Ignore:
Timestamp:
Feb 26, 2010 12:27:59 PM (11 years ago)
Author:
mjs
Message:

Formatted .cpp, .hpp, .c, .h files with "astyle -A4 -p". This matches the formatting used in the grand CBC reorganization.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/ClpModel.cpp

    r1484 r1525  
    4545ClpModel::ClpModel (bool emptyMessages) :
    4646
    47   optimizationDirection_(1),
    48   objectiveValue_(0.0),
    49   smallElement_(1.0e-20),
    50   objectiveScale_(1.0),
    51   rhsScale_(1.0),
    52   numberRows_(0),
    53   numberColumns_(0),
    54   rowActivity_(NULL),
    55   columnActivity_(NULL),
    56   dual_(NULL),
    57   reducedCost_(NULL),
    58   rowLower_(NULL),
    59   rowUpper_(NULL),
    60   objective_(NULL),
    61   rowObjective_(NULL),
    62   columnLower_(NULL),
    63   columnUpper_(NULL),
    64   matrix_(NULL),
    65   rowCopy_(NULL),
    66   scaledMatrix_(NULL),
    67   ray_(NULL),
    68   rowScale_(NULL),
    69   columnScale_(NULL),
    70   inverseRowScale_(NULL),
    71   inverseColumnScale_(NULL),
    72   scalingFlag_(3),
    73   status_(NULL),
    74   integerType_(NULL),
    75   userPointer_(NULL),
    76   trustedUserPointer_(NULL),
    77   numberIterations_(0),
    78   solveType_(0),
    79   whatsChanged_(0),
    80   problemStatus_(-1),
    81   secondaryStatus_(0),
    82   lengthNames_(0),
    83   numberThreads_(0),
    84   specialOptions_(0),
     47     optimizationDirection_(1),
     48     objectiveValue_(0.0),
     49     smallElement_(1.0e-20),
     50     objectiveScale_(1.0),
     51     rhsScale_(1.0),
     52     numberRows_(0),
     53     numberColumns_(0),
     54     rowActivity_(NULL),
     55     columnActivity_(NULL),
     56     dual_(NULL),
     57     reducedCost_(NULL),
     58     rowLower_(NULL),
     59     rowUpper_(NULL),
     60     objective_(NULL),
     61     rowObjective_(NULL),
     62     columnLower_(NULL),
     63     columnUpper_(NULL),
     64     matrix_(NULL),
     65     rowCopy_(NULL),
     66     scaledMatrix_(NULL),
     67     ray_(NULL),
     68     rowScale_(NULL),
     69     columnScale_(NULL),
     70     inverseRowScale_(NULL),
     71     inverseColumnScale_(NULL),
     72     scalingFlag_(3),
     73     status_(NULL),
     74     integerType_(NULL),
     75     userPointer_(NULL),
     76     trustedUserPointer_(NULL),
     77     numberIterations_(0),
     78     solveType_(0),
     79     whatsChanged_(0),
     80     problemStatus_(-1),
     81     secondaryStatus_(0),
     82     lengthNames_(0),
     83     numberThreads_(0),
     84     specialOptions_(0),
    8585#ifndef CLP_NO_STD
    86   defaultHandler_(true),
    87   rowNames_(),
    88   columnNames_(),
     86     defaultHandler_(true),
     87     rowNames_(),
     88     columnNames_(),
    8989#else
    90   defaultHandler_(true),
    91 #endif
    92   maximumColumns_(-1),
    93   maximumRows_(-1),
    94   maximumInternalColumns_(-1),
    95   maximumInternalRows_(-1),
    96   savedRowScale_(NULL),
    97   savedColumnScale_(NULL)
    98 {
    99   intParam_[ClpMaxNumIteration] = 2147483647;
    100   intParam_[ClpMaxNumIterationHotStart] = 9999999;
    101   intParam_[ClpNameDiscipline] = 0;
    102 
    103   dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
    104   dblParam_[ClpPrimalObjectiveLimit] = COIN_DBL_MAX;
    105   dblParam_[ClpDualTolerance] = 1e-7;
    106   dblParam_[ClpPrimalTolerance] = 1e-7;
    107   dblParam_[ClpObjOffset] = 0.0;
    108   dblParam_[ClpMaxSeconds] = -1.0;
    109   dblParam_[ClpPresolveTolerance] = 1.0e-8;
     90     defaultHandler_(true),
     91#endif
     92     maximumColumns_(-1),
     93     maximumRows_(-1),
     94     maximumInternalColumns_(-1),
     95     maximumInternalRows_(-1),
     96     savedRowScale_(NULL),
     97     savedColumnScale_(NULL)
     98{
     99     intParam_[ClpMaxNumIteration] = 2147483647;
     100     intParam_[ClpMaxNumIterationHotStart] = 9999999;
     101     intParam_[ClpNameDiscipline] = 0;
     102
     103     dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
     104     dblParam_[ClpPrimalObjectiveLimit] = COIN_DBL_MAX;
     105     dblParam_[ClpDualTolerance] = 1e-7;
     106     dblParam_[ClpPrimalTolerance] = 1e-7;
     107     dblParam_[ClpObjOffset] = 0.0;
     108     dblParam_[ClpMaxSeconds] = -1.0;
     109     dblParam_[ClpPresolveTolerance] = 1.0e-8;
    110110
    111111#ifndef CLP_NO_STD
    112   strParam_[ClpProbName] = "ClpDefaultName";
    113 #endif
    114   handler_ = new CoinMessageHandler();
    115   handler_->setLogLevel(1);
    116   eventHandler_ = new ClpEventHandler();
    117   if (!emptyMessages) {
    118     messages_ = ClpMessage();
    119     coinMessages_ = CoinMessage();
    120   }
    121   randomNumberGenerator_.setSeed(1234567);
     112     strParam_[ClpProbName] = "ClpDefaultName";
     113#endif
     114     handler_ = new CoinMessageHandler();
     115     handler_->setLogLevel(1);
     116     eventHandler_ = new ClpEventHandler();
     117     if (!emptyMessages) {
     118          messages_ = ClpMessage();
     119          coinMessages_ = CoinMessage();
     120     }
     121     randomNumberGenerator_.setSeed(1234567);
    122122}
    123123
     
    126126ClpModel::~ClpModel ()
    127127{
    128   if (defaultHandler_) {
    129     delete handler_;
    130     handler_ = NULL;
    131   }
    132   gutsOfDelete(0);
     128     if (defaultHandler_) {
     129          delete handler_;
     130          handler_ = NULL;
     131     }
     132     gutsOfDelete(0);
    133133}
    134134// Does most of deletion (0 = all, 1 = most)
    135 void 
     135void
    136136ClpModel::gutsOfDelete(int type)
    137137{
    138   if (!type||!permanentArrays()) {
    139     maximumRows_=-1;
    140     maximumColumns_ = -1;
    141     delete [] rowActivity_;
    142     rowActivity_=NULL;
    143     delete [] columnActivity_;
    144     columnActivity_=NULL;
    145     delete [] dual_;
    146     dual_=NULL;
    147     delete [] reducedCost_;
    148     reducedCost_=NULL;
    149     delete [] rowLower_;
    150     delete [] rowUpper_;
    151     delete [] rowObjective_;
    152     rowLower_=NULL;
    153     rowUpper_=NULL;
    154     rowObjective_=NULL;
    155     delete [] columnLower_;
    156     delete [] columnUpper_;
    157     delete objective_;
    158     columnLower_=NULL;
    159     columnUpper_=NULL;
    160     objective_=NULL;
    161     delete [] savedRowScale_;
    162     if (rowScale_==savedRowScale_)
    163       rowScale_=NULL;
    164     savedRowScale_ = NULL;
    165     delete [] savedColumnScale_;
    166     if (columnScale_==savedColumnScale_)
    167       columnScale_=NULL;
    168     savedColumnScale_ = NULL;
    169     delete [] rowScale_;
    170     rowScale_ = NULL;
    171     delete [] columnScale_;
    172     columnScale_ = NULL;
    173     delete [] integerType_;
    174     integerType_ = NULL;
    175     delete [] status_;
    176     status_=NULL;
    177     delete eventHandler_;
    178     eventHandler_=NULL;
    179   }
    180   whatsChanged_ = 0;
    181   delete matrix_;
    182   matrix_=NULL;
    183   delete rowCopy_;
    184   rowCopy_=NULL;
    185   delete scaledMatrix_;
    186   scaledMatrix_=NULL,
    187   delete [] ray_;
    188   ray_ = NULL;
    189   specialOptions_ = 0;
    190 }
    191 void 
    192 ClpModel::setRowScale(double * scale) 
    193 {
    194   if (!savedRowScale_) {
    195     delete [] reinterpret_cast<double *> (rowScale_);
    196     rowScale_ = scale;
    197   } else {
    198     assert (!scale);
    199     rowScale_ = NULL;
    200   }
    201 }
    202 void 
    203 ClpModel::setColumnScale(double * scale) 
    204 {
    205   if (!savedColumnScale_) {
    206     delete [] reinterpret_cast<double *> (columnScale_);
    207     columnScale_ = scale;
    208   } else {
    209     assert (!scale);
    210     columnScale_ = NULL;
    211   }
     138     if (!type || !permanentArrays()) {
     139          maximumRows_ = -1;
     140          maximumColumns_ = -1;
     141          delete [] rowActivity_;
     142          rowActivity_ = NULL;
     143          delete [] columnActivity_;
     144          columnActivity_ = NULL;
     145          delete [] dual_;
     146          dual_ = NULL;
     147          delete [] reducedCost_;
     148          reducedCost_ = NULL;
     149          delete [] rowLower_;
     150          delete [] rowUpper_;
     151          delete [] rowObjective_;
     152          rowLower_ = NULL;
     153          rowUpper_ = NULL;
     154          rowObjective_ = NULL;
     155          delete [] columnLower_;
     156          delete [] columnUpper_;
     157          delete objective_;
     158          columnLower_ = NULL;
     159          columnUpper_ = NULL;
     160          objective_ = NULL;
     161          delete [] savedRowScale_;
     162          if (rowScale_ == savedRowScale_)
     163               rowScale_ = NULL;
     164          savedRowScale_ = NULL;
     165          delete [] savedColumnScale_;
     166          if (columnScale_ == savedColumnScale_)
     167               columnScale_ = NULL;
     168          savedColumnScale_ = NULL;
     169          delete [] rowScale_;
     170          rowScale_ = NULL;
     171          delete [] columnScale_;
     172          columnScale_ = NULL;
     173          delete [] integerType_;
     174          integerType_ = NULL;
     175          delete [] status_;
     176          status_ = NULL;
     177          delete eventHandler_;
     178          eventHandler_ = NULL;
     179     }
     180     whatsChanged_ = 0;
     181     delete matrix_;
     182     matrix_ = NULL;
     183     delete rowCopy_;
     184     rowCopy_ = NULL;
     185     delete scaledMatrix_;
     186     scaledMatrix_ = NULL,
     187     delete [] ray_;
     188     ray_ = NULL;
     189     specialOptions_ = 0;
     190}
     191void
     192ClpModel::setRowScale(double * scale)
     193{
     194     if (!savedRowScale_) {
     195          delete [] reinterpret_cast<double *> (rowScale_);
     196          rowScale_ = scale;
     197     } else {
     198          assert (!scale);
     199          rowScale_ = NULL;
     200     }
     201}
     202void
     203ClpModel::setColumnScale(double * scale)
     204{
     205     if (!savedColumnScale_) {
     206          delete [] reinterpret_cast<double *> (columnScale_);
     207          columnScale_ = scale;
     208     } else {
     209          assert (!scale);
     210          columnScale_ = NULL;
     211     }
    212212}
    213213//#############################################################################
    214 void ClpModel::setPrimalTolerance( double value) 
    215 {
    216   if (value>0.0&&value<1.0e10)
    217     dblParam_[ClpPrimalTolerance]=value;
    218 }
    219 void ClpModel::setDualTolerance( double value) 
    220 {
    221   if (value>0.0&&value<1.0e10)
    222     dblParam_[ClpDualTolerance]=value;
    223 }
    224 void ClpModel::setOptimizationDirection( double value) 
    225 {
    226   optimizationDirection_=value;
    227 }
    228 void
    229 ClpModel::gutsOfLoadModel (int numberRows, int numberColumns, 
    230                      const double* collb, const double* colub,   
    231                      const double* obj,
    232                      const double* rowlb, const double* rowub,
    233                                 const double * rowObjective)
    234 {
    235   // save event handler in case already set
    236   ClpEventHandler * handler = eventHandler_->clone();
    237   // Save specialOptions
    238   int saveOptions = specialOptions_;
    239   gutsOfDelete(0);
    240   specialOptions_ = saveOptions;
    241   eventHandler_ = handler;
    242   numberRows_=numberRows;
    243   numberColumns_=numberColumns;
    244   rowActivity_=new double[numberRows_];
    245   columnActivity_=new double[numberColumns_];
    246   dual_=new double[numberRows_];
    247   reducedCost_=new double[numberColumns_];
    248 
    249   CoinZeroN(dual_,numberRows_);
    250   CoinZeroN(reducedCost_,numberColumns_);
    251   int iRow,iColumn;
    252 
    253   rowLower_=ClpCopyOfArray(rowlb,numberRows_,-COIN_DBL_MAX);
    254   rowUpper_=ClpCopyOfArray(rowub,numberRows_,COIN_DBL_MAX);
    255   double * objective=ClpCopyOfArray(obj,numberColumns_,0.0);
    256   objective_ = new ClpLinearObjective(objective,numberColumns_);
    257   delete [] objective;
    258   rowObjective_=ClpCopyOfArray(rowObjective,numberRows_);
    259   columnLower_=ClpCopyOfArray(collb,numberColumns_,0.0);
    260   columnUpper_=ClpCopyOfArray(colub,numberColumns_,COIN_DBL_MAX);
    261   // set default solution and clean bounds
    262   for (iRow=0;iRow<numberRows_;iRow++) {
    263     if (rowLower_[iRow]>0.0) {
    264       rowActivity_[iRow]=rowLower_[iRow];
    265     } else if (rowUpper_[iRow]<0.0) {
    266       rowActivity_[iRow]=rowUpper_[iRow];
    267     } else {
    268       rowActivity_[iRow]=0.0;
    269     }
    270     if (rowLower_[iRow]<-1.0e27)
    271       rowLower_[iRow]=-COIN_DBL_MAX;
    272     if (rowUpper_[iRow]>1.0e27)
    273       rowUpper_[iRow]=COIN_DBL_MAX;
    274   }
    275   for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    276     if (columnLower_[iColumn]>0.0) {
    277       columnActivity_[iColumn]=columnLower_[iColumn];
    278     } else if (columnUpper_[iColumn]<0.0) {
    279       columnActivity_[iColumn]=columnUpper_[iColumn];
    280     } else {
    281       columnActivity_[iColumn]=0.0;
    282     }
    283     if (columnLower_[iColumn]<-1.0e27)
    284       columnLower_[iColumn]=-COIN_DBL_MAX;
    285     if (columnUpper_[iColumn]>1.0e27)
    286       columnUpper_[iColumn]=COIN_DBL_MAX;
    287   }
     214void ClpModel::setPrimalTolerance( double value)
     215{
     216     if (value > 0.0 && value < 1.0e10)
     217          dblParam_[ClpPrimalTolerance] = value;
     218}
     219void ClpModel::setDualTolerance( double value)
     220{
     221     if (value > 0.0 && value < 1.0e10)
     222          dblParam_[ClpDualTolerance] = value;
     223}
     224void ClpModel::setOptimizationDirection( double value)
     225{
     226     optimizationDirection_ = value;
     227}
     228void
     229ClpModel::gutsOfLoadModel (int numberRows, int numberColumns,
     230                           const double* collb, const double* colub,
     231                           const double* obj,
     232                           const double* rowlb, const double* rowub,
     233                           const double * rowObjective)
     234{
     235     // save event handler in case already set
     236     ClpEventHandler * handler = eventHandler_->clone();
     237     // Save specialOptions
     238     int saveOptions = specialOptions_;
     239     gutsOfDelete(0);
     240     specialOptions_ = saveOptions;
     241     eventHandler_ = handler;
     242     numberRows_ = numberRows;
     243     numberColumns_ = numberColumns;
     244     rowActivity_ = new double[numberRows_];
     245     columnActivity_ = new double[numberColumns_];
     246     dual_ = new double[numberRows_];
     247     reducedCost_ = new double[numberColumns_];
     248
     249     CoinZeroN(dual_, numberRows_);
     250     CoinZeroN(reducedCost_, numberColumns_);
     251     int iRow, iColumn;
     252
     253     rowLower_ = ClpCopyOfArray(rowlb, numberRows_, -COIN_DBL_MAX);
     254     rowUpper_ = ClpCopyOfArray(rowub, numberRows_, COIN_DBL_MAX);
     255     double * objective = ClpCopyOfArray(obj, numberColumns_, 0.0);
     256     objective_ = new ClpLinearObjective(objective, numberColumns_);
     257     delete [] objective;
     258     rowObjective_ = ClpCopyOfArray(rowObjective, numberRows_);
     259     columnLower_ = ClpCopyOfArray(collb, numberColumns_, 0.0);
     260     columnUpper_ = ClpCopyOfArray(colub, numberColumns_, COIN_DBL_MAX);
     261     // set default solution and clean bounds
     262     for (iRow = 0; iRow < numberRows_; iRow++) {
     263          if (rowLower_[iRow] > 0.0) {
     264               rowActivity_[iRow] = rowLower_[iRow];
     265          } else if (rowUpper_[iRow] < 0.0) {
     266               rowActivity_[iRow] = rowUpper_[iRow];
     267          } else {
     268               rowActivity_[iRow] = 0.0;
     269          }
     270          if (rowLower_[iRow] < -1.0e27)
     271               rowLower_[iRow] = -COIN_DBL_MAX;
     272          if (rowUpper_[iRow] > 1.0e27)
     273               rowUpper_[iRow] = COIN_DBL_MAX;
     274     }
     275     for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     276          if (columnLower_[iColumn] > 0.0) {
     277               columnActivity_[iColumn] = columnLower_[iColumn];
     278          } else if (columnUpper_[iColumn] < 0.0) {
     279               columnActivity_[iColumn] = columnUpper_[iColumn];
     280          } else {
     281               columnActivity_[iColumn] = 0.0;
     282          }
     283          if (columnLower_[iColumn] < -1.0e27)
     284               columnLower_[iColumn] = -COIN_DBL_MAX;
     285          if (columnUpper_[iColumn] > 1.0e27)
     286               columnUpper_[iColumn] = COIN_DBL_MAX;
     287     }
    288288}
    289289// This just loads up a row objective
    290290void ClpModel::setRowObjective(const double * rowObjective)
    291291{
    292   delete [] rowObjective_;
    293   rowObjective_=ClpCopyOfArray(rowObjective,numberRows_);
    294   whatsChanged_ = 0;
     292     delete [] rowObjective_;
     293     rowObjective_ = ClpCopyOfArray(rowObjective, numberRows_);
     294     whatsChanged_ = 0;
    295295}
    296296void
    297297ClpModel::loadProblem (  const ClpMatrixBase& matrix,
    298                      const double* collb, const double* colub,   
    299                      const double* obj,
    300                      const double* rowlb, const double* rowub,
    301                                 const double * rowObjective)
    302 {
    303   gutsOfLoadModel(matrix.getNumRows(),matrix.getNumCols(),
    304                   collb, colub, obj, rowlb, rowub, rowObjective);
    305   if (matrix.isColOrdered()) {
    306     matrix_=matrix.clone();
    307   } else {
    308     // later may want to keep as unknown class
    309     CoinPackedMatrix matrix2;
    310     matrix2.setExtraGap(0.0);
    311     matrix2.setExtraMajor(0.0);
    312     matrix2.reverseOrderedCopyOf(*matrix.getPackedMatrix());
    313     matrix.releasePackedMatrix();
    314     matrix_=new ClpPackedMatrix(matrix2);
    315   }   
    316   matrix_->setDimensions(numberRows_,numberColumns_);
     298                         const double* collb, const double* colub,
     299                         const double* obj,
     300                         const double* rowlb, const double* rowub,
     301                         const double * rowObjective)
     302{
     303     gutsOfLoadModel(matrix.getNumRows(), matrix.getNumCols(),
     304                     collb, colub, obj, rowlb, rowub, rowObjective);
     305     if (matrix.isColOrdered()) {
     306          matrix_ = matrix.clone();
     307     } else {
     308          // later may want to keep as unknown class
     309          CoinPackedMatrix matrix2;
     310          matrix2.setExtraGap(0.0);
     311          matrix2.setExtraMajor(0.0);
     312          matrix2.reverseOrderedCopyOf(*matrix.getPackedMatrix());
     313          matrix.releasePackedMatrix();
     314          matrix_ = new ClpPackedMatrix(matrix2);
     315     }
     316     matrix_->setDimensions(numberRows_, numberColumns_);
    317317}
    318318void
    319319ClpModel::loadProblem (  const CoinPackedMatrix& matrix,
    320                      const double* collb, const double* colub,   
    321                      const double* obj,
    322                      const double* rowlb, const double* rowub,
    323                                 const double * rowObjective)
    324 {
    325   ClpPackedMatrix* clpMatrix =
    326     dynamic_cast< ClpPackedMatrix*>(matrix_);
    327   bool special = (clpMatrix) ? clpMatrix->wantsSpecialColumnCopy() : false;
    328   gutsOfLoadModel(matrix.getNumRows(),matrix.getNumCols(),
    329                   collb, colub, obj, rowlb, rowub, rowObjective);
    330   if (matrix.isColOrdered()) {
    331     matrix_=new ClpPackedMatrix(matrix);
    332     if (special) {
    333       clpMatrix = static_cast< ClpPackedMatrix*>(matrix_);
    334       clpMatrix->makeSpecialColumnCopy();
    335     }
    336   } else {
    337     CoinPackedMatrix matrix2;
    338     matrix2.setExtraGap(0.0);
    339     matrix2.setExtraMajor(0.0);
    340     matrix2.reverseOrderedCopyOf(matrix);
    341     matrix_=new ClpPackedMatrix(matrix2);
    342   }   
    343   matrix_->setDimensions(numberRows_,numberColumns_);
    344 }
    345 void
    346 ClpModel::loadProblem ( 
    347                               const int numcols, const int numrows,
    348                               const CoinBigIndex* start, const int* index,
    349                               const double* value,
    350                               const double* collb, const double* colub,   
    351                               const double* obj,
    352                               const double* rowlb, const double* rowub,
    353                               const double * rowObjective)
    354 {
    355   gutsOfLoadModel(numrows, numcols,
    356                   collb, colub, obj, rowlb, rowub, rowObjective);
    357   int numberElements = start ? start[numcols] : 0;
    358   CoinPackedMatrix matrix(true,numrows,numrows ? numcols : 0,numberElements,
    359                               value,index,start,NULL);
    360   matrix_ = new ClpPackedMatrix(matrix);
    361   matrix_->setDimensions(numberRows_,numberColumns_);
    362 }
    363 void
    364 ClpModel::loadProblem ( 
    365                               const int numcols, const int numrows,
    366                               const CoinBigIndex* start, const int* index,
    367                               const double* value,const int* length,
    368                               const double* collb, const double* colub,   
    369                               const double* obj,
    370                               const double* rowlb, const double* rowub,
    371                               const double * rowObjective)
    372 {
    373   gutsOfLoadModel(numrows, numcols,
    374                   collb, colub, obj, rowlb, rowub, rowObjective);
    375   // Compute number of elements
    376   int numberElements = 0;
    377   int i;
    378   for (i=0;i<numcols;i++)
    379     numberElements += length[i];
    380   CoinPackedMatrix matrix(true,numrows,numcols,numberElements,
    381                               value,index,start,length);
    382   matrix_ = new ClpPackedMatrix(matrix);
     320                         const double* collb, const double* colub,
     321                         const double* obj,
     322                         const double* rowlb, const double* rowub,
     323                         const double * rowObjective)
     324{
     325     ClpPackedMatrix* clpMatrix =
     326          dynamic_cast< ClpPackedMatrix*>(matrix_);
     327     bool special = (clpMatrix) ? clpMatrix->wantsSpecialColumnCopy() : false;
     328     gutsOfLoadModel(matrix.getNumRows(), matrix.getNumCols(),
     329                     collb, colub, obj, rowlb, rowub, rowObjective);
     330     if (matrix.isColOrdered()) {
     331          matrix_ = new ClpPackedMatrix(matrix);
     332          if (special) {
     333               clpMatrix = static_cast< ClpPackedMatrix*>(matrix_);
     334               clpMatrix->makeSpecialColumnCopy();
     335          }
     336     } else {
     337          CoinPackedMatrix matrix2;
     338          matrix2.setExtraGap(0.0);
     339          matrix2.setExtraMajor(0.0);
     340          matrix2.reverseOrderedCopyOf(matrix);
     341          matrix_ = new ClpPackedMatrix(matrix2);
     342     }
     343     matrix_->setDimensions(numberRows_, numberColumns_);
     344}
     345void
     346ClpModel::loadProblem (
     347     const int numcols, const int numrows,
     348     const CoinBigIndex* start, const int* index,
     349     const double* value,
     350     const double* collb, const double* colub,
     351     const double* obj,
     352     const double* rowlb, const double* rowub,
     353     const double * rowObjective)
     354{
     355     gutsOfLoadModel(numrows, numcols,
     356                     collb, colub, obj, rowlb, rowub, rowObjective);
     357     int numberElements = start ? start[numcols] : 0;
     358     CoinPackedMatrix matrix(true, numrows, numrows ? numcols : 0, numberElements,
     359                             value, index, start, NULL);
     360     matrix_ = new ClpPackedMatrix(matrix);
     361     matrix_->setDimensions(numberRows_, numberColumns_);
     362}
     363void
     364ClpModel::loadProblem (
     365     const int numcols, const int numrows,
     366     const CoinBigIndex* start, const int* index,
     367     const double* value, const int* length,
     368     const double* collb, const double* colub,
     369     const double* obj,
     370     const double* rowlb, const double* rowub,
     371     const double * rowObjective)
     372{
     373     gutsOfLoadModel(numrows, numcols,
     374                     collb, colub, obj, rowlb, rowub, rowObjective);
     375     // Compute number of elements
     376     int numberElements = 0;
     377     int i;
     378     for (i = 0; i < numcols; i++)
     379          numberElements += length[i];
     380     CoinPackedMatrix matrix(true, numrows, numcols, numberElements,
     381                             value, index, start, length);
     382     matrix_ = new ClpPackedMatrix(matrix);
    383383}
    384384#ifndef SLIM_NOIO
    385385// This loads a model from a coinModel object - returns number of errors
    386 int 
    387 ClpModel::loadProblem (  CoinModel & modelObject,bool tryPlusMinusOne)
    388 {
    389   if (modelObject.numberColumns()==0&&modelObject.numberRows()==0)
    390     return 0;
    391   int numberErrors = 0;
    392   // Set arrays for normal use
    393   double * rowLower = modelObject.rowLowerArray();
    394   double * rowUpper = modelObject.rowUpperArray();
    395   double * columnLower = modelObject.columnLowerArray();
    396   double * columnUpper = modelObject.columnUpperArray();
    397   double * objective = modelObject.objectiveArray();
    398   int * integerType = modelObject.integerTypeArray();
    399   double * associated = modelObject.associatedArray();
    400   // If strings then do copies
    401   if (modelObject.stringsExist()) {
    402     numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
    403                                             objective, integerType,associated);
    404   }
    405   int numberRows = modelObject.numberRows();
    406   int numberColumns = modelObject.numberColumns();
    407   gutsOfLoadModel(numberRows, numberColumns,
    408                   columnLower, columnUpper, objective, rowLower, rowUpper, NULL);
    409   setObjectiveOffset(modelObject.objectiveOffset());
    410   CoinBigIndex * startPositive = NULL;
    411   CoinBigIndex * startNegative = NULL;
    412   delete matrix_;
    413   if (tryPlusMinusOne) {
    414     startPositive = new CoinBigIndex[numberColumns+1];
    415     startNegative = new CoinBigIndex[numberColumns];
    416     modelObject.countPlusMinusOne(startPositive,startNegative,associated);
    417     if (startPositive[0]<0) {
    418       // no good
    419       tryPlusMinusOne=false;
    420       delete [] startPositive;
    421       delete [] startNegative;
    422     }
    423   }
     386int
     387ClpModel::loadProblem (  CoinModel & modelObject, bool tryPlusMinusOne)
     388{
     389     if (modelObject.numberColumns() == 0 && modelObject.numberRows() == 0)
     390          return 0;
     391     int numberErrors = 0;
     392     // Set arrays for normal use
     393     double * rowLower = modelObject.rowLowerArray();
     394     double * rowUpper = modelObject.rowUpperArray();
     395     double * columnLower = modelObject.columnLowerArray();
     396     double * columnUpper = modelObject.columnUpperArray();
     397     double * objective = modelObject.objectiveArray();
     398     int * integerType = modelObject.integerTypeArray();
     399     double * associated = modelObject.associatedArray();
     400     // If strings then do copies
     401     if (modelObject.stringsExist()) {
     402          numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
     403                                                  objective, integerType, associated);
     404     }
     405     int numberRows = modelObject.numberRows();
     406     int numberColumns = modelObject.numberColumns();
     407     gutsOfLoadModel(numberRows, numberColumns,
     408                     columnLower, columnUpper, objective, rowLower, rowUpper, NULL);
     409     setObjectiveOffset(modelObject.objectiveOffset());
     410     CoinBigIndex * startPositive = NULL;
     411     CoinBigIndex * startNegative = NULL;
     412     delete matrix_;
     413     if (tryPlusMinusOne) {
     414          startPositive = new CoinBigIndex[numberColumns+1];
     415          startNegative = new CoinBigIndex[numberColumns];
     416          modelObject.countPlusMinusOne(startPositive, startNegative, associated);
     417          if (startPositive[0] < 0) {
     418               // no good
     419               tryPlusMinusOne = false;
     420               delete [] startPositive;
     421               delete [] startNegative;
     422          }
     423     }
    424424#ifndef SLIM_CLP
    425   if (!tryPlusMinusOne) {
    426 #endif
    427     CoinPackedMatrix matrix;
    428     modelObject.createPackedMatrix(matrix,associated);
    429     matrix_ = new ClpPackedMatrix(matrix);
     425     if (!tryPlusMinusOne) {
     426#endif
     427          CoinPackedMatrix matrix;
     428          modelObject.createPackedMatrix(matrix, associated);
     429          matrix_ = new ClpPackedMatrix(matrix);
    430430#ifndef SLIM_CLP
    431   } else {
    432     // create +-1 matrix
    433     CoinBigIndex size = startPositive[numberColumns];
    434     int * indices = new int[size];
    435     modelObject.createPlusMinusOne(startPositive,startNegative,indices,
    436                                    associated);
    437     // Get good object
    438     ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    439     matrix->passInCopy(numberRows,numberColumns,
    440                        true,indices,startPositive,startNegative);
    441     matrix_=matrix;
    442   }
     431     } else {
     432          // create +-1 matrix
     433          CoinBigIndex size = startPositive[numberColumns];
     434          int * indices = new int[size];
     435          modelObject.createPlusMinusOne(startPositive, startNegative, indices,
     436                                         associated);
     437          // Get good object
     438          ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
     439          matrix->passInCopy(numberRows, numberColumns,
     440                             true, indices, startPositive, startNegative);
     441          matrix_ = matrix;
     442     }
    443443#endif
    444444#ifndef CLP_NO_STD
    445   // Do names if wanted
    446   int numberItems;
    447   numberItems = modelObject.rowNames()->numberItems();
    448   if (numberItems) {
    449     const char *const * rowNames=modelObject.rowNames()->names();
    450     copyRowNames(rowNames,0,numberItems);
    451   }
    452   numberItems = modelObject.columnNames()->numberItems();
    453   if (numberItems) {
    454     const char *const * columnNames=modelObject.columnNames()->names();
    455     copyColumnNames(columnNames,0,numberItems);
    456   }
    457 #endif
    458   // Do integers if wanted
    459   assert(integerType);
    460   for (int iColumn=0;iColumn<numberColumns;iColumn++) {
    461     if (integerType[iColumn])
    462       setInteger(iColumn);
    463   }
    464   if (rowLower!=modelObject.rowLowerArray()||
    465       columnLower!=modelObject.columnLowerArray()) {
    466     delete [] rowLower;
    467     delete [] rowUpper;
    468     delete [] columnLower;
    469     delete [] columnUpper;
    470     delete [] objective;
    471     delete [] integerType;
    472     delete [] associated;
    473     if (numberErrors)
    474       handler_->message(CLP_BAD_STRING_VALUES,messages_)
    475         <<numberErrors
    476         <<CoinMessageEol;
    477   }
    478   matrix_->setDimensions(numberRows_,numberColumns_);
    479   return numberErrors;
     445     // Do names if wanted
     446     int numberItems;
     447     numberItems = modelObject.rowNames()->numberItems();
     448     if (numberItems) {
     449          const char *const * rowNames = modelObject.rowNames()->names();
     450          copyRowNames(rowNames, 0, numberItems);
     451     }
     452     numberItems = modelObject.columnNames()->numberItems();
     453     if (numberItems) {
     454          const char *const * columnNames = modelObject.columnNames()->names();
     455          copyColumnNames(columnNames, 0, numberItems);
     456     }
     457#endif
     458     // Do integers if wanted
     459     assert(integerType);
     460     for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     461          if (integerType[iColumn])
     462               setInteger(iColumn);
     463     }
     464     if (rowLower != modelObject.rowLowerArray() ||
     465               columnLower != modelObject.columnLowerArray()) {
     466          delete [] rowLower;
     467          delete [] rowUpper;
     468          delete [] columnLower;
     469          delete [] columnUpper;
     470          delete [] objective;
     471          delete [] integerType;
     472          delete [] associated;
     473          if (numberErrors)
     474               handler_->message(CLP_BAD_STRING_VALUES, messages_)
     475                         << numberErrors
     476                         << CoinMessageEol;
     477     }
     478     matrix_->setDimensions(numberRows_, numberColumns_);
     479     return numberErrors;
    480480}
    481481#endif
     
    483483ClpModel::getRowBound(int iRow, double& lower, double& upper) const
    484484{
    485   lower=-COIN_DBL_MAX;
    486   upper=COIN_DBL_MAX;
    487   if (rowUpper_)
    488     upper=rowUpper_[iRow];
    489   if (rowLower_)
    490     lower=rowLower_[iRow];
     485     lower = -COIN_DBL_MAX;
     486     upper = COIN_DBL_MAX;
     487     if (rowUpper_)
     488          upper = rowUpper_[iRow];
     489     if (rowLower_)
     490          lower = rowLower_[iRow];
    491491}
    492492//------------------------------------------------------------------
     
    495495// only called in debug mode
    496496static void indexError(int index,
    497                         std::string methodName)
    498 {
    499   std::cerr<<"Illegal index "<<index<<" in ClpModel::"<<methodName<<std::endl;
    500   throw CoinError("Illegal index",methodName,"ClpModel");
     497                       std::string methodName)
     498{
     499     std::cerr << "Illegal index " << index << " in ClpModel::" << methodName << std::endl;
     500     throw CoinError("Illegal index", methodName, "ClpModel");
    501501}
    502502#endif
    503503/* Set an objective function coefficient */
    504 void 
     504void
    505505ClpModel::setObjectiveCoefficient( int elementIndex, double elementValue )
    506506{
    507507#ifndef NDEBUG
    508   if (elementIndex<0||elementIndex>=numberColumns_) {
    509     indexError(elementIndex,"setObjectiveCoefficient");
    510   }
    511 #endif
    512   objective()[elementIndex] = elementValue;
    513   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     508     if (elementIndex < 0 || elementIndex >= numberColumns_) {
     509          indexError(elementIndex, "setObjectiveCoefficient");
     510     }
     511#endif
     512     objective()[elementIndex] = elementValue;
     513     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    514514}
    515515/* Set a single row lower bound<br>
    516516   Use -DBL_MAX for -infinity. */
    517 void
    518 ClpModel::setRowLower( int elementIndex, double elementValue ) {
    519   if (elementValue<-1.0e27)
    520     elementValue=-COIN_DBL_MAX;
    521   rowLower_[elementIndex] = elementValue;
    522   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    523 }
    524      
     517void
     518ClpModel::setRowLower( int elementIndex, double elementValue )
     519{
     520     if (elementValue < -1.0e27)
     521          elementValue = -COIN_DBL_MAX;
     522     rowLower_[elementIndex] = elementValue;
     523     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     524}
     525
    525526/* Set a single row upper bound<br>
    526527   Use DBL_MAX for infinity. */
    527 void
    528 ClpModel::setRowUpper( int elementIndex, double elementValue ) {
    529   if (elementValue>1.0e27)
    530     elementValue=COIN_DBL_MAX;
    531   rowUpper_[elementIndex] = elementValue;
    532   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    533 }
    534    
     528void
     529ClpModel::setRowUpper( int elementIndex, double elementValue )
     530{
     531     if (elementValue > 1.0e27)
     532          elementValue = COIN_DBL_MAX;
     533     rowUpper_[elementIndex] = elementValue;
     534     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     535}
     536
    535537/* Set a single row lower and upper bound */
    536 void 
     538void
    537539ClpModel::setRowBounds( int elementIndex,
    538               double lower, double upper ) {
    539   if (lower<-1.0e27)
    540     lower=-COIN_DBL_MAX;
    541   if (upper>1.0e27)
    542     upper=COIN_DBL_MAX;
    543   CoinAssert (upper>=lower);
    544   rowLower_[elementIndex] = lower;
    545   rowUpper_[elementIndex] = upper;
    546   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     540                        double lower, double upper )
     541{
     542     if (lower < -1.0e27)
     543          lower = -COIN_DBL_MAX;
     544     if (upper > 1.0e27)
     545          upper = COIN_DBL_MAX;
     546     CoinAssert (upper >= lower);
     547     rowLower_[elementIndex] = lower;
     548     rowUpper_[elementIndex] = upper;
     549     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    547550}
    548551void ClpModel::setRowSetBounds(const int* indexFirst,
    549                                             const int* indexLast,
    550                                             const double* boundList)
     552                               const int* indexLast,
     553                               const double* boundList)
    551554{
    552555#ifndef NDEBUG
    553   int n = numberRows_;
    554 #endif
    555   double * lower = rowLower_;
    556   double * upper = rowUpper_;
    557   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    558   while (indexFirst != indexLast) {
    559     const int iRow=*indexFirst++;
     556     int n = numberRows_;
     557#endif
     558     double * lower = rowLower_;
     559     double * upper = rowUpper_;
     560     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     561     while (indexFirst != indexLast) {
     562          const int iRow = *indexFirst++;
    560563#ifndef NDEBUG
    561     if (iRow<0||iRow>=n) {
    562       indexError(iRow,"setRowSetBounds");
    563     }
    564 #endif
    565     lower[iRow]= *boundList++;
    566     upper[iRow]= *boundList++;
    567     if (lower[iRow]<-1.0e27)
    568       lower[iRow]=-COIN_DBL_MAX;
    569     if (upper[iRow]>1.0e27)
    570       upper[iRow]=COIN_DBL_MAX;
    571     CoinAssert (upper[iRow]>=lower[iRow]);
    572   }
     564          if (iRow < 0 || iRow >= n) {
     565               indexError(iRow, "setRowSetBounds");
     566          }
     567#endif
     568          lower[iRow] = *boundList++;
     569          upper[iRow] = *boundList++;
     570          if (lower[iRow] < -1.0e27)
     571               lower[iRow] = -COIN_DBL_MAX;
     572          if (upper[iRow] > 1.0e27)
     573               upper[iRow] = COIN_DBL_MAX;
     574          CoinAssert (upper[iRow] >= lower[iRow]);
     575     }
    573576}
    574577//-----------------------------------------------------------------------------
    575578/* Set a single column lower bound<br>
    576579   Use -DBL_MAX for -infinity. */
    577 void 
     580void
    578581ClpModel::setColumnLower( int elementIndex, double elementValue )
    579582{
    580583#ifndef NDEBUG
    581   int n = numberColumns_;
    582   if (elementIndex<0||elementIndex>=n) {
    583     indexError(elementIndex,"setColumnLower");
    584   }
    585 #endif
    586   if (elementValue<-1.0e27)
    587     elementValue=-COIN_DBL_MAX;
    588   columnLower_[elementIndex] = elementValue;
    589   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    590 }
    591      
     584     int n = numberColumns_;
     585     if (elementIndex < 0 || elementIndex >= n) {
     586          indexError(elementIndex, "setColumnLower");
     587     }
     588#endif
     589     if (elementValue < -1.0e27)
     590          elementValue = -COIN_DBL_MAX;
     591     columnLower_[elementIndex] = elementValue;
     592     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     593}
     594
    592595/* Set a single column upper bound<br>
    593596   Use DBL_MAX for infinity. */
    594 void 
     597void
    595598ClpModel::setColumnUpper( int elementIndex, double elementValue )
    596599{
    597600#ifndef NDEBUG
    598   int n = numberColumns_;
    599   if (elementIndex<0||elementIndex>=n) {
    600     indexError(elementIndex,"setColumnUpper");
    601   }
    602 #endif
    603   if (elementValue>1.0e27)
    604     elementValue=COIN_DBL_MAX;
    605   columnUpper_[elementIndex] = elementValue;
    606   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     601     int n = numberColumns_;
     602     if (elementIndex < 0 || elementIndex >= n) {
     603          indexError(elementIndex, "setColumnUpper");
     604     }
     605#endif
     606     if (elementValue > 1.0e27)
     607          elementValue = COIN_DBL_MAX;
     608     columnUpper_[elementIndex] = elementValue;
     609     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    607610}
    608611
    609612/* Set a single column lower and upper bound */
    610 void 
     613void
    611614ClpModel::setColumnBounds( int elementIndex,
    612                                      double lower, double upper )
     615                           double lower, double upper )
    613616{
    614617#ifndef NDEBUG
    615   int n = numberColumns_;
    616   if (elementIndex<0||elementIndex>=n) {
    617     indexError(elementIndex,"setColumnBounds");
    618   }
    619 #endif
    620   if (lower<-1.0e27)
    621     lower=-COIN_DBL_MAX;
    622   if (upper>1.0e27)
    623     upper=COIN_DBL_MAX;
    624   columnLower_[elementIndex] = lower;
    625   columnUpper_[elementIndex] = upper;
    626   CoinAssert (upper>=lower);
    627   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     618     int n = numberColumns_;
     619     if (elementIndex < 0 || elementIndex >= n) {
     620          indexError(elementIndex, "setColumnBounds");
     621     }
     622#endif
     623     if (lower < -1.0e27)
     624          lower = -COIN_DBL_MAX;
     625     if (upper > 1.0e27)
     626          upper = COIN_DBL_MAX;
     627     columnLower_[elementIndex] = lower;
     628     columnUpper_[elementIndex] = upper;
     629     CoinAssert (upper >= lower);
     630     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    628631}
    629632void ClpModel::setColumnSetBounds(const int* indexFirst,
    630                                             const int* indexLast,
    631                                             const double* boundList)
    632 {
    633   double * lower = columnLower_;
    634   double * upper = columnUpper_;
    635   whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     633                                  const int* indexLast,
     634                                  const double* boundList)
     635{
     636     double * lower = columnLower_;
     637     double * upper = columnUpper_;
     638     whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    636639#ifndef NDEBUG
    637   int n = numberColumns_;
    638 #endif
    639   while (indexFirst != indexLast) {
    640     const int iColumn=*indexFirst++;
     640     int n = numberColumns_;
     641#endif
     642     while (indexFirst != indexLast) {
     643          const int iColumn = *indexFirst++;
    641644#ifndef NDEBUG
    642     if (iColumn<0||iColumn>=n) {
    643       indexError(iColumn,"setColumnSetBounds");
    644     }
    645 #endif
    646     lower[iColumn]= *boundList++;
    647     upper[iColumn]= *boundList++;
    648     CoinAssert (upper[iColumn]>=lower[iColumn]);
    649     if (lower[iColumn]<-1.0e27)
    650       lower[iColumn]=-COIN_DBL_MAX;
    651     if (upper[iColumn]>1.0e27)
    652       upper[iColumn]=COIN_DBL_MAX;
    653   }
     645          if (iColumn < 0 || iColumn >= n) {
     646               indexError(iColumn, "setColumnSetBounds");
     647          }
     648#endif
     649          lower[iColumn] = *boundList++;
     650          upper[iColumn] = *boundList++;
     651          CoinAssert (upper[iColumn] >= lower[iColumn]);
     652          if (lower[iColumn] < -1.0e27)
     653               lower[iColumn] = -COIN_DBL_MAX;
     654          if (upper[iColumn] > 1.0e27)
     655               upper[iColumn] = COIN_DBL_MAX;
     656     }
    654657}
    655658//-----------------------------------------------------------------------------
    656659//#############################################################################
    657 // Copy constructor. 
     660// Copy constructor.
    658661ClpModel::ClpModel(const ClpModel &rhs, int scalingMode) :
    659   optimizationDirection_(rhs.optimizationDirection_),
    660   numberRows_(rhs.numberRows_),
    661   numberColumns_(rhs.numberColumns_),
    662   specialOptions_(rhs.specialOptions_),
    663   maximumColumns_(-1),
    664   maximumRows_(-1),
    665   maximumInternalColumns_(-1),
    666   maximumInternalRows_(-1),
    667   savedRowScale_(NULL),
    668   savedColumnScale_(NULL)
    669 {
    670   gutsOfCopy(rhs);
    671   if (scalingMode>=0&&matrix_&&
    672       matrix_->allElementsInRange(this,smallElement_,1.0e20)) {
    673     // really do scaling
    674     scalingFlag_=scalingMode;
    675     setRowScale(NULL);
    676     setColumnScale(NULL);
    677     delete rowCopy_; // in case odd
    678     rowCopy_=NULL;
    679     delete scaledMatrix_;
    680     scaledMatrix_=NULL;
    681     if (scalingMode&&!matrix_->scale(this)) {
    682       // scaling worked - now apply
    683       inverseRowScale_ = rowScale_+numberRows_;
    684       inverseColumnScale_ = columnScale_+numberColumns_;
    685       gutsOfScaling();
    686       // pretend not scaled
    687       scalingFlag_ = -scalingFlag_;
    688     } else {
    689       // not scaled
    690       scalingFlag_=0;
    691     }
    692   }
    693   randomNumberGenerator_.setSeed(1234567);
     662     optimizationDirection_(rhs.optimizationDirection_),
     663     numberRows_(rhs.numberRows_),
     664     numberColumns_(rhs.numberColumns_),
     665     specialOptions_(rhs.specialOptions_),
     666     maximumColumns_(-1),
     667     maximumRows_(-1),
     668     maximumInternalColumns_(-1),
     669     maximumInternalRows_(-1),
     670     savedRowScale_(NULL),
     671     savedColumnScale_(NULL)
     672{
     673     gutsOfCopy(rhs);
     674     if (scalingMode >= 0 && matrix_ &&
     675               matrix_->allElementsInRange(this, smallElement_, 1.0e20)) {
     676          // really do scaling
     677          scalingFlag_ = scalingMode;
     678          setRowScale(NULL);
     679          setColumnScale(NULL);
     680          delete rowCopy_; // in case odd
     681          rowCopy_ = NULL;
     682          delete scaledMatrix_;
     683          scaledMatrix_ = NULL;
     684          if (scalingMode && !matrix_->scale(this)) {
     685               // scaling worked - now apply
     686               inverseRowScale_ = rowScale_ + numberRows_;
     687               inverseColumnScale_ = columnScale_ + numberColumns_;
     688               gutsOfScaling();
     689               // pretend not scaled
     690               scalingFlag_ = -scalingFlag_;
     691          } else {
     692               // not scaled
     693               scalingFlag_ = 0;
     694          }
     695     }
     696     randomNumberGenerator_.setSeed(1234567);
    694697}
    695698// Assignment operator. This copies the data
    696 ClpModel & 
     699ClpModel &
    697700ClpModel::operator=(const ClpModel & rhs)
    698701{
    699   if (this != &rhs) {
    700     if (defaultHandler_) {
    701       //delete handler_;
    702       //handler_ = NULL;
    703     }
    704     gutsOfDelete(1);
    705     optimizationDirection_ = rhs.optimizationDirection_;
    706     numberRows_ = rhs.numberRows_;
    707     numberColumns_ = rhs.numberColumns_;
    708     gutsOfCopy(rhs,-1);
    709   }
    710   return *this;
     702     if (this != &rhs) {
     703          if (defaultHandler_) {
     704               //delete handler_;
     705               //handler_ = NULL;
     706          }
     707          gutsOfDelete(1);
     708          optimizationDirection_ = rhs.optimizationDirection_;
     709          numberRows_ = rhs.numberRows_;
     710          numberColumns_ = rhs.numberColumns_;
     711          gutsOfCopy(rhs, -1);
     712     }
     713     return *this;
    711714}
    712715/* Does most of copying
    713    If trueCopy 0 then just points to arrays 
     716   If trueCopy 0 then just points to arrays
    714717   If -1 leaves as much as possible */
    715 void 
     718void
    716719ClpModel::gutsOfCopy(const ClpModel & rhs, int trueCopy)
    717720{
    718   defaultHandler_ = rhs.defaultHandler_;
    719   if (trueCopy>=0) {
    720     if (defaultHandler_)
    721       handler_ = new CoinMessageHandler(*rhs.handler_);
    722     else
    723       handler_ = rhs.handler_;
    724     eventHandler_ = rhs.eventHandler_->clone();
    725     randomNumberGenerator_ = rhs.randomNumberGenerator_;
    726     messages_ = rhs.messages_;
    727     coinMessages_ = rhs.coinMessages_;
    728   } else {
    729     if (!eventHandler_&&rhs.eventHandler_)
    730       eventHandler_ = rhs.eventHandler_->clone();
    731   }
    732   intParam_[ClpMaxNumIteration] = rhs.intParam_[ClpMaxNumIteration];
    733   intParam_[ClpMaxNumIterationHotStart] =
    734     rhs.intParam_[ClpMaxNumIterationHotStart];
    735   intParam_[ClpNameDiscipline] = rhs.intParam_[ClpNameDiscipline] ;
    736 
    737   dblParam_[ClpDualObjectiveLimit] = rhs.dblParam_[ClpDualObjectiveLimit];
    738   dblParam_[ClpPrimalObjectiveLimit] = rhs.dblParam_[ClpPrimalObjectiveLimit];
    739   dblParam_[ClpDualTolerance] = rhs.dblParam_[ClpDualTolerance];
    740   dblParam_[ClpPrimalTolerance] = rhs.dblParam_[ClpPrimalTolerance];
    741   dblParam_[ClpObjOffset] = rhs.dblParam_[ClpObjOffset];
    742   dblParam_[ClpMaxSeconds] = rhs.dblParam_[ClpMaxSeconds];
    743   dblParam_[ClpPresolveTolerance] = rhs.dblParam_[ClpPresolveTolerance];
     721     defaultHandler_ = rhs.defaultHandler_;
     722     if (trueCopy >= 0) {
     723          if (defaultHandler_)
     724               handler_ = new CoinMessageHandler(*rhs.handler_);
     725          else
     726               handler_ = rhs.handler_;
     727          eventHandler_ = rhs.eventHandler_->clone();
     728          randomNumberGenerator_ = rhs.randomNumberGenerator_;
     729          messages_ = rhs.messages_;
     730          coinMessages_ = rhs.coinMessages_;
     731     } else {
     732          if (!eventHandler_ && rhs.eventHandler_)
     733               eventHandler_ = rhs.eventHandler_->clone();
     734     }
     735     intParam_[ClpMaxNumIteration] = rhs.intParam_[ClpMaxNumIteration];
     736     intParam_[ClpMaxNumIterationHotStart] =
     737          rhs.intParam_[ClpMaxNumIterationHotStart];
     738     intParam_[ClpNameDiscipline] = rhs.intParam_[ClpNameDiscipline] ;
     739
     740     dblParam_[ClpDualObjectiveLimit] = rhs.dblParam_[ClpDualObjectiveLimit];
     741     dblParam_[ClpPrimalObjectiveLimit] = rhs.dblParam_[ClpPrimalObjectiveLimit];
     742     dblParam_[ClpDualTolerance] = rhs.dblParam_[ClpDualTolerance];
     743     dblParam_[ClpPrimalTolerance] = rhs.dblParam_[ClpPrimalTolerance];
     744     dblParam_[ClpObjOffset] = rhs.dblParam_[ClpObjOffset];
     745     dblParam_[ClpMaxSeconds] = rhs.dblParam_[ClpMaxSeconds];
     746     dblParam_[ClpPresolveTolerance] = rhs.dblParam_[ClpPresolveTolerance];
    744747#ifndef CLP_NO_STD
    745748
    746   strParam_[ClpProbName] = rhs.strParam_[ClpProbName];
    747 #endif
    748 
    749   optimizationDirection_ = rhs.optimizationDirection_;
    750   objectiveValue_=rhs.objectiveValue_;
    751   smallElement_ = rhs.smallElement_;
    752   objectiveScale_ = rhs.objectiveScale_;
    753   rhsScale_ = rhs.rhsScale_;
    754   numberIterations_ = rhs.numberIterations_;
    755   solveType_ = rhs.solveType_;
    756   whatsChanged_ = rhs.whatsChanged_;
    757   problemStatus_ = rhs.problemStatus_;
    758   secondaryStatus_ = rhs.secondaryStatus_;
    759   numberRows_ = rhs.numberRows_;
    760   numberColumns_ = rhs.numberColumns_;
    761   userPointer_ = rhs.userPointer_;
    762   trustedUserPointer_ = rhs.trustedUserPointer_;
    763   scalingFlag_ = rhs.scalingFlag_;
    764   specialOptions_ = rhs.specialOptions_;
    765   if (trueCopy) {
     749     strParam_[ClpProbName] = rhs.strParam_[ClpProbName];
     750#endif
     751
     752     optimizationDirection_ = rhs.optimizationDirection_;
     753     objectiveValue_ = rhs.objectiveValue_;
     754     smallElement_ = rhs.smallElement_;
     755     objectiveScale_ = rhs.objectiveScale_;
     756     rhsScale_ = rhs.rhsScale_;
     757     numberIterations_ = rhs.numberIterations_;
     758     solveType_ = rhs.solveType_;
     759     whatsChanged_ = rhs.whatsChanged_;
     760     problemStatus_ = rhs.problemStatus_;
     761     secondaryStatus_ = rhs.secondaryStatus_;
     762     numberRows_ = rhs.numberRows_;
     763     numberColumns_ = rhs.numberColumns_;
     764     userPointer_ = rhs.userPointer_;
     765     trustedUserPointer_ = rhs.trustedUserPointer_;
     766     scalingFlag_ = rhs.scalingFlag_;
     767     specialOptions_ = rhs.specialOptions_;
     768     if (trueCopy) {
    766769#ifndef CLP_NO_STD
    767     lengthNames_ = rhs.lengthNames_;
    768     if (lengthNames_) {
    769       rowNames_ = rhs.rowNames_;
    770       columnNames_ = rhs.columnNames_;
    771     }
    772 #endif
    773     numberThreads_ = rhs.numberThreads_;
    774     if (maximumRows_<0) {
    775       specialOptions_ &= ~65536;
    776       savedRowScale_ = NULL;
    777       savedColumnScale_ = NULL;
    778       integerType_ = CoinCopyOfArray(rhs.integerType_,numberColumns_);
    779       rowActivity_= ClpCopyOfArray(rhs.rowActivity_, numberRows_);
    780       columnActivity_= ClpCopyOfArray(rhs.columnActivity_,numberColumns_);
    781       dual_= ClpCopyOfArray(rhs.dual_, numberRows_);
    782       reducedCost_= ClpCopyOfArray(rhs.reducedCost_, numberColumns_);
    783       rowLower_ = ClpCopyOfArray ( rhs.rowLower_, numberRows_ );
    784       rowUpper_ = ClpCopyOfArray ( rhs.rowUpper_, numberRows_ );
    785       columnLower_ = ClpCopyOfArray ( rhs.columnLower_, numberColumns_ );
    786       columnUpper_ = ClpCopyOfArray ( rhs.columnUpper_, numberColumns_ );
    787       rowScale_ = ClpCopyOfArray(rhs.rowScale_,numberRows_*2);
    788       columnScale_ = ClpCopyOfArray(rhs.columnScale_,numberColumns_*2);
    789       if (rhs.objective_)
    790         objective_  = rhs.objective_->clone();
    791       else
    792         objective_ = NULL;
    793       rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
    794       status_ = ClpCopyOfArray( rhs.status_,numberColumns_+numberRows_);
    795       ray_ = NULL;
    796       if (problemStatus_==1)
    797         ray_ = ClpCopyOfArray (rhs.ray_,numberRows_);
    798       else if (problemStatus_==2)
    799         ray_ = ClpCopyOfArray (rhs.ray_,numberColumns_);
    800       if (rhs.rowCopy_) {
    801         rowCopy_ = rhs.rowCopy_->clone();
    802       } else {
    803         rowCopy_=NULL;
    804       }
    805       if (rhs.scaledMatrix_) {
    806         scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
    807       } else {
    808         scaledMatrix_=NULL;
    809       }
    810       matrix_=NULL;
    811       if (rhs.matrix_) {
    812         matrix_ = rhs.matrix_->clone();
    813       }
    814     } else {
    815       // This already has arrays - just copy
    816       savedRowScale_ = NULL;
    817       savedColumnScale_ = NULL;
    818       startPermanentArrays();
    819       if (rhs.integerType_) {
    820         assert (integerType_);
    821         ClpDisjointCopyN(rhs.integerType_,numberColumns_,integerType_);
    822       } else {
    823         integerType_ = NULL;
    824       }
    825       if (rhs.rowActivity_) {
    826         ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
    827                            rowActivity_);
    828         ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
    829                            columnActivity_);
    830         ClpDisjointCopyN ( rhs.dual_, numberRows_ ,
    831                            dual_);
    832         ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
    833                            reducedCost_);
    834       } else {
    835         rowActivity_=NULL;
    836         columnActivity_=NULL;
    837         dual_=NULL;
    838         reducedCost_=NULL;
    839       }
    840       ClpDisjointCopyN ( rhs.rowLower_, numberRows_,rowLower_ );
    841       ClpDisjointCopyN ( rhs.rowUpper_, numberRows_,rowUpper_ );
    842       ClpDisjointCopyN ( rhs.columnLower_, numberColumns_,columnLower_ );
    843       assert ((specialOptions_&131072)==0);
    844       abort();
    845       ClpDisjointCopyN ( rhs.columnUpper_, numberColumns_,columnUpper_ );
    846       if (rhs.objective_) {
    847         abort(); //check if same
    848         objective_  = rhs.objective_->clone();
    849       } else {
    850         objective_ = NULL;
    851       }
    852       assert (!rhs.rowObjective_);
    853       ClpDisjointCopyN( rhs.status_,numberColumns_+numberRows_,status_);
    854       ray_ = NULL;
    855       if (problemStatus_==1)
    856         ray_ = ClpCopyOfArray (rhs.ray_,numberRows_);
    857       else if (problemStatus_==2)
    858         ray_ = ClpCopyOfArray (rhs.ray_,numberColumns_);
    859       assert (!ray_);
    860       delete rowCopy_;
    861       if (rhs.rowCopy_) {
    862         rowCopy_ = rhs.rowCopy_->clone();
    863       } else {
    864         rowCopy_=NULL;
    865       }
    866       delete scaledMatrix_;
    867       if (rhs.scaledMatrix_) {
    868         scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
    869       } else {
    870         scaledMatrix_=NULL;
    871       }
    872       delete matrix_;
    873       matrix_=NULL;
    874       if (rhs.matrix_) {
    875         matrix_ = rhs.matrix_->clone();
    876       }
    877       if (rhs.savedRowScale_) {
    878         assert (savedRowScale_);
    879         assert (!rowScale_);
    880         ClpDisjointCopyN(rhs.savedRowScale_,4*maximumInternalRows_,savedRowScale_);
    881         ClpDisjointCopyN(rhs.savedColumnScale_,4*maximumInternalColumns_,savedColumnScale_);
    882       } else {
    883         assert (!savedRowScale_);
    884         if (rowScale_) {
    885           ClpDisjointCopyN(rhs.rowScale_,numberRows_,rowScale_);
    886           ClpDisjointCopyN(rhs.columnScale_,numberColumns_,columnScale_);
    887         } else {
    888           rowScale_ =NULL;
    889           columnScale_=NULL;
    890         }
    891       }
    892       abort(); // look at resizeDouble and resize
    893     }
    894   } else {
    895     savedRowScale_ = rhs.savedRowScale_;
    896     assert (!savedRowScale_);
    897     savedColumnScale_ = rhs.savedColumnScale_;
    898     rowActivity_ = rhs.rowActivity_;
    899     columnActivity_ = rhs.columnActivity_;
    900     dual_ = rhs.dual_;
    901     reducedCost_ = rhs.reducedCost_;
    902     rowLower_ = rhs.rowLower_;
    903     rowUpper_ = rhs.rowUpper_;
    904     objective_ = rhs.objective_;
    905     rowObjective_ = rhs.rowObjective_;
    906     columnLower_ = rhs.columnLower_;
    907     columnUpper_ = rhs.columnUpper_;
    908     matrix_ = rhs.matrix_;
    909     rowCopy_ = NULL;
    910     scaledMatrix_ = NULL;
    911     ray_ = rhs.ray_;
    912     //rowScale_ = rhs.rowScale_;
    913     //columnScale_ = rhs.columnScale_;
    914     lengthNames_ = 0;
    915     numberThreads_ = rhs.numberThreads_;
     770          lengthNames_ = rhs.lengthNames_;
     771          if (lengthNames_) {
     772               rowNames_ = rhs.rowNames_;
     773               columnNames_ = rhs.columnNames_;
     774          }
     775#endif
     776          numberThreads_ = rhs.numberThreads_;
     777          if (maximumRows_ < 0) {
     778               specialOptions_ &= ~65536;
     779               savedRowScale_ = NULL;
     780               savedColumnScale_ = NULL;
     781               integerType_ = CoinCopyOfArray(rhs.integerType_, numberColumns_);
     782               rowActivity_ = ClpCopyOfArray(rhs.rowActivity_, numberRows_);
     783               columnActivity_ = ClpCopyOfArray(rhs.columnActivity_, numberColumns_);
     784               dual_ = ClpCopyOfArray(rhs.dual_, numberRows_);
     785               reducedCost_ = ClpCopyOfArray(rhs.reducedCost_, numberColumns_);
     786               rowLower_ = ClpCopyOfArray ( rhs.rowLower_, numberRows_ );
     787               rowUpper_ = ClpCopyOfArray ( rhs.rowUpper_, numberRows_ );
     788               columnLower_ = ClpCopyOfArray ( rhs.columnLower_, numberColumns_ );
     789               columnUpper_ = ClpCopyOfArray ( rhs.columnUpper_, numberColumns_ );
     790               rowScale_ = ClpCopyOfArray(rhs.rowScale_, numberRows_ * 2);
     791               columnScale_ = ClpCopyOfArray(rhs.columnScale_, numberColumns_ * 2);
     792               if (rhs.objective_)
     793                    objective_  = rhs.objective_->clone();
     794               else
     795                    objective_ = NULL;
     796               rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
     797               status_ = ClpCopyOfArray( rhs.status_, numberColumns_ + numberRows_);
     798               ray_ = NULL;
     799               if (problemStatus_ == 1)
     800                    ray_ = ClpCopyOfArray (rhs.ray_, numberRows_);
     801               else if (problemStatus_ == 2)
     802                    ray_ = ClpCopyOfArray (rhs.ray_, numberColumns_);
     803               if (rhs.rowCopy_) {
     804                    rowCopy_ = rhs.rowCopy_->clone();
     805               } else {
     806                    rowCopy_ = NULL;
     807               }
     808               if (rhs.scaledMatrix_) {
     809                    scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
     810               } else {
     811                    scaledMatrix_ = NULL;
     812               }
     813               matrix_ = NULL;
     814               if (rhs.matrix_) {
     815                    matrix_ = rhs.matrix_->clone();
     816               }
     817          } else {
     818               // This already has arrays - just copy
     819               savedRowScale_ = NULL;
     820               savedColumnScale_ = NULL;
     821               startPermanentArrays();
     822               if (rhs.integerType_) {
     823                    assert (integerType_);
     824                    ClpDisjointCopyN(rhs.integerType_, numberColumns_, integerType_);
     825               } else {
     826                    integerType_ = NULL;
     827               }
     828               if (rhs.rowActivity_) {
     829                    ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
     830                                       rowActivity_);
     831                    ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
     832                                       columnActivity_);
     833                    ClpDisjointCopyN ( rhs.dual_, numberRows_ ,
     834                                       dual_);
     835                    ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
     836                                       reducedCost_);
     837               } else {
     838                    rowActivity_ = NULL;
     839                    columnActivity_ = NULL;
     840                    dual_ = NULL;
     841                    reducedCost_ = NULL;
     842               }
     843               ClpDisjointCopyN ( rhs.rowLower_, numberRows_, rowLower_ );
     844               ClpDisjointCopyN ( rhs.rowUpper_, numberRows_, rowUpper_ );
     845               ClpDisjointCopyN ( rhs.columnLower_, numberColumns_, columnLower_ );
     846               assert ((specialOptions_ & 131072) == 0);
     847               abort();
     848               ClpDisjointCopyN ( rhs.columnUpper_, numberColumns_, columnUpper_ );
     849               if (rhs.objective_) {
     850                    abort(); //check if same
     851                    objective_  = rhs.objective_->clone();
     852               } else {
     853                    objective_ = NULL;
     854               }
     855               assert (!rhs.rowObjective_);
     856               ClpDisjointCopyN( rhs.status_, numberColumns_ + numberRows_, status_);
     857               ray_ = NULL;
     858               if (problemStatus_ == 1)
     859                    ray_ = ClpCopyOfArray (rhs.ray_, numberRows_);
     860               else if (problemStatus_ == 2)
     861                    ray_ = ClpCopyOfArray (rhs.ray_, numberColumns_);
     862               assert (!ray_);
     863               delete rowCopy_;
     864               if (rhs.rowCopy_) {
     865                    rowCopy_ = rhs.rowCopy_->clone();
     866               } else {
     867                    rowCopy_ = NULL;
     868               }
     869               delete scaledMatrix_;
     870               if (rhs.scaledMatrix_) {
     871                    scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
     872               } else {
     873                    scaledMatrix_ = NULL;
     874               }
     875               delete matrix_;
     876               matrix_ = NULL;
     877               if (rhs.matrix_) {
     878                    matrix_ = rhs.matrix_->clone();
     879               }
     880               if (rhs.savedRowScale_) {
     881                    assert (savedRowScale_);
     882                    assert (!rowScale_);
     883                    ClpDisjointCopyN(rhs.savedRowScale_, 4 * maximumInternalRows_, savedRowScale_);
     884                    ClpDisjointCopyN(rhs.savedColumnScale_, 4 * maximumInternalColumns_, savedColumnScale_);
     885               } else {
     886                    assert (!savedRowScale_);
     887                    if (rowScale_) {
     888                         ClpDisjointCopyN(rhs.rowScale_, numberRows_, rowScale_);
     889                         ClpDisjointCopyN(rhs.columnScale_, numberColumns_, columnScale_);
     890                    } else {
     891                         rowScale_ = NULL;
     892                         columnScale_ = NULL;
     893                    }
     894               }
     895               abort(); // look at resizeDouble and resize
     896          }
     897     } else {
     898          savedRowScale_ = rhs.savedRowScale_;
     899          assert (!savedRowScale_);
     900          savedColumnScale_ = rhs.savedColumnScale_;
     901          rowActivity_ = rhs.rowActivity_;
     902          columnActivity_ = rhs.columnActivity_;
     903          dual_ = rhs.dual_;
     904          reducedCost_ = rhs.reducedCost_;
     905          rowLower_ = rhs.rowLower_;
     906          rowUpper_ = rhs.rowUpper_;
     907          objective_ = rhs.objective_;
     908          rowObjective_ = rhs.rowObjective_;
     909          columnLower_ = rhs.columnLower_;
     910          columnUpper_ = rhs.columnUpper_;
     911          matrix_ = rhs.matrix_;
     912          rowCopy_ = NULL;
     913          scaledMatrix_ = NULL;
     914          ray_ = rhs.ray_;
     915          //rowScale_ = rhs.rowScale_;
     916          //columnScale_ = rhs.columnScale_;
     917          lengthNames_ = 0;
     918          numberThreads_ = rhs.numberThreads_;
    916919#ifndef CLP_NO_STD
    917     rowNames_ = std::vector<std::string> ();
    918     columnNames_ = std::vector<std::string> ();
    919 #endif
    920     integerType_ = NULL;
    921     status_ = rhs.status_;
    922   }
    923   inverseRowScale_ = NULL;
    924   inverseColumnScale_ = NULL;
     920          rowNames_ = std::vector<std::string> ();
     921          columnNames_ = std::vector<std::string> ();
     922#endif
     923          integerType_ = NULL;
     924          status_ = rhs.status_;
     925     }
     926     inverseRowScale_ = NULL;
     927     inverseColumnScale_ = NULL;
    925928}
    926929// Copy contents - resizing if necessary - otherwise re-use memory
    927 void 
     930void
    928931ClpModel::copy(const ClpMatrixBase * from, ClpMatrixBase * & to)
    929932{
    930   assert (from);
    931   const ClpPackedMatrix * matrixFrom = (dynamic_cast<const ClpPackedMatrix*>(from));
    932   ClpPackedMatrix * matrixTo = (dynamic_cast< ClpPackedMatrix*>(to));
    933   if (matrixFrom&&matrixTo) {
    934     matrixTo->copy(matrixFrom);
    935   } else {
    936     delete to;
    937     to =  from->clone();
    938   }
     933     assert (from);
     934     const ClpPackedMatrix * matrixFrom = (dynamic_cast<const ClpPackedMatrix*>(from));
     935     ClpPackedMatrix * matrixTo = (dynamic_cast< ClpPackedMatrix*>(to));
     936     if (matrixFrom && matrixTo) {
     937          matrixTo->copy(matrixFrom);
     938     } else {
     939          delete to;
     940          to =  from->clone();
     941     }
    939942#if 0
    940   delete modelPtr_->matrix_;
    941   if (continuousModel_->matrix_) {
    942     modelPtr_->matrix_ = continuousModel_->matrix_->clone();
    943   } else {
    944     modelPtr_->matrix_=NULL;
    945   }
     943     delete modelPtr_->matrix_;
     944     if (continuousModel_->matrix_) {
     945          modelPtr_->matrix_ = continuousModel_->matrix_->clone();
     946     } else {
     947          modelPtr_->matrix_ = NULL;
     948     }
    946949#endif
    947950}
     
    949952   of data around.  It assumes a derived class wants to overwrite
    950953   an empty model with a real one - while it does an algorithm */
    951 void 
     954void
    952955ClpModel::borrowModel(ClpModel & rhs)
    953956{
    954   if (defaultHandler_) {
    955     delete handler_;
    956     handler_ = NULL;
    957   }
    958   gutsOfDelete(1);
    959   optimizationDirection_ = rhs.optimizationDirection_;
    960   numberRows_ = rhs.numberRows_;
    961   numberColumns_ = rhs.numberColumns_;
    962   delete [] rhs.ray_;
    963   rhs.ray_=NULL;
    964   // make sure scaled matrix not copied
    965   ClpPackedMatrix * save = rhs.scaledMatrix_;
    966   rhs.scaledMatrix_ = NULL;
    967   delete scaledMatrix_;
    968   scaledMatrix_=NULL;
    969   gutsOfCopy(rhs,0);
    970   rhs.scaledMatrix_ = save;
    971   specialOptions_ = rhs.specialOptions_ & ~65536;
    972   savedRowScale_=NULL;
    973   savedColumnScale_=NULL;
    974   inverseRowScale_ = NULL;
    975   inverseColumnScale_ = NULL;
     957     if (defaultHandler_) {
     958          delete handler_;
     959          handler_ = NULL;
     960     }
     961     gutsOfDelete(1);
     962     optimizationDirection_ = rhs.optimizationDirection_;
     963     numberRows_ = rhs.numberRows_;
     964     numberColumns_ = rhs.numberColumns_;
     965     delete [] rhs.ray_;
     966     rhs.ray_ = NULL;
     967     // make sure scaled matrix not copied
     968     ClpPackedMatrix * save = rhs.scaledMatrix_;
     969     rhs.scaledMatrix_ = NULL;
     970     delete scaledMatrix_;
     971     scaledMatrix_ = NULL;
     972     gutsOfCopy(rhs, 0);
     973     rhs.scaledMatrix_ = save;
     974     specialOptions_ = rhs.specialOptions_ & ~65536;
     975     savedRowScale_ = NULL;
     976     savedColumnScale_ = NULL;
     977     inverseRowScale_ = NULL;
     978     inverseColumnScale_ = NULL;
    976979}
    977980// Return model - nulls all arrays so can be deleted safely
    978 void 
     981void
    979982ClpModel::returnModel(ClpModel & otherModel)
    980983{
    981   otherModel.objectiveValue_=objectiveValue_;
    982   otherModel.numberIterations_ = numberIterations_;
    983   otherModel.problemStatus_ = problemStatus_;
    984   otherModel.secondaryStatus_ = secondaryStatus_;
    985   rowActivity_ = NULL;
    986   columnActivity_ = NULL;
    987   dual_ = NULL;
    988   reducedCost_ = NULL;
    989   rowLower_ = NULL;
    990   rowUpper_ = NULL;
    991   objective_ = NULL;
    992   rowObjective_ = NULL;
    993   columnLower_ = NULL;
    994   columnUpper_ = NULL;
    995   matrix_ = NULL;
    996   rowCopy_ = NULL;
    997   delete scaledMatrix_;
    998   scaledMatrix_ = NULL;
    999   delete [] otherModel.ray_;
    1000   otherModel.ray_ = ray_;
    1001   ray_ = NULL;
    1002   if (rowScale_&&otherModel.rowScale_!=rowScale_) {
    1003     delete [] rowScale_;
    1004     delete [] columnScale_;
    1005   }
    1006   rowScale_ = NULL;
    1007   columnScale_ = NULL;
    1008   //rowScale_=NULL;
    1009   //columnScale_=NULL;
    1010   // do status
    1011   if (otherModel.status_!=status_) {
    1012     delete [] otherModel.status_;
    1013     otherModel.status_ = status_;
    1014   }
    1015   status_ = NULL;
    1016   if (defaultHandler_) {
    1017     delete handler_;
    1018     handler_ = NULL;
    1019   }
    1020   inverseRowScale_ = NULL;
    1021   inverseColumnScale_ = NULL;
     984     otherModel.objectiveValue_ = objectiveValue_;
     985     otherModel.numberIterations_ = numberIterations_;
     986     otherModel.problemStatus_ = problemStatus_;
     987     otherModel.secondaryStatus_ = secondaryStatus_;
     988     rowActivity_ = NULL;
     989     columnActivity_ = NULL;
     990     dual_ = NULL;
     991     reducedCost_ = NULL;
     992     rowLower_ = NULL;
     993     rowUpper_ = NULL;
     994     objective_ = NULL;
     995     rowObjective_ = NULL;
     996     columnLower_ = NULL;
     997     columnUpper_ = NULL;
     998     matrix_ = NULL;
     999     rowCopy_ = NULL;
     1000     delete scaledMatrix_;
     1001     scaledMatrix_ = NULL;
     1002     delete [] otherModel.ray_;
     1003     otherModel.ray_ = ray_;
     1004     ray_ = NULL;
     1005     if (rowScale_ && otherModel.rowScale_ != rowScale_) {
     1006          delete [] rowScale_;
     1007          delete [] columnScale_;
     1008     }
     1009     rowScale_ = NULL;
     1010     columnScale_ = NULL;
     1011     //rowScale_=NULL;
     1012     //columnScale_=NULL;
     1013     // do status
     1014     if (otherModel.status_ != status_) {
     1015          delete [] otherModel.status_;
     1016          otherModel.status_ = status_;
     1017     }
     1018     status_ = NULL;
     1019     if (defaultHandler_) {
     1020          delete handler_;
     1021          handler_ = NULL;
     1022     }
     1023     inverseRowScale_ = NULL;
     1024     inverseColumnScale_ = NULL;
    10221025}
    10231026//#############################################################################
     
    10281031ClpModel::setIntParam(ClpIntParam key, int value)
    10291032{
    1030   switch (key) {
    1031   case ClpMaxNumIteration:
    1032     if (value < 0)
    1033       return false;
    1034     break;
    1035   case ClpMaxNumIterationHotStart:
    1036     if (value < 0)
    1037       return false;
    1038     break;
    1039   case ClpNameDiscipline:
    1040     if (value < 0)
    1041       return false;
    1042     break;
    1043   default:
    1044     return false;
    1045   }
    1046   intParam_[key] = value;
    1047   return true;
     1033     switch (key) {
     1034     case ClpMaxNumIteration:
     1035          if (value < 0)
     1036               return false;
     1037          break;
     1038     case ClpMaxNumIterationHotStart:
     1039          if (value < 0)
     1040               return false;
     1041          break;
     1042     case ClpNameDiscipline:
     1043          if (value < 0)
     1044               return false;
     1045          break;
     1046     default:
     1047          return false;
     1048     }
     1049     intParam_[key] = value;
     1050     return true;
    10481051}
    10491052
     
    10541057{
    10551058
    1056   switch (key) {
    1057   case ClpDualObjectiveLimit:
    1058     break;
    1059 
    1060   case ClpPrimalObjectiveLimit:
    1061     break;
    1062 
    1063   case ClpDualTolerance:
    1064     if (value<=0.0||value>1.0e10)
    1065       return false;
    1066     break;
    1067    
    1068   case ClpPrimalTolerance:
    1069     if (value<=0.0||value>1.0e10)
    1070       return false;
    1071     break;
    1072    
    1073   case ClpObjOffset:
    1074     break;
    1075 
    1076   case ClpMaxSeconds:
    1077     if(value>=0)
    1078       value += CoinCpuTime();
    1079     else
    1080       value = -1.0;
    1081     break;
    1082 
    1083   case ClpPresolveTolerance:
    1084     if (value<=0.0||value>1.0e10)
    1085       return false;
    1086     break;
    1087    
    1088   default:
    1089     return false;
    1090   }
    1091   dblParam_[key] = value;
    1092   return true;
     1059     switch (key) {
     1060     case ClpDualObjectiveLimit:
     1061          break;
     1062
     1063     case ClpPrimalObjectiveLimit:
     1064          break;
     1065
     1066     case ClpDualTolerance:
     1067          if (value <= 0.0 || value > 1.0e10)
     1068               return false;
     1069          break;
     1070
     1071     case ClpPrimalTolerance:
     1072          if (value <= 0.0 || value > 1.0e10)
     1073               return false;
     1074          break;
     1075
     1076     case ClpObjOffset:
     1077          break;
     1078
     1079     case ClpMaxSeconds:
     1080          if(value >= 0)
     1081               value += CoinCpuTime();
     1082          else
     1083               value = -1.0;
     1084          break;
     1085
     1086     case ClpPresolveTolerance:
     1087          if (value <= 0.0 || value > 1.0e10)
     1088               return false;
     1089          break;
     1090
     1091     default:
     1092          return false;
     1093     }
     1094     dblParam_[key] = value;
     1095     return true;
    10931096}
    10941097
     
    11001103{
    11011104
    1102   switch (key) {
    1103   case ClpProbName:
    1104     break;
    1105 
    1106   default:
    1107     return false;
    1108   }
    1109   strParam_[key] = value;
    1110   return true;
     1105     switch (key) {
     1106     case ClpProbName:
     1107          break;
     1108
     1109     default:
     1110          return false;
     1111     }
     1112     strParam_[key] = value;
     1113     return true;
    11111114}
    11121115#endif
     
    11141117// Returns resized array and deletes incoming
    11151118double * resizeDouble(double * array , int size, int newSize, double fill,
    1116                       bool createArray)
    1117 {
    1118   if ((array||createArray)&&size<newSize) {
    1119     int i;
    1120     double * newArray = new double[newSize];
    1121     if (array)
    1122       CoinMemcpyN(array,CoinMin(newSize,size),newArray);
    1123     delete [] array;
    1124     array = newArray;
    1125     for (i=size;i<newSize;i++)
    1126       array[i]=fill;
    1127   }
    1128   return array;
     1119                      bool createArray)
     1120{
     1121     if ((array || createArray) && size < newSize) {
     1122          int i;
     1123          double * newArray = new double[newSize];
     1124          if (array)
     1125               CoinMemcpyN(array, CoinMin(newSize, size), newArray);
     1126          delete [] array;
     1127          array = newArray;
     1128          for (i = size; i < newSize; i++)
     1129               array[i] = fill;
     1130     }
     1131     return array;
    11291132}
    11301133// Returns resized array and updates size
    1131 double * deleteDouble(double * array , int size, 
    1132                       int number, const int * which,int & newSize)
    1133 {
    1134   if (array) {
    1135     int i ;
    1136     char * deleted = new char[size];
    1137     int numberDeleted=0;
    1138     CoinZeroN(deleted,size);
    1139     for (i=0;i<number;i++) {
    1140       int j = which[i];
    1141       if (j>=0&&j<size&&!deleted[j]) {
    1142         numberDeleted++;
    1143         deleted[j]=1;
    1144       }
    1145     }
    1146     newSize = size-numberDeleted;
    1147     double * newArray = new double[newSize];
    1148     int put=0;
    1149     for (i=0;i<size;i++) {
    1150       if (!deleted[i]) {
    1151         newArray[put++]=array[i];
    1152       }
    1153     }
    1154     delete [] array;
    1155     array = newArray;
    1156     delete [] deleted;
    1157   }
    1158   return array;
    1159 }
    1160 char * deleteChar(char * array , int size, 
    1161                   int number, const int * which,int & newSize,
    1162                   bool ifDelete)
    1163 {
    1164   if (array) {
    1165     int i ;
    1166     char * deleted = new char[size];
    1167     int numberDeleted=0;
    1168     CoinZeroN(deleted,size);
    1169     for (i=0;i<number;i++) {
    1170       int j = which[i];
    1171       if (j>=0&&j<size&&!deleted[j]) {
    1172         numberDeleted++;
    1173         deleted[j]=1;
    1174       }
    1175     }
    1176     newSize = size-numberDeleted;
    1177     char * newArray = new char[newSize];
    1178     int put=0;
    1179     for (i=0;i<size;i++) {
    1180       if (!deleted[i]) {
    1181         newArray[put++]=array[i];
    1182       }
    1183     }
    1184     if (ifDelete)
    1185       delete [] array;
    1186     array = newArray;
    1187     delete [] deleted;
    1188   }
    1189   return array;
     1134double * deleteDouble(double * array , int size,
     1135                      int number, const int * which, int & newSize)
     1136{
     1137     if (array) {
     1138          int i ;
     1139          char * deleted = new char[size];
     1140          int numberDeleted = 0;
     1141          CoinZeroN(deleted, size);
     1142          for (i = 0; i < number; i++) {
     1143               int j = which[i];
     1144               if (j >= 0 && j < size && !deleted[j]) {
     1145                    numberDeleted++;
     1146                    deleted[j] = 1;
     1147               }
     1148          }
     1149          newSize = size - numberDeleted;
     1150          double * newArray = new double[newSize];
     1151          int put = 0;
     1152          for (i = 0; i < size; i++) {
     1153               if (!deleted[i]) {
     1154                    newArray[put++] = array[i];
     1155               }
     1156          }
     1157          delete [] array;
     1158          array = newArray;
     1159          delete [] deleted;
     1160     }
     1161     return array;
     1162}
     1163char * deleteChar(char * array , int size,
     1164                  int number, const int * which, int & newSize,
     1165                  bool ifDelete)
     1166{
     1167     if (array) {
     1168          int i ;
     1169          char * deleted = new char[size];
     1170          int numberDeleted = 0;
     1171          CoinZeroN(deleted, size);
     1172          for (i = 0; i < number; i++) {
     1173               int j = which[i];
     1174               if (j >= 0 && j < size && !deleted[j]) {
     1175                    numberDeleted++;
     1176                    deleted[j] = 1;
     1177               }
     1178          }
     1179          newSize = size - numberDeleted;
     1180          char * newArray = new char[newSize];
     1181          int put = 0;
     1182          for (i = 0; i < size; i++) {
     1183               if (!deleted[i]) {
     1184                    newArray[put++] = array[i];
     1185               }
     1186          }
     1187          if (ifDelete)
     1188               delete [] array;
     1189          array = newArray;
     1190          delete [] deleted;
     1191     }
     1192     return array;
    11901193}
    11911194// Create empty ClpPackedMatrix
    1192 void 
     1195void
    11931196ClpModel::createEmptyMatrix()
    11941197{
    1195   delete matrix_;
    1196   whatsChanged_ = 0;
    1197   CoinPackedMatrix matrix2;
    1198   matrix_=new ClpPackedMatrix(matrix2);
     1198     delete matrix_;
     1199     whatsChanged_ = 0;
     1200     CoinPackedMatrix matrix2;
     1201     matrix_ = new ClpPackedMatrix(matrix2);
    11991202}
    12001203/* Really clean up matrix.
    1201    a) eliminate all duplicate AND small elements in matrix 
     1204   a) eliminate all duplicate AND small elements in matrix
    12021205   b) remove all gaps and set extraGap_ and extraMajor_ to 0.0
    12031206   c) reallocate arrays and make max lengths equal to lengths
     
    12051208   returns number of elements eliminated or -1 if not ClpMatrix
    12061209*/
    1207 int 
     1210int
    12081211ClpModel::cleanMatrix(double threshold)
    12091212{
    1210   ClpPackedMatrix * matrix = (dynamic_cast< ClpPackedMatrix*>(matrix_));
    1211   if (matrix) {
    1212     return matrix->getPackedMatrix()->cleanMatrix(threshold);
    1213   } else {
    1214     return -1;
    1215   }
    1216 }
    1217 // Resizes 
    1218 void 
     1213     ClpPackedMatrix * matrix = (dynamic_cast< ClpPackedMatrix*>(matrix_));
     1214     if (matrix) {
     1215          return matrix->getPackedMatrix()->cleanMatrix(threshold);
     1216     } else {
     1217          return -1;
     1218     }
     1219}
     1220// Resizes
     1221void
    12191222ClpModel::resize (int newNumberRows, int newNumberColumns)
    12201223{
    1221   if (newNumberRows==numberRows_&&
    1222       newNumberColumns==numberColumns_)
    1223     return; // nothing to do
    1224   whatsChanged_ = 0;
    1225   int numberRows2=newNumberRows;
    1226   int numberColumns2=newNumberColumns;
    1227   if (numberRows2<maximumRows_)
    1228     numberRows2=maximumRows_;
    1229   if (numberColumns2<maximumColumns_)
    1230     numberColumns2=maximumColumns_;
    1231   if (numberRows2>maximumRows_) {
    1232     rowActivity_ = resizeDouble(rowActivity_,numberRows_,
    1233                                 newNumberRows,0.0,true);
    1234     dual_ = resizeDouble(dual_,numberRows_,
    1235                          newNumberRows,0.0,true);
    1236     rowObjective_ = resizeDouble(rowObjective_,numberRows_,
    1237                                  newNumberRows,0.0,false);
    1238     rowLower_ = resizeDouble(rowLower_,numberRows_,
    1239                              newNumberRows,-COIN_DBL_MAX,true);
    1240     rowUpper_ = resizeDouble(rowUpper_,numberRows_,
    1241                              newNumberRows,COIN_DBL_MAX,true);
    1242   }
    1243   if (numberColumns2>maximumColumns_) {
    1244     columnActivity_ = resizeDouble(columnActivity_,numberColumns_,
    1245                                    newNumberColumns,0.0,true);
    1246     reducedCost_ = resizeDouble(reducedCost_,numberColumns_,
    1247                                 newNumberColumns,0.0,true);
    1248   }
    1249   if (savedRowScale_&&numberRows2>maximumInternalRows_) {
    1250     double * temp;
    1251     temp = new double [4*newNumberRows];
    1252     CoinFillN(temp,4*newNumberRows,1.0);
    1253     CoinMemcpyN(savedRowScale_,numberRows_,temp);
    1254     CoinMemcpyN(savedRowScale_+maximumInternalRows_,numberRows_,temp+newNumberRows);
    1255     CoinMemcpyN(savedRowScale_+2*maximumInternalRows_,numberRows_,temp+2*newNumberRows);
    1256     CoinMemcpyN(savedRowScale_+3*maximumInternalRows_,numberRows_,temp+3*newNumberRows);
    1257     delete [] savedRowScale_;
    1258     savedRowScale_ = temp;
    1259   }
    1260   if (savedColumnScale_&&numberColumns2>maximumInternalColumns_) {
    1261     double * temp;
    1262     temp = new double [4*newNumberColumns];
    1263     CoinFillN(temp,4*newNumberColumns,1.0);
    1264     CoinMemcpyN(savedColumnScale_,numberColumns_,temp);
    1265     CoinMemcpyN(savedColumnScale_+maximumInternalColumns_,numberColumns_,temp+newNumberColumns);
    1266     CoinMemcpyN(savedColumnScale_+2*maximumInternalColumns_,numberColumns_,temp+2*newNumberColumns);
    1267     CoinMemcpyN(savedColumnScale_+3*maximumInternalColumns_,numberColumns_,temp+3*newNumberColumns);
    1268     delete [] savedColumnScale_;
    1269     savedColumnScale_ = temp;
    1270   }
    1271   if (objective_&&numberColumns2>maximumColumns_)
    1272     objective_->resize(newNumberColumns);
    1273   else if (!objective_)
    1274     objective_ = new ClpLinearObjective(NULL,newNumberColumns);
    1275   if (numberColumns2>maximumColumns_) {
    1276     columnLower_ = resizeDouble(columnLower_,numberColumns_,
    1277                                 newNumberColumns,0.0,true);
    1278     columnUpper_ = resizeDouble(columnUpper_,numberColumns_,
    1279                                 newNumberColumns,COIN_DBL_MAX,true);
    1280   }
    1281   if (newNumberRows<numberRows_) {
    1282     int * which = new int[numberRows_-newNumberRows];
    1283     int i;
    1284     for (i=newNumberRows;i<numberRows_;i++)
    1285       which[i-newNumberRows]=i;
    1286     matrix_->deleteRows(numberRows_-newNumberRows,which);
    1287     delete [] which;
    1288   }
    1289   if (numberRows_!=newNumberRows||numberColumns_!=newNumberColumns) {
    1290     // set state back to unknown
    1291     problemStatus_ = -1;
    1292     secondaryStatus_ = 0;
    1293     delete [] ray_;
    1294     ray_ = NULL;
    1295   }
    1296   setRowScale(NULL);
    1297   setColumnScale(NULL);
    1298   if (status_) {
    1299     if (newNumberColumns+newNumberRows) {
    1300       if (newNumberColumns+newNumberRows>maximumRows_+maximumColumns_) {
    1301         unsigned char * tempC = new unsigned char [newNumberColumns+newNumberRows];
    1302         unsigned char * tempR = tempC + newNumberColumns;
    1303         memset(tempC,3,newNumberColumns*sizeof(unsigned char));
    1304         memset(tempR,1,newNumberRows*sizeof(unsigned char));
    1305         CoinMemcpyN(status_,CoinMin(newNumberColumns,numberColumns_),tempC);
    1306         CoinMemcpyN(status_+numberColumns_,CoinMin(newNumberRows,numberRows_),tempR);
    1307         delete [] status_;
    1308         status_ = tempC;
    1309       } else if (newNumberColumns<numberColumns_) {
    1310         memmove(status_+newNumberColumns,status_+numberColumns_,
    1311                 newNumberRows);
    1312       } else if (newNumberColumns>numberColumns_) {
    1313         memset(status_+numberColumns_,3,newNumberColumns-numberColumns_);
    1314         memmove(status_+newNumberColumns,status_+numberColumns_,
    1315                 newNumberRows);
    1316       }
    1317     } else {
    1318       // empty model - some systems don't like new [0]
    1319       delete [] status_;
    1320       status_ = NULL;
    1321     }
    1322   }
     1224     if (newNumberRows == numberRows_ &&
     1225               newNumberColumns == numberColumns_)
     1226          return; // nothing to do
     1227     whatsChanged_ = 0;
     1228     int numberRows2 = newNumberRows;
     1229     int numberColumns2 = newNumberColumns;
     1230     if (numberRows2 < maximumRows_)
     1231          numberRows2 = maximumRows_;
     1232     if (numberColumns2 < maximumColumns_)
     1233          numberColumns2 = maximumColumns_;
     1234     if (numberRows2 > maximumRows_) {
     1235          rowActivity_ = resizeDouble(rowActivity_, numberRows_,
     1236                                      newNumberRows, 0.0, true);
     1237          dual_ = resizeDouble(dual_, numberRows_,
     1238                               newNumberRows, 0.0, true);
     1239          rowObjective_ = resizeDouble(rowObjective_, numberRows_,
     1240                                       newNumberRows, 0.0, false);
     1241          rowLower_ = resizeDouble(rowLower_, numberRows_,
     1242                                   newNumberRows, -COIN_DBL_MAX, true);
     1243          rowUpper_ = resizeDouble(rowUpper_, numberRows_,
     1244                                   newNumberRows, COIN_DBL_MAX, true);
     1245     }
     1246     if (numberColumns2 > maximumColumns_) {
     1247          columnActivity_ = resizeDouble(columnActivity_, numberColumns_,
     1248                                         newNumberColumns, 0.0, true);
     1249          reducedCost_ = resizeDouble(reducedCost_, numberColumns_,
     1250                                      newNumberColumns, 0.0, true);
     1251     }
     1252     if (savedRowScale_ && numberRows2 > maximumInternalRows_) {
     1253          double * temp;
     1254          temp = new double [4*newNumberRows];
     1255          CoinFillN(temp, 4 * newNumberRows, 1.0);
     1256          CoinMemcpyN(savedRowScale_, numberRows_, temp);
     1257          CoinMemcpyN(savedRowScale_ + maximumInternalRows_, numberRows_, temp + newNumberRows);
     1258          CoinMemcpyN(savedRowScale_ + 2 * maximumInternalRows_, numberRows_, temp + 2 * newNumberRows);
     1259          CoinMemcpyN(savedRowScale_ + 3 * maximumInternalRows_, numberRows_, temp + 3 * newNumberRows);
     1260          delete [] savedRowScale_;
     1261          savedRowScale_ = temp;
     1262     }
     1263     if (savedColumnScale_ && numberColumns2 > maximumInternalColumns_) {
     1264          double * temp;
     1265          temp = new double [4*newNumberColumns];
     1266          CoinFillN(temp, 4 * newNumberColumns, 1.0);
     1267          CoinMemcpyN(savedColumnScale_, numberColumns_, temp);
     1268          CoinMemcpyN(savedColumnScale_ + maximumInternalColumns_, numberColumns_, temp + newNumberColumns);
     1269          CoinMemcpyN(savedColumnScale_ + 2 * maximumInternalColumns_, numberColumns_, temp + 2 * newNumberColumns);
     1270          CoinMemcpyN(savedColumnScale_ + 3 * maximumInternalColumns_, numberColumns_, temp + 3 * newNumberColumns);
     1271          delete [] savedColumnScale_;
     1272          savedColumnScale_ = temp;
     1273     }
     1274     if (objective_ && numberColumns2 > maximumColumns_)
     1275          objective_->resize(newNumberColumns);
     1276     else if (!objective_)
     1277          objective_ = new ClpLinearObjective(NULL, newNumberColumns);
     1278     if (numberColumns2 > maximumColumns_) {
     1279          columnLower_ = resizeDouble(columnLower_, numberColumns_,
     1280                                      newNumberColumns, 0.0, true);
     1281          columnUpper_ = resizeDouble(columnUpper_, numberColumns_,
     1282                                      newNumberColumns, COIN_DBL_MAX, true);
     1283     }
     1284     if (newNumberRows < numberRows_) {
     1285          int * which = new int[numberRows_-newNumberRows];
     1286          int i;
     1287          for (i = newNumberRows; i < numberRows_; i++)
     1288               which[i-newNumberRows] = i;
     1289          matrix_->deleteRows(numberRows_ - newNumberRows, which);
     1290          delete [] which;
     1291     }
     1292     if (numberRows_ != newNumberRows || numberColumns_ != newNumberColumns) {
     1293          // set state back to unknown
     1294          problemStatus_ = -1;
     1295          secondaryStatus_ = 0;
     1296          delete [] ray_;
     1297          ray_ = NULL;
     1298     }
     1299     setRowScale(NULL);
     1300     setColumnScale(NULL);
     1301     if (status_) {
     1302          if (newNumberColumns + newNumberRows) {
     1303               if (newNumberColumns + newNumberRows > maximumRows_ + maximumColumns_) {
     1304                    unsigned char * tempC = new unsigned char [newNumberColumns+newNumberRows];
     1305                    unsigned char * tempR = tempC + newNumberColumns;
     1306                    memset(tempC, 3, newNumberColumns * sizeof(unsigned char));
     1307                    memset(tempR, 1, newNumberRows * sizeof(unsigned char));
     1308                    CoinMemcpyN(status_, CoinMin(newNumberColumns, numberColumns_), tempC);
     1309                    CoinMemcpyN(status_ + numberColumns_, CoinMin(newNumberRows, numberRows_), tempR);
     1310                    delete [] status_;
     1311                    status_ = tempC;
     1312               } else if (newNumberColumns < numberColumns_) {
     1313                    memmove(status_ + newNumberColumns, status_ + numberColumns_,
     1314                            newNumberRows);
     1315               } else if (newNumberColumns > numberColumns_) {
     1316                    memset(status_ + numberColumns_, 3, newNumberColumns - numberColumns_);
     1317                    memmove(status_ + newNumberColumns, status_ + numberColumns_,
     1318                            newNumberRows);
     1319               }
     1320          } else {
     1321               // empty model - some systems don't like new [0]
     1322               delete [] status_;
     1323               status_ = NULL;
     1324          }
     1325     }
    13231326#ifndef CLP_NO_STD
    1324   if (lengthNames_) {
    1325     // redo row and column names
    1326     if (numberRows_ < newNumberRows) {
    1327       rowNames_.resize(newNumberRows);
    1328       lengthNames_ = CoinMax(lengthNames_,8);
    1329       char name[9];
    1330       for (int iRow = numberRows_;iRow<newNumberRows;iRow++) {
    1331         sprintf(name,"R%7.7d",iRow);
    1332         rowNames_[iRow]=name;
    1333       }
    1334     }
    1335     if (numberColumns_ < newNumberColumns) {
    1336       columnNames_.resize(newNumberColumns);
    1337       lengthNames_ = CoinMax(lengthNames_,8);
    1338       char name[9];
    1339       for (int iColumn = numberColumns_;iColumn<newNumberColumns;iColumn++) {
    1340         sprintf(name,"C%7.7d",iColumn);
    1341         columnNames_[iColumn]=name;
    1342       }
    1343     }
    1344   }
    1345 #endif
    1346   numberRows_ = newNumberRows;
    1347   if (newNumberColumns<numberColumns_&&matrix_->getNumCols()) {
    1348     int * which = new int[numberColumns_-newNumberColumns];
    1349     int i;
    1350     for (i=newNumberColumns;i<numberColumns_;i++)
    1351       which[i-newNumberColumns]=i;
    1352     matrix_->deleteCols(numberColumns_-newNumberColumns,which);
    1353     delete [] which;
    1354   }
    1355   if (integerType_&&numberColumns2>maximumColumns_) {
    1356     char * temp = new char [newNumberColumns];
    1357     CoinZeroN(temp,newNumberColumns);
    1358     CoinMemcpyN(integerType_,
    1359            CoinMin(newNumberColumns,numberColumns_),temp);
    1360     delete [] integerType_;
    1361     integerType_ = temp;
    1362   }
    1363   numberColumns_ = newNumberColumns;
    1364   if ((specialOptions_&65536)!=0) {
    1365     // leave until next create rim to up numbers
    1366   }
    1367   if (maximumRows_>=0) {
    1368     if (numberRows_>maximumRows_)
    1369       printf("resize %d rows, %d old maximum rows\n",
    1370              numberRows_,maximumRows_);
    1371     maximumRows_ = CoinMax(maximumRows_,numberRows_);
    1372     maximumColumns_ = CoinMax(maximumColumns_,numberColumns_);
    1373   }
     1327     if (lengthNames_) {
     1328          // redo row and column names
     1329          if (numberRows_ < newNumberRows) {
     1330               rowNames_.resize(newNumberRows);
     1331               lengthNames_ = CoinMax(lengthNames_, 8);
     1332               char name[9];
     1333               for (int iRow = numberRows_; iRow < newNumberRows; iRow++) {
     1334                    sprintf(name, "R%7.7d", iRow);
     1335                    rowNames_[iRow] = name;
     1336               }
     1337          }
     1338          if (numberColumns_ < newNumberColumns) {
     1339               columnNames_.resize(newNumberColumns);
     1340               lengthNames_ = CoinMax(lengthNames_, 8);
     1341               char name[9];
     1342               for (int iColumn = numberColumns_; iColumn < newNumberColumns; iColumn++) {
     1343                    sprintf(name, "C%7.7d", iColumn);
     1344                    columnNames_[iColumn] = name;
     1345               }
     1346          }
     1347     }
     1348#endif
     1349     numberRows_ = newNumberRows;
     1350     if (newNumberColumns < numberColumns_ && matrix_->getNumCols()) {
     1351          int * which = new int[numberColumns_-newNumberColumns];
     1352          int i;
     1353          for (i = newNumberColumns; i < numberColumns_; i++)
     1354               which[i-newNumberColumns] = i;
     1355          matrix_->deleteCols(numberColumns_ - newNumberColumns, which);
     1356          delete [] which;
     1357     }
     1358     if (integerType_ && numberColumns2 > maximumColumns_) {
     1359          char * temp = new char [newNumberColumns];
     1360          CoinZeroN(temp, newNumberColumns);
     1361          CoinMemcpyN(integerType_,
     1362                      CoinMin(newNumberColumns, numberColumns_), temp);
     1363          delete [] integerType_;
     1364          integerType_ = temp;
     1365     }
     1366     numberColumns_ = newNumberColumns;
     1367     if ((specialOptions_ & 65536) != 0) {
     1368          // leave until next create rim to up numbers
     1369     }
     1370     if (maximumRows_ >= 0) {
     1371          if (numberRows_ > maximumRows_)
     1372               printf("resize %d rows, %d old maximum rows\n",
     1373                      numberRows_, maximumRows_);
     1374          maximumRows_ = CoinMax(maximumRows_, numberRows_);
     1375          maximumColumns_ = CoinMax(maximumColumns_, numberColumns_);
     1376     }
    13741377}
    13751378// Deletes rows
    1376 void 
     1379void
    13771380ClpModel::deleteRows(int number, const int * which)
    13781381{
    1379   if (!number)
    1380     return; // nothing to do
    1381   whatsChanged_ &= ~(1+2+4+8+16+32); // all except columns changed
    1382   int newSize=0;
    1383   if (maximumRows_<0) {
    1384     rowActivity_ = deleteDouble(rowActivity_,numberRows_,
    1385                                 number, which, newSize);
    1386     dual_ = deleteDouble(dual_,numberRows_,
    1387                         number, which, newSize);
    1388     rowObjective_ = deleteDouble(rowObjective_,numberRows_,
    1389                                 number, which, newSize);
    1390     rowLower_ = deleteDouble(rowLower_,numberRows_,
    1391                              number, which, newSize);
    1392     rowUpper_ = deleteDouble(rowUpper_,numberRows_,
    1393                              number, which, newSize);
    1394     if (matrix_->getNumRows())
    1395       matrix_->deleteRows(number,which);
    1396     //matrix_->removeGaps();
    1397     // status
    1398     if (status_) {
    1399       if (numberColumns_+newSize) {
    1400         unsigned char * tempR  = reinterpret_cast<unsigned char *>
    1401           (deleteChar(reinterpret_cast<char *>(status_)+numberColumns_,
    1402                       numberRows_,
    1403                       number, which, newSize,false));
    1404         unsigned char * tempC = new unsigned char [numberColumns_+newSize];
    1405         CoinMemcpyN(status_,numberColumns_,tempC);
    1406         CoinMemcpyN(tempR,newSize,tempC+numberColumns_);
    1407         delete [] tempR;
    1408         delete [] status_;
    1409         status_ = tempC;
    1410       } else {
    1411         // empty model - some systems don't like new [0]
    1412         delete [] status_;
    1413         status_ = NULL;
    1414       }
    1415     }
    1416   } else {
    1417     char * deleted = new char [numberRows_];
    1418     int i;
    1419     int numberDeleted=0;
    1420     CoinZeroN(deleted,numberRows_);
    1421     for (i=0;i<number;i++) {
    1422       int j = which[i];
    1423       if (j>=0&&j<numberRows_&&!deleted[j]) {
    1424         numberDeleted++;
    1425         deleted[j]=1;
    1426       }
    1427     }
    1428     assert (!rowObjective_);
    1429     unsigned char * status2 = status_+numberColumns_;
    1430     for (i=0;i<numberRows_;i++) {
    1431       if (!deleted[i]) {
    1432         rowActivity_[newSize]=rowActivity_[i];
    1433         dual_[newSize] = dual_[i];
    1434         rowLower_[newSize] = rowLower_[i];
    1435         rowUpper_[newSize] = rowUpper_[i];
    1436         status2[newSize] = status2[i];
    1437         newSize++;
    1438       }
    1439     }
    1440     if (matrix_->getNumRows())
    1441       matrix_->deleteRows(number,which);
    1442     //matrix_->removeGaps();
    1443     delete [] deleted;
    1444   }
     1382     if (!number)
     1383          return; // nothing to do
     1384     whatsChanged_ &= ~(1 + 2 + 4 + 8 + 16 + 32); // all except columns changed
     1385     int newSize = 0;
     1386     if (maximumRows_ < 0) {
     1387          rowActivity_ = deleteDouble(rowActivity_, numberRows_,
     1388                                      number, which, newSize);
     1389          dual_ = deleteDouble(dual_, numberRows_,
     1390                              number, which, newSize);
     1391          rowObjective_ = deleteDouble(rowObjective_, numberRows_,
     1392                                      number, which, newSize);
     1393          rowLower_ = deleteDouble(rowLower_, numberRows_,
     1394                                   number, which, newSize);
     1395          rowUpper_ = deleteDouble(rowUpper_, numberRows_,
     1396                                   number, which, newSize);
     1397          if (matrix_->getNumRows())
     1398               matrix_->deleteRows(number, which);
     1399          //matrix_->removeGaps();
     1400          // status
     1401          if (status_) {
     1402               if (numberColumns_ + newSize) {
     1403                    unsigned char * tempR  = reinterpret_cast<unsigned char *>
     1404                                             (deleteChar(reinterpret_cast<char *>(status_) + numberColumns_,
     1405                                                         numberRows_,
     1406                                                         number, which, newSize, false));
     1407                    unsigned char * tempC = new unsigned char [numberColumns_+newSize];
     1408                    CoinMemcpyN(status_, numberColumns_, tempC);
     1409                    CoinMemcpyN(tempR, newSize, tempC + numberColumns_);
     1410                    delete [] tempR;
     1411                    delete [] status_;
     1412                    status_ = tempC;
     1413               } else {
     1414                    // empty model - some systems don't like new [0]
     1415                    delete [] status_;
     1416                    status_ = NULL;
     1417               }
     1418          }
     1419     } else {
     1420          char * deleted = new char [numberRows_];
     1421          int i;
     1422          int numberDeleted = 0;
     1423          CoinZeroN(deleted, numberRows_);
     1424          for (i = 0; i < number; i++) {
     1425               int j = which[i];
     1426               if (j >= 0 && j < numberRows_ && !deleted[j]) {
     1427                    numberDeleted++;
     1428                    deleted[j] = 1;
     1429               }
     1430          }
     1431          assert (!rowObjective_);
     1432          unsigned char * status2 = status_ + numberColumns_;
     1433          for (i = 0; i < numberRows_; i++) {
     1434               if (!deleted[i]) {
     1435                    rowActivity_[newSize] = rowActivity_[i];
     1436                    dual_[newSize] = dual_[i];
     1437                    rowLower_[newSize] = rowLower_[i];
     1438                    rowUpper_[newSize] = rowUpper_[i];
     1439                    status2[newSize] = status2[i];
     1440                    newSize++;
     1441               }
     1442          }
     1443          if (matrix_->getNumRows())
     1444               matrix_->deleteRows(number, which);
     1445          //matrix_->removeGaps();
     1446          delete [] deleted;
     1447     }
    14451448#ifndef CLP_NO_STD
    1446   // Now works if which out of order
    1447   if (lengthNames_) {
    1448     char * mark = new char [numberRows_];
    1449     CoinZeroN(mark,numberRows_);
    1450     int i;
    1451     for (i=0;i<number;i++)
    1452       mark[which[i]]=1;
    1453     int k=0;
    1454     for ( i = 0; i < numberRows_; ++i) {
    1455       if (!mark[i])
    1456         rowNames_[k++] = rowNames_[i];
    1457     }
    1458     rowNames_.erase(rowNames_.begin()+k, rowNames_.end());
    1459     delete [] mark;
    1460   }
    1461 #endif
    1462   numberRows_=newSize;
    1463   // set state back to unknown
    1464   problemStatus_ = -1;
    1465   secondaryStatus_ = 0;
    1466   delete [] ray_;
    1467   ray_ = NULL;
    1468   if (savedRowScale_!=rowScale_) {
    1469     delete [] rowScale_;
    1470     delete [] columnScale_;
    1471   }
    1472   rowScale_ = NULL;
    1473   columnScale_ = NULL;
     1449     // Now works if which out of order
     1450     if (lengthNames_) {
     1451          char * mark = new char [numberRows_];
     1452          CoinZeroN(mark, numberRows_);
     1453          int i;
     1454          for (i = 0; i < number; i++)
     1455               mark[which[i]] = 1;
     1456          int k = 0;
     1457          for ( i = 0; i < numberRows_; ++i) {
     1458               if (!mark[i])
     1459                    rowNames_[k++] = rowNames_[i];
     1460          }
     1461          rowNames_.erase(rowNames_.begin() + k, rowNames_.end());
     1462          delete [] mark;
     1463     }
     1464#endif
     1465     numberRows_ = newSize;
     1466     // set state back to unknown
     1467     problemStatus_ = -1;
     1468     secondaryStatus_ = 0;
     1469     delete [] ray_;
     1470     ray_ = NULL;
     1471     if (savedRowScale_ != rowScale_) {
     1472          delete [] rowScale_;
     1473          delete [] columnScale_;
     1474     }
     1475     rowScale_ = NULL;
     1476     columnScale_ = NULL;
    14741477}
    14751478// Deletes columns
    1476 void 
     1479void
    14771480ClpModel::deleteColumns(int number, const int * which)
    14781481{
    1479   if (!number)
    1480     return; // nothing to do
    1481   assert (maximumColumns_<0);
    1482   whatsChanged_ &= ~(1+2+4+8+64+128+256); // all except rows changed
    1483   int newSize=0;
    1484   columnActivity_ = deleteDouble(columnActivity_,numberColumns_,
    1485                               number, which, newSize);
    1486   reducedCost_ = deleteDouble(reducedCost_,numberColumns_,
    1487                               number, which, newSize);
    1488   objective_->deleteSome(number, which);
    1489   columnLower_ = deleteDouble(columnLower_,numberColumns_,
    1490                               number, which, newSize);
    1491   columnUpper_ = deleteDouble(columnUpper_,numberColumns_,
    1492                               number, which, newSize);
    1493   // possible matrix is not full
    1494   if (matrix_->getNumCols()<numberColumns_) {
    1495     int * which2 = new int [number];
    1496     int n=0;
    1497     int nMatrix = matrix_->getNumCols();
    1498     for (int i=0;i<number;i++) {
    1499       if (which[i]<nMatrix)
    1500         which2[n++]=which[i];
    1501     }
    1502     matrix_->deleteCols(n,which2);
    1503     delete [] which2;
    1504   } else {
    1505     matrix_->deleteCols(number,which);
    1506   }
    1507   //matrix_->removeGaps();
    1508   // status
    1509   if (status_) {
    1510     if (numberRows_+newSize) {
    1511       unsigned char * tempC  = reinterpret_cast<unsigned char *>
    1512         (deleteChar(reinterpret_cast<char *>(status_),
    1513                     numberColumns_,
    1514                     number, which, newSize,false));
    1515       unsigned char * temp = new unsigned char [numberRows_+newSize];
    1516       CoinMemcpyN(tempC,newSize,temp);
    1517       CoinMemcpyN(status_+numberColumns_,       numberRows_,temp+newSize);
    1518       delete [] tempC;
    1519       delete [] status_;
    1520       status_ = temp;
    1521     } else {
    1522       // empty model - some systems don't like new [0]
    1523       delete [] status_;
    1524       status_ = NULL;
    1525     }
    1526   }
    1527   integerType_ = deleteChar(integerType_,numberColumns_,
    1528                             number, which, newSize,true);
     1482     if (!number)
     1483          return; // nothing to do
     1484     assert (maximumColumns_ < 0);
     1485     whatsChanged_ &= ~(1 + 2 + 4 + 8 + 64 + 128 + 256); // all except rows changed
     1486     int newSize = 0;
     1487     columnActivity_ = deleteDouble(columnActivity_, numberColumns_,
     1488                                    number, which, newSize);
     1489     reducedCost_ = deleteDouble(reducedCost_, numberColumns_,
     1490                                 number, which, newSize);
     1491     objective_->deleteSome(number, which);
     1492     columnLower_ = deleteDouble(columnLower_, numberColumns_,
     1493                                 number, which, newSize);
     1494     columnUpper_ = deleteDouble(columnUpper_, numberColumns_,
     1495                                 number, which, newSize);
     1496     // possible matrix is not full
     1497     if (matrix_->getNumCols() < numberColumns_) {
     1498          int * which2 = new int [number];
     1499          int n = 0;
     1500          int nMatrix = matrix_->getNumCols();
     1501          for (int i = 0; i < number; i++) {
     1502               if (which[i] < nMatrix)
     1503                    which2[n++] = which[i];
     1504          }
     1505          matrix_->deleteCols(n, which2);
     1506          delete [] which2;
     1507     } else {
     1508          matrix_->deleteCols(number, which);
     1509     }
     1510     //matrix_->removeGaps();
     1511     // status
     1512     if (status_) {
     1513          if (numberRows_ + newSize) {
     1514               unsigned char * tempC  = reinterpret_cast<unsigned char *>
     1515                                        (deleteChar(reinterpret_cast<char *>(status_),
     1516                                                    numberColumns_,
     1517                                                    number, which, newSize, false));
     1518               unsigned char * temp = new unsigned char [numberRows_+newSize];
     1519               CoinMemcpyN(tempC, newSize, temp);
     1520               CoinMemcpyN(status_ + numberColumns_,    numberRows_, temp + newSize);
     1521               delete [] tempC;
     1522               delete [] status_;
     1523               status_ = temp;
     1524          } else {
     1525               // empty model - some systems don't like new [0]
     1526               delete [] status_;
     1527               status_ = NULL;
     1528          }
     1529     }
     1530     integerType_ = deleteChar(integerType_, numberColumns_,
     1531                               number, which, newSize, true);
    15291532#ifndef CLP_NO_STD
    1530   // Now works if which out of order
    1531   if (lengthNames_) {
    1532     char * mark = new char [numberColumns_];
    1533     CoinZeroN(mark,numberColumns_);
    1534     int i;
    1535     for (i=0;i<number;i++)
    1536       mark[which[i]]=1;
    1537     int k=0;
    1538     for ( i = 0; i < numberColumns_; ++i) {
    1539       if (!mark[i])
    1540         columnNames_[k++] = columnNames_[i];
    1541     }
    1542     columnNames_.erase(columnNames_.begin()+k, columnNames_.end());
    1543     delete [] mark;
    1544   }
    1545 #endif
    1546   numberColumns_=newSize;
    1547   // set state back to unknown
    1548   problemStatus_ = -1;
    1549   secondaryStatus_ = 0;
    1550   delete [] ray_;
    1551   ray_ = NULL;
    1552   setRowScale(NULL);
    1553   setColumnScale(NULL);
     1533     // Now works if which out of order
     1534     if (lengthNames_) {
     1535          char * mark = new char [numberColumns_];
     1536          CoinZeroN(mark, numberColumns_);
     1537          int i;
     1538          for (i = 0; i < number; i++)
     1539               mark[which[i]] = 1;
     1540          int k = 0;
     1541          for ( i = 0; i < numberColumns_; ++i) {
     1542               if (!mark[i])
     1543                    columnNames_[k++] = columnNames_[i];
     1544          }
     1545          columnNames_.erase(columnNames_.begin() + k, columnNames_.end());
     1546          delete [] mark;
     1547     }
     1548#endif
     1549     numberColumns_ = newSize;
     1550     // set state back to unknown
     1551     problemStatus_ = -1;
     1552     secondaryStatus_ = 0;
     1553     delete [] ray_;
     1554     ray_ = NULL;
     1555     setRowScale(NULL);
     1556     setColumnScale(NULL);
    15541557}
    15551558// Add one row
    1556 void 
     1559void
    15571560ClpModel::addRow(int numberInRow, const int * columns,
    15581561                 const double * elements, double rowLower, double rowUpper)
    15591562{
    1560   CoinBigIndex starts[2];
    1561   starts[0]=0;
    1562   starts[1]=numberInRow;
    1563   addRows(1, &rowLower, &rowUpper,starts,columns,elements);
     1563     CoinBigIndex starts[2];
     1564     starts[0] = 0;
     1565     starts[1] = numberInRow;
     1566     addRows(1, &rowLower, &rowUpper, starts, columns, elements);
    15641567}
    15651568// Add rows
    1566 void 
    1567 ClpModel::addRows(int number, const double * rowLower, 
    1568                   const double * rowUpper,
    1569                   const CoinBigIndex * rowStarts, const int * columns,
    1570                   const double * elements)
    1571 {
    1572   if (number) {
    1573     whatsChanged_ &= ~(1+2+8+16+32); // all except columns changed
    1574     int numberRowsNow = numberRows_;
    1575     resize(numberRowsNow+number,numberColumns_);
    1576     double * lower = rowLower_+numberRowsNow;
    1577     double * upper = rowUpper_+numberRowsNow;
    1578     int iRow;
    1579     if (rowLower) {
    1580       for (iRow = 0; iRow < number; iRow++) {
    1581         double value = rowLower[iRow];
    1582         if (value<-1.0e20)
    1583           value = -COIN_DBL_MAX;
    1584         lower[iRow]= value;
    1585       }
    1586     } else {
    1587       for (iRow = 0; iRow < number; iRow++) {
    1588         lower[iRow]= -COIN_DBL_MAX;
    1589       }
    1590     }
    1591     if (rowUpper) {
    1592       for (iRow = 0; iRow < number; iRow++) {
    1593         double value = rowUpper[iRow];
    1594         if (value>1.0e20)
    1595           value = COIN_DBL_MAX;
    1596         upper[iRow]= value;
    1597       }
    1598     } else {
    1599       for (iRow = 0; iRow < number; iRow++) {
    1600         upper[iRow]= COIN_DBL_MAX;
    1601       }
    1602     }
    1603     // Deal with matrix
    1604    
    1605     delete rowCopy_;
    1606     rowCopy_=NULL;
    1607     delete scaledMatrix_;
    1608     scaledMatrix_=NULL;
    1609     if (!matrix_)
    1610       createEmptyMatrix();
    1611     setRowScale(NULL);
    1612     setColumnScale(NULL);
     1569void
     1570ClpModel::addRows(int number, const double * rowLower,
     1571                  const double * rowUpper,
     1572                  const CoinBigIndex * rowStarts, const int * columns,
     1573                  const double * elements)
     1574{
     1575     if (number) {
     1576          whatsChanged_ &= ~(1 + 2 + 8 + 16 + 32); // all except columns changed
     1577          int numberRowsNow = numberRows_;
     1578          resize(numberRowsNow + number, numberColumns_);
     1579          double * lower = rowLower_ + numberRowsNow;
     1580          double * upper = rowUpper_ + numberRowsNow;
     1581          int iRow;
     1582          if (rowLower) {
     1583               for (iRow = 0; iRow < number; iRow++) {
     1584                    double value = rowLower[iRow];
     1585                    if (value < -1.0e20)
     1586                         value = -COIN_DBL_MAX;
     1587                    lower[iRow] = value;
     1588               }
     1589          } else {
     1590               for (iRow = 0; iRow < number; iRow++) {
     1591                    lower[iRow] = -COIN_DBL_MAX;
     1592               }
     1593          }
     1594          if (rowUpper) {
     1595               for (iRow = 0; iRow < number; iRow++) {
     1596                    double value = rowUpper[iRow];
     1597                    if (value > 1.0e20)
     1598                         value = COIN_DBL_MAX;
     1599                    upper[iRow] = value;
     1600               }
     1601          } else {
     1602               for (iRow = 0; iRow < number; iRow++) {
     1603                    upper[iRow] = COIN_DBL_MAX;
     1604               }
     1605          }
     1606          // Deal with matrix
     1607
     1608          delete rowCopy_;
     1609          rowCopy_ = NULL;
     1610          delete scaledMatrix_;
     1611          scaledMatrix_ = NULL;
     1612          if (!matrix_)
     1613               createEmptyMatrix();
     1614          setRowScale(NULL);
     1615          setColumnScale(NULL);
    16131616#ifndef CLP_NO_STD
    1614     if (lengthNames_) {
    1615       rowNames_.resize(numberRows_);
    1616     }
    1617 #endif
    1618     if (rowStarts) {
    1619       // Make sure matrix has correct number of columns
    1620       matrix_->getPackedMatrix()->reserve(numberColumns_,0,true);
    1621       matrix_->appendMatrix(number,0,rowStarts,columns,elements);
    1622     }
    1623   }
     1617          if (lengthNames_) {
     1618               rowNames_.resize(numberRows_);
     1619          }
     1620#endif
     1621          if (rowStarts) {
     1622               // Make sure matrix has correct number of columns
     1623               matrix_->getPackedMatrix()->reserve(numberColumns_, 0, true);
     1624               matrix_->appendMatrix(number, 0, rowStarts, columns, elements);
     1625          }
     1626     }
    16241627}
    16251628// Add rows
    1626 void 
    1627 ClpModel::addRows(int number, const double * rowLower, 
    1628                   const double * rowUpper,
    1629                   const CoinBigIndex * rowStarts,
    1630                   const int * rowLengths, const int * columns,
    1631                   const double * elements)
    1632 {
    1633   if (number) {
    1634     CoinBigIndex numberElements=0;
    1635     int iRow;
    1636     for (iRow=0;iRow<number;iRow++)
    1637       numberElements += rowLengths[iRow];
    1638     int * newStarts = new int[number+1];
    1639     int * newIndex = new int[numberElements];
    1640     double * newElements = new double[numberElements];
    1641     numberElements=0;
    1642     newStarts[0]=0;
    1643     for (iRow=0;iRow<number;iRow++) {
    1644       int iStart = rowStarts[iRow];
    1645       int length = rowLengths[iRow];
    1646       CoinMemcpyN(columns+iStart,length,newIndex+numberElements);
    1647       CoinMemcpyN(elements+iStart,length,newElements+numberElements);
    1648       numberElements += length;
    1649       newStarts[iRow+1]=numberElements;
    1650     }
    1651     addRows(number, rowLower, rowUpper,
    1652             newStarts,newIndex,newElements);
    1653     delete [] newStarts;
    1654     delete [] newIndex;
    1655     delete [] newElements;
    1656   }
     1629void
     1630ClpModel::addRows(int number, const double * rowLower,
     1631                  const double * rowUpper,
     1632                  const CoinBigIndex * rowStarts,
     1633                  const int * rowLengths, const int * columns,
     1634                  const double * elements)
     1635{
     1636     if (number) {
     1637          CoinBigIndex numberElements = 0;
     1638          int iRow;
     1639          for (iRow = 0; iRow < number; iRow++)
     1640               numberElements += rowLengths[iRow];
     1641          int * newStarts = new int[number+1];
     1642          int * newIndex = new int[numberElements];
     1643          double * newElements = new double[numberElements];
     1644          numberElements = 0;
     1645          newStarts[0] = 0;
     1646          for (iRow = 0; iRow < number; iRow++) {
     1647               int iStart = rowStarts[iRow];
     1648               int length = rowLengths[iRow];
     1649               CoinMemcpyN(columns + iStart, length, newIndex + numberElements);
     1650               CoinMemcpyN(elements + iStart, length, newElements + numberElements);
     1651               numberElements += length;
     1652               newStarts[iRow+1] = numberElements;
     1653          }
     1654          addRows(number, rowLower, rowUpper,
     1655                  newStarts, newIndex, newElements);
     1656          delete [] newStarts;
     1657          delete [] newIndex;
     1658          delete [] newElements;
     1659     }
    16571660}
    16581661#ifndef CLP_NO_VECTOR
    1659 void 
    1660 ClpModel::addRows(int number, const double * rowLower, 
    1661                   const double * rowUpper,
    1662                   const CoinPackedVectorBase * const * rows)
    1663 {
    1664   if (!number)
    1665     return;
    1666   whatsChanged_ &= ~(1+2+8+16+32); // all except columns changed
    1667   int numberRowsNow = numberRows_;
    1668   resize(numberRowsNow+number,numberColumns_);
    1669   double * lower = rowLower_+numberRowsNow;
    1670   double * upper = rowUpper_+numberRowsNow;
    1671   int iRow;
    1672   if (rowLower) {
    1673     for (iRow = 0; iRow < number; iRow++) {
    1674       double value = rowLower[iRow];
    1675       if (value<-1.0e20)
    1676         value = -COIN_DBL_MAX;
    1677       lower[iRow]= value;
    1678     }
    1679   } else {
    1680     for (iRow = 0; iRow < number; iRow++) {
    1681       lower[iRow]= -COIN_DBL_MAX;
    1682     }
    1683   }
    1684   if (rowUpper) {
    1685     for (iRow = 0; iRow < number; iRow++) {
    1686       double value = rowUpper[iRow];
    1687       if (value>1.0e20)
    1688         value = COIN_DBL_MAX;
    1689       upper[iRow]= value;
    1690     }
    1691   } else {
    1692     for (iRow = 0; iRow < number; iRow++) {
    1693       upper[iRow]= COIN_DBL_MAX;
    1694     }
    1695   }
    1696   // Deal with matrix
    1697 
    1698   delete rowCopy_;
    1699   rowCopy_=NULL;
    1700   delete scaledMatrix_;
    1701   scaledMatrix_=NULL;
    1702   if (!matrix_)
    1703     createEmptyMatrix();
    1704   if (rows)
    1705     matrix_->appendRows(number,rows);
    1706   setRowScale(NULL);
    1707   setColumnScale(NULL);
    1708   if (lengthNames_) {
    1709     rowNames_.resize(numberRows_);
    1710   }
     1662void
     1663ClpModel::addRows(int number, const double * rowLower,
     1664                  const double * rowUpper,
     1665                  const CoinPackedVectorBase * const * rows)
     1666{
     1667     if (!number)
     1668          return;
     1669     whatsChanged_ &= ~(1 + 2 + 8 + 16 + 32); // all except columns changed
     1670     int numberRowsNow = numberRows_;
     1671     resize(numberRowsNow + number, numberColumns_);
     1672     double * lower = rowLower_ + numberRowsNow;
     1673     double * upper = rowUpper_ + numberRowsNow;
     1674     int iRow;
     1675     if (rowLower) {
     1676          for (iRow = 0; iRow < number; iRow++) {
     1677               double value = rowLower[iRow];
     1678               if (value < -1.0e20)
     1679                    value = -COIN_DBL_MAX;
     1680               lower[iRow] = value;
     1681          }
     1682     } else {
     1683          for (iRow = 0; iRow < number; iRow++) {
     1684               lower[iRow] = -COIN_DBL_MAX;
     1685          }
     1686     }
     1687     if (rowUpper) {
     1688          for (iRow = 0; iRow < number; iRow++) {
     1689               double value = rowUpper[iRow];
     1690               if (value > 1.0e20)
     1691                    value = COIN_DBL_MAX;
     1692               upper[iRow] = value;
     1693          }
     1694     } else {
     1695          for (iRow = 0; iRow < number; iRow++) {
     1696               upper[iRow] = COIN_DBL_MAX;
     1697          }
     1698     }
     1699     // Deal with matrix
     1700
     1701     delete rowCopy_;
     1702     rowCopy_ = NULL;
     1703     delete scaledMatrix_;
     1704     scaledMatrix_ = NULL;
     1705     if (!matrix_)
     1706          createEmptyMatrix();
     1707     if (rows)
     1708          matrix_->appendRows(number, rows);
     1709     setRowScale(NULL);
     1710     setColumnScale(NULL);
     1711     if (lengthNames_) {
     1712          rowNames_.resize(numberRows_);
     1713     }
    17111714}
    17121715#endif
     
    17141717// Add rows from a build object
    17151718int
    1716 ClpModel::addRows(const CoinBuild & buildObject,bool tryPlusMinusOne,bool checkDuplicates)
    1717 {
    1718   CoinAssertHint (buildObject.type()==0,"Looks as if both addRows and addCols being used"); // check correct
    1719   int number = buildObject.numberRows();
    1720   int numberErrors=0;
    1721   if (number) {
    1722     CoinBigIndex size=0;
    1723     int iRow;
    1724     double * lower = new double [number];
    1725     double * upper = new double [number];
    1726     if ((!matrix_||!matrix_->getNumElements())&&tryPlusMinusOne) {
    1727       // See if can be +-1
    1728       for (iRow=0;iRow<number;iRow++) {
    1729         const int * columns;
    1730         const double * elements;
    1731         int numberElements = buildObject.row(iRow,lower[iRow],
    1732                                                 upper[iRow],
    1733                                                 columns,elements);
    1734         for (int i=0;i<numberElements;i++) {
    1735           // allow for zero elements
    1736           if (elements[i]) {
    1737             if (fabs(elements[i])==1.0) {
    1738               size++;
    1739             } else {
    1740               // bad
    1741               tryPlusMinusOne=false;
    1742             }
    1743           }
    1744         }
    1745         if (!tryPlusMinusOne)
    1746           break;
    1747       }
    1748     } else {
    1749       // Will add to whatever sort of matrix exists
    1750       tryPlusMinusOne=false;
    1751     }
    1752     if (!tryPlusMinusOne) {
    1753       CoinBigIndex numberElements = buildObject.numberElements();
    1754       CoinBigIndex * starts = new CoinBigIndex [number+1];
    1755       int * column = new int[numberElements];
    1756       double * element = new double[numberElements];
    1757       starts[0]=0;
    1758       numberElements=0;
    1759       for (iRow=0;iRow<number;iRow++) {
    1760         const int * columns;
    1761         const double * elements;
    1762         int numberElementsThis = buildObject.row(iRow,lower[iRow],upper[iRow],
    1763                                              columns,elements);
    1764         CoinMemcpyN(columns,numberElementsThis,column+numberElements);
    1765         CoinMemcpyN(elements,numberElementsThis,element+numberElements);
    1766         numberElements += numberElementsThis;
    1767         starts[iRow+1]=numberElements;
    1768       }
    1769       addRows(number, lower, upper,NULL);
    1770       // make sure matrix has enough columns
    1771       matrix_->setDimensions(-1,numberColumns_);
    1772       numberErrors=matrix_->appendMatrix(number,0,starts,column,element,
    1773                             checkDuplicates ? numberColumns_ : -1);
    1774       delete [] starts;
    1775       delete [] column;
    1776       delete [] element;
    1777     } else {
    1778       char * which=NULL; // for duplicates
    1779       if (checkDuplicates) {
    1780         which = new char[numberColumns_];
    1781         CoinZeroN(which,numberColumns_);
    1782       }
    1783       // build +-1 matrix
    1784       // arrays already filled in
    1785       addRows(number, lower, upper,NULL);
    1786       CoinBigIndex * startPositive = new CoinBigIndex [numberColumns_+1];
    1787       CoinBigIndex * startNegative = new CoinBigIndex [numberColumns_];
    1788       int * indices = new int [size];
    1789       CoinZeroN(startPositive,numberColumns_);
    1790       CoinZeroN(startNegative,numberColumns_);
    1791       int maxColumn=-1;
    1792       // need two passes
    1793       for (iRow=0;iRow<number;iRow++) {
    1794         const int * columns;
    1795         const double * elements;
    1796         int numberElements = buildObject.row(iRow,lower[iRow],
    1797                                                 upper[iRow],
    1798                                                 columns,elements);
    1799         for (int i=0;i<numberElements;i++) {
    1800           int iColumn=columns[i];
    1801           if (checkDuplicates) {
    1802             if (iColumn>=numberColumns_) {
    1803               if(which[iColumn])
    1804                 numberErrors++;
    1805               else
    1806                 which[iColumn]=1;
    1807             } else {
    1808               numberErrors++;
    1809               // and may as well switch off
    1810               checkDuplicates=false;
    1811             }
    1812           }
    1813           maxColumn = CoinMax(maxColumn,iColumn);
    1814           if (elements[i]==1.0) {
    1815             startPositive[iColumn]++;
    1816           } else if (elements[i]==-1.0) {
    1817             startNegative[iColumn]++;
    1818           }
    1819         }
    1820         if (checkDuplicates) {
    1821           for (int i=0;i<numberElements;i++) {
    1822             int iColumn=columns[i];
    1823             which[iColumn]=0;
    1824           }
    1825         }
    1826       }
    1827       // check size
    1828       int numberColumns = maxColumn+1;
    1829       CoinAssertHint (numberColumns<=numberColumns_,
    1830                       "rows having column indices >= numberColumns_");
    1831       size=0;
    1832       int iColumn;
    1833       for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1834         CoinBigIndex n=startPositive[iColumn];
    1835         startPositive[iColumn]=size;
    1836         size+= n;
    1837         n=startNegative[iColumn];
    1838         startNegative[iColumn]=size;
    1839         size+= n;
    1840       }
    1841       startPositive[numberColumns_]=size;
    1842       for (iRow=0;iRow<number;iRow++) {
    1843         const int * columns;
    1844         const double * elements;
    1845         int numberElements = buildObject.row(iRow,lower[iRow],
    1846                                                 upper[iRow],
    1847                                                 columns,elements);
    1848         for (int i=0;i<numberElements;i++) {
    1849           int iColumn=columns[i];
    1850           maxColumn = CoinMax(maxColumn,iColumn);
    1851           if (elements[i]==1.0) {
    1852             CoinBigIndex position = startPositive[iColumn];
    1853             indices[position]=iRow;
    1854             startPositive[iColumn]++;
    1855           } else if (elements[i]==-1.0) {
    1856             CoinBigIndex position = startNegative[iColumn];
    1857             indices[position]=iRow;
    1858             startNegative[iColumn]++;
    1859           }
    1860         }
    1861       }
    1862       // and now redo starts
    1863       for (iColumn=numberColumns_-1;iColumn>=0;iColumn--) {
    1864         startPositive[iColumn+1]=startNegative[iColumn];
    1865         startNegative[iColumn]=startPositive[iColumn];
    1866       }
    1867       startPositive[0]=0;
    1868       for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    1869         CoinBigIndex start = startPositive[iColumn];
    1870         CoinBigIndex end = startNegative[iColumn];
    1871         std::sort(indices+start,indices+end);
    1872         start = startNegative[iColumn];
    1873         end = startPositive[iColumn+1];
    1874         std::sort(indices+start,indices+end);
    1875       }
    1876       // Get good object
    1877       delete matrix_;
    1878       ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    1879       matrix->passInCopy(numberRows_,numberColumns,
    1880                          true,indices,startPositive,startNegative);
    1881       matrix_=matrix;
    1882       delete [] which;
    1883     }
    1884     delete [] lower;
    1885     delete [] upper;
    1886     // make sure matrix correct size
    1887     matrix_->setDimensions(numberRows_,numberColumns_);
    1888   }
    1889   return numberErrors;
     1719ClpModel::addRows(const CoinBuild & buildObject, bool tryPlusMinusOne, bool checkDuplicates)
     1720{
     1721     CoinAssertHint (buildObject.type() == 0, "Looks as if both addRows and addCols being used"); // check correct
     1722     int number = buildObject.numberRows();
     1723     int numberErrors = 0;
     1724     if (number) {
     1725          CoinBigIndex size = 0;
     1726          int iRow;
     1727          double * lower = new double [number];
     1728          double * upper = new double [number];
     1729          if ((!matrix_ || !matrix_->getNumElements()) && tryPlusMinusOne) {
     1730               // See if can be +-1
     1731               for (iRow = 0; iRow < number; iRow++) {
     1732                    const int * columns;
     1733                    const double * elements;
     1734                    int numberElements = buildObject.row(iRow, lower[iRow],
     1735                                                         upper[iRow],
     1736                                                         columns, elements);
     1737                    for (int i = 0; i < numberElements; i++) {
     1738                         // allow for zero elements
     1739                         if (elements[i]) {
     1740                              if (fabs(elements[i]) == 1.0) {
     1741                                   size++;
     1742                              } else {
     1743                                   // bad
     1744                                   tryPlusMinusOne = false;
     1745                              }
     1746                         }
     1747                    }
     1748                    if (!tryPlusMinusOne)
     1749                         break;
     1750               }
     1751          } else {
     1752               // Will add to whatever sort of matrix exists
     1753               tryPlusMinusOne = false;
     1754          }
     1755          if (!tryPlusMinusOne) {
     1756               CoinBigIndex numberElements = buildObject.numberElements();
     1757               CoinBigIndex * starts = new CoinBigIndex [number+1];
     1758               int * column = new int[numberElements];
     1759               double * element = new double[numberElements];
     1760               starts[0] = 0;
     1761               numberElements = 0;
     1762               for (iRow = 0; iRow < number; iRow++) {
     1763                    const int * columns;
     1764                    const double * elements;
     1765                    int numberElementsThis = buildObject.row(iRow, lower[iRow], upper[iRow],
     1766                                             columns, elements);
     1767                    CoinMemcpyN(columns, numberElementsThis, column + numberElements);
     1768                    CoinMemcpyN(elements, numberElementsThis, element + numberElements);
     1769                    numberElements += numberElementsThis;
     1770                    starts[iRow+1] = numberElements;
     1771               }
     1772               addRows(number, lower, upper, NULL);
     1773               // make sure matrix has enough columns
     1774               matrix_->setDimensions(-1, numberColumns_);
     1775               numberErrors = matrix_->appendMatrix(number, 0, starts, column, element,
     1776                                                    checkDuplicates ? numberColumns_ : -1);
     1777               delete [] starts;
     1778               delete [] column;
     1779               delete [] element;
     1780          } else {
     1781               char * which = NULL; // for duplicates
     1782               if (checkDuplicates) {
     1783                    which = new char[numberColumns_];
     1784                    CoinZeroN(which, numberColumns_);
     1785               }
     1786               // build +-1 matrix
     1787               // arrays already filled in
     1788               addRows(number, lower, upper, NULL);
     1789               CoinBigIndex * startPositive = new CoinBigIndex [numberColumns_+1];
     1790               CoinBigIndex * startNegative = new CoinBigIndex [numberColumns_];
     1791               int * indices = new int [size];
     1792               CoinZeroN(startPositive, numberColumns_);
     1793               CoinZeroN(startNegative, numberColumns_);
     1794               int maxColumn = -1;
     1795               // need two passes
     1796               for (iRow = 0; iRow < number; iRow++) {
     1797                    const int * columns;
     1798                    const double * elements;
     1799                    int numberElements = buildObject.row(iRow, lower[iRow],
     1800                                                         upper[iRow],
     1801                                                         columns, elements);
     1802                    for (int i = 0; i < numberElements; i++) {
     1803                         int iColumn = columns[i];
     1804                         if (checkDuplicates) {
     1805                              if (iColumn >= numberColumns_) {
     1806                                   if(which[iColumn])
     1807                                        numberErrors++;
     1808                                   else
     1809                                        which[iColumn] = 1;
     1810                              } else {
     1811                                   numberErrors++;
     1812                                   // and may as well switch off
     1813                                   checkDuplicates = false;
     1814                              }
     1815                         }
     1816                         maxColumn = CoinMax(maxColumn, iColumn);
     1817                         if (elements[i] == 1.0) {
     1818                              startPositive[iColumn]++;
     1819                         } else if (elements[i] == -1.0) {
     1820                              startNegative[iColumn]++;
     1821                         }
     1822                    }
     1823                    if (checkDuplicates) {
     1824                         for (int i = 0; i < numberElements; i++) {
     1825                              int iColumn = columns[i];
     1826                              which[iColumn] = 0;
     1827                         }
     1828                    }
     1829               }
     1830               // check size
     1831               int numberColumns = maxColumn + 1;
     1832               CoinAssertHint (numberColumns <= numberColumns_,
     1833                               "rows having column indices >= numberColumns_");
     1834               size = 0;
     1835               int iColumn;
     1836               for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     1837                    CoinBigIndex n = startPositive[iColumn];
     1838                    startPositive[iColumn] = size;
     1839                    size += n;
     1840                    n = startNegative[iColumn];
     1841                    startNegative[iColumn] = size;
     1842                    size += n;
     1843               }
     1844               startPositive[numberColumns_] = size;
     1845               for (iRow = 0; iRow < number; iRow++) {
     1846                    const int * columns;
     1847                    const double * elements;
     1848                    int numberElements = buildObject.row(iRow, lower[iRow],
     1849                                                         upper[iRow],
     1850                                                         columns, elements);
     1851                    for (int i = 0; i < numberElements; i++) {
     1852                         int iColumn = columns[i];
     1853                         maxColumn = CoinMax(maxColumn, iColumn);
     1854                         if (elements[i] == 1.0) {
     1855                              CoinBigIndex position = startPositive[iColumn];
     1856                              indices[position] = iRow;
     1857                              startPositive[iColumn]++;
     1858                         } else if (elements[i] == -1.0) {
     1859                              CoinBigIndex position = startNegative[iColumn];
     1860                              indices[position] = iRow;
     1861                              startNegative[iColumn]++;
     1862                         }
     1863                    }
     1864               }
     1865               // and now redo starts
     1866               for (iColumn = numberColumns_ - 1; iColumn >= 0; iColumn--) {
     1867                    startPositive[iColumn+1] = startNegative[iColumn];
     1868                    startNegative[iColumn] = startPositive[iColumn];
     1869               }
     1870               startPositive[0] = 0;
     1871               for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     1872                    CoinBigIndex start = startPositive[iColumn];
     1873                    CoinBigIndex end = startNegative[iColumn];
     1874                    std::sort(indices + start, indices + end);
     1875                    start = startNegative[iColumn];
     1876                    end = startPositive[iColumn+1];
     1877                    std::sort(indices + start, indices + end);
     1878               }
     1879               // Get good object
     1880               delete matrix_;
     1881               ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
     1882               matrix->passInCopy(numberRows_, numberColumns,
     1883                                  true, indices, startPositive, startNegative);
     1884               matrix_ = matrix;
     1885               delete [] which;
     1886          }
     1887          delete [] lower;
     1888          delete [] upper;
     1889          // make sure matrix correct size
     1890          matrix_->setDimensions(numberRows_, numberColumns_);
     1891     }
     1892     return numberErrors;
    18901893}
    18911894#endif
    18921895#ifndef SLIM_NOIO
    18931896// Add rows from a model object
    1894 int 
    1895 ClpModel::addRows( CoinModel & modelObject,bool tryPlusMinusOne,bool checkDuplicates)
    1896 {
    1897   if (modelObject.numberElements()==0)
    1898     return 0;
    1899   bool goodState=true;
    1900   int numberErrors=0;
    1901   if (modelObject.columnLowerArray()) {
    1902     // some column information exists
    1903     int numberColumns2 = modelObject.numberColumns();
    1904     const double * columnLower = modelObject.columnLowerArray();
    1905     const double * columnUpper = modelObject.columnUpperArray();
    1906     const double * objective = modelObject.objectiveArray();
    1907     const int * integerType = modelObject.integerTypeArray();
    1908     for (int i=0;i<numberColumns2;i++) {
    1909       if (columnLower[i]!=0.0)
    1910         goodState=false;
    1911       if (columnUpper[i]!=COIN_DBL_MAX)
    1912         goodState=false;
    1913       if (objective[i]!=0.0)
    1914         goodState=false;
    1915       if (integerType[i]!=0)
    1916         goodState=false;
    1917     }
    1918   }
    1919   if (goodState) {
    1920     // can do addRows
    1921     // Set arrays for normal use
    1922     double * rowLower = modelObject.rowLowerArray();
    1923     double * rowUpper = modelObject.rowUpperArray();
    1924     double * columnLower = modelObject.columnLowerArray();
    1925     double * columnUpper = modelObject.columnUpperArray();
    1926     double * objective = modelObject.objectiveArray();
    1927     int * integerType = modelObject.integerTypeArray();
    1928     double * associated = modelObject.associatedArray();
    1929     // If strings then do copies
    1930     if (modelObject.stringsExist()) {
    1931       numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
    1932                                  objective, integerType,associated);
    1933     }
    1934     int numberRows = numberRows_; // save number of rows
    1935     int numberRows2 = modelObject.numberRows();
    1936     if (numberRows2&&!numberErrors) {
    1937       CoinBigIndex * startPositive = NULL;
    1938       CoinBigIndex * startNegative = NULL;
    1939       int numberColumns = modelObject.numberColumns();
    1940       if ((!matrix_||!matrix_->getNumElements())&&!numberRows&&tryPlusMinusOne) {
    1941         startPositive = new CoinBigIndex[numberColumns+1];
    1942         startNegative = new CoinBigIndex[numberColumns];
    1943         modelObject.countPlusMinusOne(startPositive,startNegative,associated);
    1944         if (startPositive[0]<0) {
    1945           // no good
    1946           tryPlusMinusOne=false;
    1947           delete [] startPositive;
    1948           delete [] startNegative;
    1949         }
    1950       } else {
    1951         // Will add to whatever sort of matrix exists
    1952         tryPlusMinusOne=false;
    1953       }
    1954       assert (rowLower);
    1955       addRows(numberRows2, rowLower, rowUpper,NULL,NULL,NULL);
     1897int
     1898ClpModel::addRows( CoinModel & modelObject, bool tryPlusMinusOne, bool checkDuplicates)
     1899{
     1900     if (modelObject.numberElements() == 0)
     1901          return 0;
     1902     bool goodState = true;
     1903     int numberErrors = 0;
     1904     if (modelObject.columnLowerArray()) {
     1905          // some column information exists
     1906          int numberColumns2 = modelObject.numberColumns();
     1907          const double * columnLower = modelObject.columnLowerArray();
     1908          const double * columnUpper = modelObject.columnUpperArray();
     1909          const double * objective = modelObject.objectiveArray();
     1910          const int * integerType = modelObject.integerTypeArray();
     1911          for (int i = 0; i < numberColumns2; i++) {
     1912               if (columnLower[i] != 0.0)
     1913                    goodState = false;
     1914               if (columnUpper[i] != COIN_DBL_MAX)
     1915                    goodState = false;
     1916               if (objective[i] != 0.0)
     1917                    goodState = false;
     1918               if (integerType[i] != 0)
     1919                    goodState = false;
     1920          }
     1921     }
     1922     if (goodState) {
     1923          // can do addRows
     1924          // Set arrays for normal use
     1925          double * rowLower = modelObject.rowLowerArray();
     1926          double * rowUpper = modelObject.rowUpperArray();
     1927          double * columnLower = modelObject.columnLowerArray();
     1928          double * columnUpper = modelObject.columnUpperArray();
     1929          double * objective = modelObject.objectiveArray();
     1930          int * integerType = modelObject.integerTypeArray();
     1931          double * associated = modelObject.associatedArray();
     1932          // If strings then do copies
     1933          if (modelObject.stringsExist()) {
     1934               numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
     1935                                                       objective, integerType, associated);
     1936          }
     1937          int numberRows = numberRows_; // save number of rows
     1938          int numberRows2 = modelObject.numberRows();
     1939          if (numberRows2 && !numberErrors) {
     1940               CoinBigIndex * startPositive = NULL;
     1941               CoinBigIndex * startNegative = NULL;
     1942               int numberColumns = modelObject.numberColumns();
     1943               if ((!matrix_ || !matrix_->getNumElements()) && !numberRows && tryPlusMinusOne) {
     1944                    startPositive = new CoinBigIndex[numberColumns+1];
     1945                    startNegative = new CoinBigIndex[numberColumns];
     1946                    modelObject.countPlusMinusOne(startPositive, startNegative, associated);
     1947                    if (startPositive[0] < 0) {
     1948                         // no good
     1949                         tryPlusMinusOne = false;
     1950                         delete [] startPositive;
     1951                         delete [] startNegative;
     1952                    }
     1953               } else {
     1954                    // Will add to whatever sort of matrix exists
     1955                    tryPlusMinusOne = false;
     1956               }
     1957               assert (rowLower);
     1958               addRows(numberRows2, rowLower, rowUpper, NULL, NULL, NULL);
    19561959#ifndef SLIM_CLP
    1957       if (!tryPlusMinusOne) {
    1958 #endif
    1959         CoinPackedMatrix matrix;
    1960         modelObject.createPackedMatrix(matrix,associated);
    1961         assert (!matrix.getExtraGap());
    1962         if (matrix_->getNumRows()) {
    1963           // matrix by rows
    1964           matrix.reverseOrdering();
    1965           assert (!matrix.getExtraGap());
    1966           const int * column = matrix.getIndices();
    1967           //const int * rowLength = matrix.getVectorLengths();
    1968           const CoinBigIndex * rowStart = matrix.getVectorStarts();
    1969           const double * element = matrix.getElements();
    1970           // make sure matrix has enough columns
    1971           matrix_->setDimensions(-1,numberColumns_);
    1972           numberErrors+=matrix_->appendMatrix(numberRows2,0,rowStart,column,element,
    1973                                 checkDuplicates ? numberColumns_ : -1);
    1974         } else {
    1975           delete matrix_;
    1976           matrix_ = new ClpPackedMatrix(matrix);
    1977         }
     1960               if (!tryPlusMinusOne) {
     1961#endif
     1962                    CoinPackedMatrix matrix;
     1963                    modelObject.createPackedMatrix(matrix, associated);
     1964                    assert (!matrix.getExtraGap());
     1965                    if (matrix_->getNumRows()) {
     1966                         // matrix by rows
     1967                         matrix.reverseOrdering();
     1968                         assert (!matrix.getExtraGap());
     1969                         const int * column = matrix.getIndices();
     1970                         //const int * rowLength = matrix.getVectorLengths();
     1971                         const CoinBigIndex * rowStart = matrix.getVectorStarts();
     1972                         const double * element = matrix.getElements();
     1973                         // make sure matrix has enough columns
     1974                         matrix_->setDimensions(-1, numberColumns_);
     1975                         numberErrors += matrix_->appendMatrix(numberRows2, 0, rowStart, column, element,
     1976                                                               checkDuplicates ? numberColumns_ : -1);
     1977                    } else {
     1978                         delete matrix_;
     1979                         matrix_ = new ClpPackedMatrix(matrix);
     1980                    }
    19781981#ifndef SLIM_CLP
    1979       } else {
    1980         // create +-1 matrix
    1981         CoinBigIndex size = startPositive[numberColumns];
    1982         int * indices = new int[size];
    1983         modelObject.createPlusMinusOne(startPositive,startNegative,indices,
    1984                                        associated);
    1985         // Get good object
    1986         ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    1987         matrix->passInCopy(numberRows2,numberColumns,
    1988                            true,indices,startPositive,startNegative);
    1989         delete matrix_;
    1990         matrix_=matrix;
    1991       }
    1992       // Do names if wanted
    1993       if (modelObject.rowNames()->numberItems()) {
    1994         const char *const * rowNames=modelObject.rowNames()->names();
    1995         copyRowNames(rowNames,numberRows,numberRows_);
    1996       }
    1997 #endif
    1998     }
    1999     if (rowLower!=modelObject.rowLowerArray()) {
    2000       delete [] rowLower;
    2001       delete [] rowUpper;
    2002       delete [] columnLower;
    2003       delete [] columnUpper;
    2004       delete [] objective;
    2005       delete [] integerType;
    2006       delete [] associated;
    2007       if (numberErrors)
    2008         handler_->message(CLP_BAD_STRING_VALUES,messages_)
    2009           <<numberErrors
    2010           <<CoinMessageEol;
    2011     }
    2012     return numberErrors;
    2013   } else {
    2014     // not suitable for addRows
    2015     handler_->message(CLP_COMPLICATED_MODEL,messages_)
    2016       <<modelObject.numberRows()
    2017       <<modelObject.numberColumns()
    2018       <<CoinMessageEol;
    2019     return -1;
    2020   }
     1982               } else {
     1983                    // create +-1 matrix
     1984                    CoinBigIndex size = startPositive[numberColumns];
     1985                    int * indices = new int[size];
     1986                    modelObject.createPlusMinusOne(startPositive, startNegative, indices,
     1987                                                   associated);
     1988                    // Get good object
     1989                    ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
     1990                    matrix->passInCopy(numberRows2, numberColumns,
     1991                                       true, indices, startPositive, startNegative);
     1992                    delete matrix_;
     1993                    matrix_ = matrix;
     1994               }
     1995               // Do names if wanted
     1996               if (modelObject.rowNames()->numberItems()) {
     1997                    const char *const * rowNames = modelObject.rowNames()->names();
     1998                    copyRowNames(rowNames, numberRows, numberRows_);
     1999               }
     2000#endif
     2001          }
     2002          if (rowLower != modelObject.rowLowerArray()) {
     2003               delete [] rowLower;
     2004               delete [] rowUpper;
     2005               delete [] columnLower;
     2006               delete [] columnUpper;
     2007               delete [] objective;
     2008               delete [] integerType;
     2009               delete [] associated;
     2010               if (numberErrors)
     2011                    handler_->message(CLP_BAD_STRING_VALUES, messages_)
     2012                              << numberErrors
     2013                              << CoinMessageEol;
     2014          }
     2015          return numberErrors;
     2016     } else {
     2017          // not suitable for addRows
     2018          handler_->message(CLP_COMPLICATED_MODEL, messages_)
     2019                    << modelObject.numberRows()
     2020                    << modelObject.numberColumns()
     2021                    << CoinMessageEol;
     2022          return -1;
     2023     }
    20212024}
    20222025#endif
    20232026// Add one column
    2024 void 
     2027void
    20252028ClpModel::addColumn(int numberInColumn,
    2026                  const int * rows,
    2027                  const double * elements,
    2028                  double columnLower,
    2029                  double  columnUpper,
    2030                  double  objective)
    2031 {
    2032   CoinBigIndex starts[2];
    2033   starts[0]=0;
    2034   starts[1]=numberInColumn;
    2035   addColumns(1, &columnLower, &columnUpper,&objective,starts,rows,elements);
     2029                    const int * rows,
     2030                    const double * elements,
     2031                    double columnLower,
     2032                    double  columnUpper,
     2033                    double  objective)
     2034{
     2035     CoinBigIndex starts[2];
     2036     starts[0] = 0;
     2037     starts[1] = numberInColumn;
     2038     addColumns(1, &columnLower, &columnUpper, &objective, starts, rows, elements);
    20362039}
    20372040// Add columns
    2038 void 
    2039 ClpModel::addColumns(int number, const double * columnLower, 
    2040                      const double * columnUpper,
    2041                      const double * objIn,
    2042                      const int * columnStarts, const int * rows,
    2043                      const double * elements)
    2044 {
    2045   // Create a list of CoinPackedVectors
    2046   if (number) {
    2047     whatsChanged_ &= ~(1+2+4+64+128+256); // all except rows changed
    2048     int numberColumnsNow = numberColumns_;
    2049     resize(numberRows_,numberColumnsNow+number);
    2050     double * lower = columnLower_+numberColumnsNow;
    2051     double * upper = columnUpper_+numberColumnsNow;
    2052     double * obj = objective()+numberColumnsNow;
    2053     int iColumn;
    2054     if (columnLower) {
    2055       for (iColumn = 0; iColumn < number; iColumn++) {
    2056         double value = columnLower[iColumn];
    2057         if (value<-1.0e20)
    2058           value = -COIN_DBL_MAX;
    2059         lower[iColumn]= value;
    2060       }
    2061     } else {
    2062       for (iColumn = 0; iColumn < number; iColumn++) {
    2063         lower[iColumn]= 0.0;
    2064       }
    2065     }
    2066     if (columnUpper) {
    2067       for (iColumn = 0; iColumn < number; iColumn++) {
    2068         double value = columnUpper[iColumn];
    2069         if (value>1.0e20)
    2070           value = COIN_DBL_MAX;
    2071         upper[iColumn]= value;
    2072       }
    2073     } else {
    2074       for (iColumn = 0; iColumn < number; iColumn++) {
    2075         upper[iColumn]= COIN_DBL_MAX;
    2076       }
    2077     }
    2078     if (objIn) {
    2079       for (iColumn = 0; iColumn < number; iColumn++) {
    2080         obj[iColumn] = objIn[iColumn];
    2081       }
    2082     } else {
    2083       for (iColumn = 0; iColumn < number; iColumn++) {
    2084         obj[iColumn]= 0.0;
    2085       }
    2086     }
    2087     // Deal with matrix
    2088    
    2089     delete rowCopy_;
    2090     rowCopy_=NULL;
    2091     delete scaledMatrix_;
    2092     scaledMatrix_=NULL;
    2093     if (!matrix_)
    2094       createEmptyMatrix();
    2095     setRowScale(NULL);
    2096     setColumnScale(NULL);
     2041void
     2042ClpModel::addColumns(int number, const double * columnLower,
     2043                     const double * columnUpper,
     2044                     const double * objIn,
     2045                     const int * columnStarts, const int * rows,
     2046                     const double * elements)
     2047{
     2048     // Create a list of CoinPackedVectors
     2049     if (number) {
     2050          whatsChanged_ &= ~(1 + 2 + 4 + 64 + 128 + 256); // all except rows changed
     2051          int numberColumnsNow = numberColumns_;
     2052          resize(numberRows_, numberColumnsNow + number);
     2053          double * lower = columnLower_ + numberColumnsNow;
     2054          double * upper = columnUpper_ + numberColumnsNow;
     2055          double * obj = objective() + numberColumnsNow;
     2056          int iColumn;
     2057          if (columnLower) {
     2058               for (iColumn = 0; iColumn < number; iColumn++) {
     2059                    double value = columnLower[iColumn];
     2060                    if (value < -1.0e20)
     2061                         value = -COIN_DBL_MAX;
     2062                    lower[iColumn] = value;
     2063               }
     2064          } else {
     2065               for (iColumn = 0; iColumn < number; iColumn++) {
     2066                    lower[iColumn] = 0.0;
     2067               }
     2068          }
     2069          if (columnUpper) {
     2070               for (iColumn = 0; iColumn < number; iColumn++) {
     2071                    double value = columnUpper[iColumn];
     2072                    if (value > 1.0e20)
     2073                         value = COIN_DBL_MAX;
     2074                    upper[iColumn] = value;
     2075               }
     2076          } else {
     2077               for (iColumn = 0; iColumn < number; iColumn++) {
     2078                    upper[iColumn] = COIN_DBL_MAX;
     2079               }
     2080          }
     2081          if (objIn) {
     2082               for (iColumn = 0; iColumn < number; iColumn++) {
     2083                    obj[iColumn] = objIn[iColumn];
     2084               }
     2085          } else {
     2086               for (iColumn = 0; iColumn < number; iColumn++) {
     2087                    obj[iColumn] = 0.0;
     2088               }
     2089          }
     2090          // Deal with matrix
     2091
     2092          delete rowCopy_;
     2093          rowCopy_ = NULL;
     2094          delete scaledMatrix_;
     2095          scaledMatrix_ = NULL;
     2096          if (!matrix_)
     2097               createEmptyMatrix();
     2098          setRowScale(NULL);
     2099          setColumnScale(NULL);
    20972100#ifndef CLP_NO_STD
    2098     if (lengthNames_) {
    2099       columnNames_.resize(numberColumns_);
    2100     }
    2101 #endif
    2102     //if (elements)
    2103     matrix_->appendMatrix(number,1,columnStarts,rows,elements);
    2104   }
     2101          if (lengthNames_) {
     2102               columnNames_.resize(numberColumns_);
     2103          }
     2104#endif
     2105          //if (elements)
     2106          matrix_->appendMatrix(number, 1, columnStarts, rows, elements);
     2107     }
    21052108}
    21062109// Add columns
    2107 void 
    2108 ClpModel::addColumns(int number, const double * columnLower, 
    2109                      const double * columnUpper,
    2110                      const double * objIn,
    2111                      const int * columnStarts,
    2112                      const int * columnLengths, const int * rows,
    2113                      const double * elements)
    2114 {
    2115   if (number) {
    2116     CoinBigIndex numberElements=0;
    2117     int iColumn;
    2118     for (iColumn=0;iColumn<number;iColumn++)
    2119       numberElements += columnLengths[iColumn];
    2120     int * newStarts = new int[number+1];
    2121     int * newIndex = new int[numberElements];
    2122     double * newElements = new double[numberElements];
    2123     numberElements=0;
    2124     newStarts[0]=0;
    2125     for (iColumn=0;iColumn<number;iColumn++) {
    2126       int iStart = columnStarts[iColumn];
    2127       int length = columnLengths[iColumn];
    2128       CoinMemcpyN(rows+iStart,length,newIndex+numberElements);
    2129       CoinMemcpyN(elements+iStart,length,newElements+numberElements);
    2130       numberElements += length;
    2131       newStarts[iColumn+1]=numberElements;
    2132     }
    2133     addColumns(number, columnLower, columnUpper,objIn,
    2134             newStarts,newIndex,newElements);
    2135     delete [] newStarts;
    2136     delete [] newIndex;
    2137     delete [] newElements;
    2138   }
     2110void
     2111ClpModel::addColumns(int number, const double * columnLower,
     2112                     const double * columnUpper,
     2113                     const double * objIn,
     2114                     const int * columnStarts,
     2115                     const int * columnLengths, const int * rows,
     2116                     const double * elements)
     2117{
     2118     if (number) {
     2119          CoinBigIndex numberElements = 0;
     2120          int iColumn;
     2121          for (iColumn = 0; iColumn < number; iColumn++)
     2122               numberElements += columnLengths[iColumn];
     2123          int * newStarts = new int[number+1];
     2124          int * newIndex = new int[numberElements];
     2125          double * newElements = new double[numberElements];
     2126          numberElements = 0;
     2127          newStarts[0] = 0;
     2128          for (iColumn = 0; iColumn < number; iColumn++) {
     2129               int iStart = columnStarts[iColumn];
     2130               int length = columnLengths[iColumn];
     2131               CoinMemcpyN(rows + iStart, length, newIndex + numberElements);
     2132               CoinMemcpyN(elements + iStart, length, newElements + numberElements);
     2133               numberElements += length;
     2134               newStarts[iColumn+1] = numberElements;
     2135          }
     2136          addColumns(number, columnLower, columnUpper, objIn,
     2137                     newStarts, newIndex, newElements);
     2138          delete [] newStarts;
     2139          delete [] newIndex;
     2140          delete [] newElements;
     2141     }
    21392142}
    21402143#ifndef CLP_NO_VECTOR
    2141 void 
    2142 ClpModel::addColumns(int number, const double * columnLower, 
    2143                      const double * columnUpper,
    2144                      const double * objIn,
    2145                      const CoinPackedVectorBase * const * columns)
    2146 {
    2147   if (!number)
    2148     return;
    2149   whatsChanged_ &= ~(1+2+4+64+128+256); // all except rows changed
    2150   int numberColumnsNow = numberColumns_;
    2151   resize(numberRows_,numberColumnsNow+number);
    2152   double * lower = columnLower_+numberColumnsNow;
    2153   double * upper = columnUpper_+numberColumnsNow;
    2154   double * obj = objective()+numberColumnsNow;
    2155   int iColumn;
    2156   if (columnLower) {
    2157     for (iColumn = 0; iColumn < number; iColumn++) {
    2158       double value = columnLower[iColumn];
    2159       if (value<-1.0e20)
    2160         value = -COIN_DBL_MAX;
    2161       lower[iColumn]= value;
    2162     }
    2163   } else {
    2164     for (iColumn = 0; iColumn < number; iColumn++) {
    2165       lower[iColumn]= 0.0;
    2166     }
    2167   }
    2168   if (columnUpper) {
    2169     for (iColumn = 0; iColumn < number; iColumn++) {
    2170       double value = columnUpper[iColumn];
    2171       if (value>1.0e20)
    2172         value = COIN_DBL_MAX;
    2173       upper[iColumn]= value;
    2174     }
    2175   } else {
    2176     for (iColumn = 0; iColumn < number; iColumn++) {
    2177       upper[iColumn]= COIN_DBL_MAX;
    2178     }
    2179   }
    2180   if (objIn) {
    2181     for (iColumn = 0; iColumn < number; iColumn++) {
    2182       obj[iColumn] = objIn[iColumn];
    2183     }
    2184   } else {
    2185     for (iColumn = 0; iColumn < number; iColumn++) {
    2186       obj[iColumn]= 0.0;
    2187     }
    2188   }
    2189   // Deal with matrix
    2190 
    2191   delete rowCopy_;
    2192   rowCopy_=NULL;
    2193   delete scaledMatrix_; 
    2194   scaledMatrix_=NULL;
    2195   if (!matrix_)
    2196     createEmptyMatrix();
    2197   if (columns)
    2198     matrix_->appendCols(number,columns);
    2199   setRowScale(NULL);
    2200   setColumnScale(NULL);
    2201   if (lengthNames_) {
    2202     columnNames_.resize(numberColumns_);
    2203   }
     2144void
     2145ClpModel::addColumns(int number, const double * columnLower,
     2146                     const double * columnUpper,
     2147                     const double * objIn,
     2148                     const CoinPackedVectorBase * const * columns)
     2149{
     2150     if (!number)
     2151          return;
     2152     whatsChanged_ &= ~(1 + 2 + 4 + 64 + 128 + 256); // all except rows changed
     2153     int numberColumnsNow = numberColumns_;
     2154     resize(numberRows_, numberColumnsNow + number);
     2155     double * lower = columnLower_ + numberColumnsNow;
     2156     double * upper = columnUpper_ + numberColumnsNow;
     2157     double * obj = objective() + numberColumnsNow;
     2158     int iColumn;
     2159     if (columnLower) {
     2160          for (iColumn = 0; iColumn < number; iColumn++) {
     2161               double value = columnLower[iColumn];
     2162               if (value < -1.0e20)
     2163                    value = -COIN_DBL_MAX;
     2164               lower[iColumn] = value;
     2165          }
     2166     } else {
     2167          for (iColumn = 0; iColumn < number; iColumn++) {
     2168               lower[iColumn] = 0.0;
     2169          }
     2170     }
     2171     if (columnUpper) {
     2172          for (iColumn = 0; iColumn < number; iColumn++) {
     2173               double value = columnUpper[iColumn];
     2174               if (value > 1.0e20)
     2175                    value = COIN_DBL_MAX;
     2176               upper[iColumn] = value;
     2177          }
     2178     } else {
     2179          for (iColumn = 0; iColumn < number; iColumn++) {
     2180               upper[iColumn] = COIN_DBL_MAX;
     2181          }
     2182     }
     2183     if (objIn) {
     2184          for (iColumn = 0; iColumn < number; iColumn++) {
     2185               obj[iColumn] = objIn[iColumn];
     2186          }
     2187     } else {
     2188          for (iColumn = 0; iColumn < number; iColumn++) {
     2189               obj[iColumn] = 0.0;
     2190          }
     2191     }
     2192     // Deal with matrix
     2193
     2194     delete rowCopy_;
     2195     rowCopy_ = NULL;
     2196     delete scaledMatrix_;
     2197     scaledMatrix_ = NULL;
     2198     if (!matrix_)
     2199          createEmptyMatrix();
     2200     if (columns)
     2201          matrix_->appendCols(number, columns);
     2202     setRowScale(NULL);
     2203     setColumnScale(NULL);
     2204     if (lengthNames_) {
     2205          columnNames_.resize(numberColumns_);
     2206     }
    22042207}
    22052208#endif
    22062209#ifndef SLIM_CLP
    22072210// Add columns from a build object
    2208 int 
    2209 ClpModel::addColumns(const CoinBuild & buildObject,bool tryPlusMinusOne,bool checkDuplicates)
    2210 {
    2211   CoinAssertHint (buildObject.type()==1,"Looks as if both addRows and addCols being used"); // check correct
    2212   int number = buildObject.numberColumns();
    2213   int numberErrors=0;
    2214   if (number) {
    2215     CoinBigIndex size=0;
    2216     int maximumLength=0;
    2217     double * lower = new double [number];
    2218     double * upper = new double [number];
    2219     int iColumn;
    2220     double * objective = new double [number];
    2221     if ((!matrix_||!matrix_->getNumElements())&&tryPlusMinusOne) {
    2222       // See if can be +-1
    2223       for (iColumn=0;iColumn<number;iColumn++) {
    2224         const int * rows;
    2225         const double * elements;
    2226         int numberElements = buildObject.column(iColumn,lower[iColumn],
    2227                                                 upper[iColumn],objective[iColumn],
    2228                                                 rows,elements);
    2229         maximumLength = CoinMax(maximumLength,numberElements);
    2230         for (int i=0;i<numberElements;i++) {
    2231           // allow for zero elements
    2232           if (elements[i]) {
    2233             if (fabs(elements[i])==1.0) {
    2234               size++;
    2235             } else {
    2236               // bad
    2237               tryPlusMinusOne=false;
    2238             }
    2239           }
    2240         }
    2241         if (!tryPlusMinusOne)
    2242           break;
    2243       }
    2244     } else {
    2245       // Will add to whatever sort of matrix exists
    2246       tryPlusMinusOne=false;
    2247     }
    2248     if (!tryPlusMinusOne) {
    2249       CoinBigIndex numberElements = buildObject.numberElements();
    2250       CoinBigIndex * starts = new CoinBigIndex [number+1];
    2251       int * row = new int[numberElements];
    2252       double * element = new double[numberElements];
    2253       starts[0]=0;
    2254       numberElements=0;
    2255       for (iColumn=0;iColumn<number;iColumn++) {
    2256         const int * rows;
    2257         const double * elements;
    2258         int numberElementsThis = buildObject.column(iColumn,lower[iColumn],upper[iColumn],
    2259                                              objective[iColumn],rows,elements);
    2260         CoinMemcpyN(rows,numberElementsThis,row+numberElements);
    2261         CoinMemcpyN(elements,numberElementsThis,element+numberElements);
    2262         numberElements += numberElementsThis;
    2263         starts[iColumn+1]=numberElements;
    2264       }
    2265       addColumns(number, lower, upper,objective,NULL);
    2266       // make sure matrix has enough rows
    2267       matrix_->setDimensions(numberRows_,-1);
    2268       numberErrors=matrix_->appendMatrix(number,1,starts,row,element,
    2269                             checkDuplicates ? numberRows_ : -1);
    2270       delete [] starts;
    2271       delete [] row;
    2272       delete [] element;
    2273     } else {
    2274       // arrays already filled in
    2275       addColumns(number, lower, upper,objective,NULL);
    2276       char * which=NULL; // for duplicates
    2277       if (checkDuplicates) {
    2278         which = new char[numberRows_];
    2279         CoinZeroN(which,numberRows_);
    2280       }
    2281       // build +-1 matrix
    2282       CoinBigIndex * startPositive = new CoinBigIndex [number+1];
    2283       CoinBigIndex * startNegative = new CoinBigIndex [number];
    2284       int * indices = new int [size];
    2285       int * neg = new int[maximumLength];
    2286       startPositive[0]=0;
    2287       size=0;
    2288       int maxRow=-1;
    2289       for (iColumn=0;iColumn<number;iColumn++) {
    2290         const int * rows;
    2291         const double * elements;
    2292         int numberElements = buildObject.column(iColumn,lower[iColumn],
    2293                                                 upper[iColumn],objective[iColumn],
    2294                                                 rows,elements);
    2295         int nNeg=0;
    2296         CoinBigIndex start = size;
    2297         for (int i=0;i<numberElements;i++) {
    2298           int iRow=rows[i];
    2299           if (checkDuplicates) {
    2300             if (iRow>=numberRows_) {
    2301               if(which[iRow])
    2302                 numberErrors++;
    2303               else
    2304                 which[iRow]=1;
    2305             } else {
    2306               numberErrors++;
    2307               // and may as well switch off
    2308               checkDuplicates=false;
    2309             }
    2310           }
    2311           maxRow = CoinMax(maxRow,iRow);
    2312           if (elements[i]==1.0) {
    2313             indices[size++]=iRow;
    2314           } else if (elements[i]==-1.0) {
    2315             neg[nNeg++]=iRow;
    2316           }
    2317         }
    2318         std::sort(indices+start,indices+size);
    2319         std::sort(neg,neg+nNeg);
    2320         startNegative[iColumn]=size;
    2321         CoinMemcpyN(neg,nNeg,indices+size);
    2322         size += nNeg;
    2323         startPositive[iColumn+1]=size;
    2324       }
    2325       delete [] neg;
    2326       // check size
    2327       assert (maxRow+1<=numberRows_);
    2328       // Get good object
    2329       delete matrix_;
    2330       ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    2331       matrix->passInCopy(numberRows_,number,true,indices,startPositive,startNegative);
    2332       matrix_=matrix;
    2333       delete [] which;
    2334     }
    2335     delete [] objective;
    2336     delete [] lower;
    2337     delete [] upper;
    2338   }
    2339   return 0;
     2211int
     2212ClpModel::addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne, bool checkDuplicates)
     2213{
     2214     CoinAssertHint (buildObject.type() == 1, "Looks as if both addRows and addCols being used"); // check correct
     2215     int number = buildObject.numberColumns();
     2216     int numberErrors = 0;
     2217     if (number) {
     2218          CoinBigIndex size = 0;
     2219          int maximumLength = 0;
     2220          double * lower = new double [number];
     2221          double * upper = new double [number];
     2222          int iColumn;
     2223          double * objective = new double [number];
     2224          if ((!matrix_ || !matrix_->getNumElements()) && tryPlusMinusOne) {
     2225               // See if can be +-1
     2226               for (iColumn = 0; iColumn < number; iColumn++) {
     2227                    const int * rows;
     2228                    const double * elements;
     2229                    int numberElements = buildObject.column(iColumn, lower[iColumn],
     2230                                                            upper[iColumn], objective[iColumn],
     2231                                                            rows, elements);
     2232                    maximumLength = CoinMax(maximumLength, numberElements);
     2233                    for (int i = 0; i < numberElements; i++) {
     2234                         // allow for zero elements
     2235                         if (elements[i]) {
     2236                              if (fabs(elements[i]) == 1.0) {
     2237                                   size++;
     2238                              } else {
     2239                                   // bad
     2240                                   tryPlusMinusOne = false;
     2241                              }
     2242                         }
     2243                    }
     2244                    if (!tryPlusMinusOne)
     2245                         break;
     2246               }
     2247          } else {
     2248               // Will add to whatever sort of matrix exists
     2249               tryPlusMinusOne = false;
     2250          }
     2251          if (!tryPlusMinusOne) {
     2252               CoinBigIndex numberElements = buildObject.numberElements();
     2253               CoinBigIndex * starts = new CoinBigIndex [number+1];
     2254               int * row = new int[numberElements];
     2255               double * element = new double[numberElements];
     2256               starts[0] = 0;
     2257               numberElements = 0;
     2258               for (iColumn = 0; iColumn < number; iColumn++) {
     2259                    const int * rows;
     2260                    const double * elements;
     2261                    int numberElementsThis = buildObject.column(iColumn, lower[iColumn], upper[iColumn],
     2262                                             objective[iColumn], rows, elements);
     2263                    CoinMemcpyN(rows, numberElementsThis, row + numberElements);
     2264                    CoinMemcpyN(elements, numberElementsThis, element + numberElements);
     2265                    numberElements += numberElementsThis;
     2266                    starts[iColumn+1] = numberElements;
     2267               }
     2268               addColumns(number, lower, upper, objective, NULL);
     2269               // make sure matrix has enough rows
     2270               matrix_->setDimensions(numberRows_, -1);
     2271               numberErrors = matrix_->appendMatrix(number, 1, starts, row, element,
     2272                                                    checkDuplicates ? numberRows_ : -1);
     2273               delete [] starts;
     2274               delete [] row;
     2275               delete [] element;
     2276          } else {
     2277               // arrays already filled in
     2278               addColumns(number, lower, upper, objective, NULL);
     2279               char * which = NULL; // for duplicates
     2280               if (checkDuplicates) {
     2281                    which = new char[numberRows_];
     2282                    CoinZeroN(which, numberRows_);
     2283               }
     2284               // build +-1 matrix
     2285               CoinBigIndex * startPositive = new CoinBigIndex [number+1];
     2286               CoinBigIndex * startNegative = new CoinBigIndex [number];
     2287               int * indices = new int [size];
     2288               int * neg = new int[maximumLength];
     2289               startPositive[0] = 0;
     2290               size = 0;
     2291               int maxRow = -1;
     2292               for (iColumn = 0; iColumn < number; iColumn++) {
     2293                    const int * rows;
     2294                    const double * elements;
     2295                    int numberElements = buildObject.column(iColumn, lower[iColumn],
     2296                                                            upper[iColumn], objective[iColumn],
     2297                                                            rows, elements);
     2298                    int nNeg = 0;
     2299                    CoinBigIndex start = size;
     2300                    for (int i = 0; i < numberElements; i++) {
     2301                         int iRow = rows[i];
     2302                         if (checkDuplicates) {
     2303                              if (iRow >= numberRows_) {
     2304                                   if(which[iRow])
     2305                                        numberErrors++;
     2306                                   else
     2307                                        which[iRow] = 1;
     2308                              } else {
     2309                                   numberErrors++;
     2310                                   // and may as well switch off
     2311                                   checkDuplicates = false;
     2312                              }
     2313                         }
     2314                         maxRow = CoinMax(maxRow, iRow);
     2315                         if (elements[i] == 1.0) {
     2316                              indices[size++] = iRow;
     2317                         } else if (elements[i] == -1.0) {
     2318                              neg[nNeg++] = iRow;
     2319                         }
     2320                    }
     2321                    std::sort(indices + start, indices + size);
     2322                    std::sort(neg, neg + nNeg);
     2323                    startNegative[iColumn] = size;
     2324                    CoinMemcpyN(neg, nNeg, indices + size);
     2325                    size += nNeg;
     2326                    startPositive[iColumn+1] = size;
     2327               }
     2328               delete [] neg;
     2329               // check size
     2330               assert (maxRow + 1 <= numberRows_);
     2331               // Get good object
     2332               delete matrix_;
     2333               ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
     2334               matrix->passInCopy(numberRows_, number, true, indices, startPositive, startNegative);
     2335               matrix_ = matrix;
     2336               delete [] which;
     2337          }
     2338          delete [] objective;
     2339          delete [] lower;
     2340          delete [] upper;
     2341     }
     2342     return 0;
    23402343}
    23412344#endif
    23422345#ifndef SLIM_NOIO
    23432346// Add columns from a model object
    2344 int 
    2345 ClpModel::addColumns( CoinModel & modelObject,bool tryPlusMinusOne,bool checkDuplicates)
    2346 {
    2347   if (modelObject.numberElements()==0)
    2348     return 0;
    2349   bool goodState=true;
    2350   if (modelObject.rowLowerArray()) {
    2351     // some row information exists
    2352     int numberRows2 = modelObject.numberRows();
    2353     const double * rowLower = modelObject.rowLowerArray();
    2354     const double * rowUpper = modelObject.rowUpperArray();
    2355     for (int i=0;i<numberRows2;i++) {
    2356       if (rowLower[i]!=-COIN_DBL_MAX)
    2357         goodState=false;
    2358       if (rowUpper[i]!=COIN_DBL_MAX)
    2359         goodState=false;
    2360     }
    2361   }
    2362   if (goodState) {
    2363     // can do addColumns
    2364     int numberErrors = 0;
    2365     // Set arrays for normal use
    2366     double * rowLower = modelObject.rowLowerArray();
    2367     double * rowUpper = modelObject.rowUpperArray();
    2368     double * columnLower = modelObject.columnLowerArray();
    2369     double * columnUpper = modelObject.columnUpperArray();
    2370     double * objective = modelObject.objectiveArray();
    2371     int * integerType = modelObject.integerTypeArray();
    2372     double * associated = modelObject.associatedArray();
    2373     // If strings then do copies
    2374     if (modelObject.stringsExist()) {
    2375       numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
    2376                                  objective, integerType,associated);
    2377     }
    2378     int numberColumns = numberColumns_; // save number of columns
    2379     int numberColumns2 = modelObject.numberColumns();
    2380     if (numberColumns2&&!numberErrors) {
    2381       CoinBigIndex * startPositive = NULL;
    2382       CoinBigIndex * startNegative = NULL;
    2383       if ((!matrix_||!matrix_->getNumElements())&&!numberColumns&&tryPlusMinusOne) {
    2384         startPositive = new CoinBigIndex[numberColumns2+1];
    2385         startNegative = new CoinBigIndex[numberColumns2];
    2386         modelObject.countPlusMinusOne(startPositive,startNegative,associated);
    2387         if (startPositive[0]<0) {
    2388           // no good
    2389           tryPlusMinusOne=false;
    2390           delete [] startPositive;
    2391           delete [] startNegative;
    2392         }
    2393       } else {
    2394         // Will add to whatever sort of matrix exists
    2395         tryPlusMinusOne=false;
    2396       }
    2397       assert (columnLower);
    2398       addColumns(numberColumns2, columnLower, columnUpper,objective, NULL,NULL,NULL);
     2347int
     2348ClpModel::addColumns( CoinModel & modelObject, bool tryPlusMinusOne, bool checkDuplicates)
     2349{
     2350     if (modelObject.numberElements() == 0)
     2351          return 0;
     2352     bool goodState = true;
     2353     if (modelObject.rowLowerArray()) {
     2354          // some row information exists
     2355          int numberRows2 = modelObject.numberRows();
     2356          const double * rowLower = modelObject.rowLowerArray();
     2357          const double * rowUpper = modelObject.rowUpperArray();
     2358          for (int i = 0; i < numberRows2; i++) {
     2359               if (rowLower[i] != -COIN_DBL_MAX)
     2360                    goodState = false;
     2361               if (rowUpper[i] != COIN_DBL_MAX)
     2362                    goodState = false;
     2363          }
     2364     }
     2365     if (goodState) {
     2366          // can do addColumns
     2367          int numberErrors = 0;
     2368          // Set arrays for normal use
     2369          double * rowLower = modelObject.rowLowerArray();
     2370          double * rowUpper = modelObject.rowUpperArray();
     2371          double * columnLower = modelObject.columnLowerArray();
     2372          double * columnUpper = modelObject.columnUpperArray();
     2373          double * objective = modelObject.objectiveArray();
     2374          int * integerType = modelObject.integerTypeArray();
     2375          double * associated = modelObject.associatedArray();
     2376          // If strings then do copies
     2377          if (modelObject.stringsExist()) {
     2378               numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
     2379                                                       objective, integerType, associated);
     2380          }
     2381          int numberColumns = numberColumns_; // save number of columns
     2382          int numberColumns2 = modelObject.numberColumns();
     2383          if (numberColumns2 && !numberErrors) {
     2384               CoinBigIndex * startPositive = NULL;
     2385               CoinBigIndex * startNegative = NULL;
     2386               if ((!matrix_ || !matrix_->getNumElements()) && !numberColumns && tryPlusMinusOne) {
     2387                    startPositive = new CoinBigIndex[numberColumns2+1];
     2388                    startNegative = new CoinBigIndex[numberColumns2];
     2389                    modelObject.countPlusMinusOne(startPositive, startNegative, associated);
     2390                    if (startPositive[0] < 0) {
     2391                         // no good
     2392                         tryPlusMinusOne = false;
     2393                         delete [] startPositive;
     2394                         delete [] startNegative;
     2395                    }
     2396               } else {
     2397                    // Will add to whatever sort of matrix exists
     2398                    tryPlusMinusOne = false;
     2399               }
     2400               assert (columnLower);
     2401               addColumns(numberColumns2, columnLower, columnUpper, objective, NULL, NULL, NULL);
    23992402#ifndef SLIM_CLP
    2400       if (!tryPlusMinusOne) {
    2401 #endif
    2402         CoinPackedMatrix matrix;
    2403         modelObject.createPackedMatrix(matrix,associated);
    2404         assert (!matrix.getExtraGap());
    2405         if (matrix_->getNumCols()) {
    2406           const int * row = matrix.getIndices();
    2407           //const int * columnLength = matrix.getVectorLengths();
    2408           const CoinBigIndex * columnStart = matrix.getVectorStarts();
    2409           const double * element = matrix.getElements();
    2410           // make sure matrix has enough rows
    2411           matrix_->setDimensions(numberRows_,-1);
    2412           numberErrors+=matrix_->appendMatrix(numberColumns2,1,columnStart,row,element,
    2413                                 checkDuplicates ? numberRows_ : -1);
    2414         } else {
    2415           delete matrix_;
    2416           matrix_ = new ClpPackedMatrix(matrix);
    2417         }
     2403               if (!tryPlusMinusOne) {
     2404#endif
     2405                    CoinPackedMatrix matrix;
     2406                    modelObject.createPackedMatrix(matrix, associated);
     2407                    assert (!matrix.getExtraGap());
     2408                    if (matrix_->getNumCols()) {
     2409                         const int * row = matrix.getIndices();
     2410                         //const int * columnLength = matrix.getVectorLengths();
     2411                         const CoinBigIndex * columnStart = matrix.getVectorStarts();
     2412                         const double * element = matrix.getElements();
     2413                         // make sure matrix has enough rows
     2414                         matrix_->setDimensions(numberRows_, -1);
     2415                         numberErrors += matrix_->appendMatrix(numberColumns2, 1, columnStart, row, element,
     2416                                                               checkDuplicates ? numberRows_ : -1);
     2417                    } else {
     2418                         delete matrix_;
     2419                         matrix_ = new ClpPackedMatrix(matrix);
     2420                    }
    24182421#ifndef SLIM_CLP
    2419       } else {
    2420         // create +-1 matrix
    2421         CoinBigIndex size = startPositive[numberColumns2];
    2422         int * indices = new int[size];
    2423         modelObject.createPlusMinusOne(startPositive,startNegative,indices,
    2424                                        associated);
    2425         // Get good object
    2426         ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    2427         matrix->passInCopy(numberRows_,numberColumns2,
    2428                            true,indices,startPositive,startNegative);
    2429         delete matrix_;
    2430         matrix_=matrix;
    2431       }
     2422               } else {
     2423                    // create +-1 matrix
     2424                    CoinBigIndex size = startPositive[numberColumns2];
     2425                    int * indices = new int[size];
     2426                    modelObject.createPlusMinusOne(startPositive, startNegative, indices,
     2427                                                   associated);
     2428                    // Get good object
     2429                    ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
     2430                    matrix->passInCopy(numberRows_, numberColumns2,
     2431                                       true, indices, startPositive, startNegative);
     2432                    delete matrix_;
     2433                    matrix_ = matrix;
     2434               }
    24322435#endif
    24332436#ifndef CLP_NO_STD
    2434       // Do names if wanted
    2435       if (modelObject.columnNames()->numberItems()) {
    2436         const char *const * columnNames=modelObject.columnNames()->names();
    2437         copyColumnNames(columnNames,numberColumns,numberColumns_);
    2438       }
    2439 #endif
    2440       // Do integers if wanted
    2441       assert(integerType);
    2442       for (int iColumn=0;iColumn<numberColumns2;iColumn++) {
    2443         if (integerType[iColumn])
    2444           setInteger(iColumn+numberColumns);
    2445       }
    2446     }
    2447     if (columnLower!=modelObject.columnLowerArray()) {
    2448       delete [] rowLower;
    2449       delete [] rowUpper;
    2450       delete [] columnLower;
    2451       delete [] columnUpper;
    2452       delete [] objective;
    2453       delete [] integerType;
    2454       delete [] associated;
    2455       if (numberErrors)
    2456         handler_->message(CLP_BAD_STRING_VALUES,messages_)
    2457           <<numberErrors
    2458           <<CoinMessageEol;
    2459     }
    2460     return numberErrors;
    2461   } else {
    2462     // not suitable for addColumns
    2463     handler_->message(CLP_COMPLICATED_MODEL,messages_)
    2464       <<modelObject.numberRows()
    2465       <<modelObject.numberColumns()
    2466       <<CoinMessageEol;
    2467     return -1;
    2468   }
     2437               // Do names if wanted
     2438               if (modelObject.columnNames()->numberItems()) {
     2439                    const char *const * columnNames = modelObject.columnNames()->names();
     2440                    copyColumnNames(columnNames, numberColumns, numberColumns_);
     2441               }
     2442#endif
     2443               // Do integers if wanted
     2444               assert(integerType);
     2445               for (int iColumn = 0; iColumn < numberColumns2; iColumn++) {
     2446                    if (integerType[iColumn])
     2447                         setInteger(iColumn + numberColumns);
     2448               }
     2449          }
     2450          if (columnLower != modelObject.columnLowerArray()) {
     2451               delete [] rowLower;
     2452               delete [] rowUpper;
     2453               delete [] columnLower;
     2454               delete [] columnUpper;
     2455               delete [] objective;
     2456               delete [] integerType;
     2457               delete [] associated;
     2458               if (numberErrors)
     2459                    handler_->message(CLP_BAD_STRING_VALUES, messages_)
     2460                              << numberErrors
     2461                              << CoinMessageEol;
     2462          }
     2463          return numberErrors;
     2464     } else {
     2465          // not suitable for addColumns
     2466          handler_->message(CLP_COMPLICATED_MODEL, messages_)
     2467                    << modelObject.numberRows()
     2468                    << modelObject.numberColumns()
     2469                    << CoinMessageEol;
     2470          return -1;
     2471     }
    24692472}
    24702473#endif
    24712474// chgRowLower
    2472 void 
    2473 ClpModel::chgRowLower(const double * rowLower) 
    2474 {
    2475   int numberRows = numberRows_;
    2476   int iRow;
    2477   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2478   if (rowLower) {
    2479     for (iRow = 0; iRow < numberRows; iRow++) {
    2480       double value = rowLower[iRow];
    2481       if (value<-1.0e20)
    2482                 value = -COIN_DBL_MAX;
    2483       rowLower_[iRow]= value;
    2484     }
    2485   } else {
    2486     for (iRow = 0; iRow < numberRows; iRow++) {
    2487       rowLower_[iRow]= -COIN_DBL_MAX;
    2488     }
    2489   }
     2475void
     2476ClpModel::chgRowLower(const double * rowLower)
     2477{
     2478     int numberRows = numberRows_;
     2479     int iRow;
     2480     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2481     if (rowLower) {
     2482          for (iRow = 0; iRow < numberRows; iRow++) {
     2483               double value = rowLower[iRow];
     2484               if (value < -1.0e20)
     2485                    value = -COIN_DBL_MAX;
     2486               rowLower_[iRow] = value;
     2487          }
     2488     } else {
     2489          for (iRow = 0; iRow < numberRows; iRow++) {
     2490               rowLower_[iRow] = -COIN_DBL_MAX;
     2491          }
     2492     }
    24902493}
    24912494// chgRowUpper
    2492 void 
    2493 ClpModel::chgRowUpper(const double * rowUpper) 
    2494 {
    2495   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2496   int numberRows = numberRows_;
    2497   int iRow;
    2498   if (rowUpper) {
    2499     for (iRow = 0; iRow < numberRows; iRow++) {
    2500       double value = rowUpper[iRow];
    2501       if (value>1.0e20)
    2502                 value = COIN_DBL_MAX;
    2503       rowUpper_[iRow]= value;
    2504     }
    2505   } else {
    2506     for (iRow = 0; iRow < numberRows; iRow++) {
    2507       rowUpper_[iRow]= COIN_DBL_MAX;;
    2508     }
    2509   }
     2495void
     2496ClpModel::chgRowUpper(const double * rowUpper)
     2497{
     2498     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2499     int numberRows = numberRows_;
     2500     int iRow;
     2501     if (rowUpper) {
     2502          for (iRow = 0; iRow < numberRows; iRow++) {
     2503               double value = rowUpper[iRow];
     2504               if (value > 1.0e20)
     2505                    value = COIN_DBL_MAX;
     2506               rowUpper_[iRow] = value;
     2507          }
     2508     } else {
     2509          for (iRow = 0; iRow < numberRows; iRow++) {
     2510               rowUpper_[iRow] = COIN_DBL_MAX;;
     2511          }
     2512     }
    25102513}
    25112514// chgColumnLower
    2512 void 
    2513 ClpModel::chgColumnLower(const double * columnLower) 
    2514 {
    2515   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2516   int numberColumns = numberColumns_;
    2517   int iColumn;
    2518   if (columnLower) {
    2519     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2520       double value = columnLower[iColumn];
    2521       if (value<-1.0e20)
    2522                 value = -COIN_DBL_MAX;
    2523       columnLower_[iColumn]= value;
    2524     }
    2525   } else {
    2526     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2527       columnLower_[iColumn]= 0.0;
    2528     }
    2529   }
     2515void
     2516ClpModel::chgColumnLower(const double * columnLower)
     2517{
     2518     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2519     int numberColumns = numberColumns_;
     2520     int iColumn;
     2521     if (columnLower) {
     2522          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2523               double value = columnLower[iColumn];
     2524               if (value < -1.0e20)
     2525                    value = -COIN_DBL_MAX;
     2526               columnLower_[iColumn] = value;
     2527          }
     2528     } else {
     2529          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2530               columnLower_[iColumn] = 0.0;
     2531          }
     2532     }
    25302533}
    25312534// chgColumnUpper
    2532 void 
    2533 ClpModel::chgColumnUpper(const double * columnUpper) 
    2534 {
    2535   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2536   int numberColumns = numberColumns_;
    2537   int iColumn;
    2538   if (columnUpper) {
    2539     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2540       double value = columnUpper[iColumn];
    2541       if (value>1.0e20)
    2542                 value = COIN_DBL_MAX;
    2543       columnUpper_[iColumn]= value;
    2544     }
    2545   } else {
    2546     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2547       columnUpper_[iColumn]= COIN_DBL_MAX;;
    2548     }
    2549   }
     2535void
     2536ClpModel::chgColumnUpper(const double * columnUpper)
     2537{
     2538     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2539     int numberColumns = numberColumns_;
     2540     int iColumn;
     2541     if (columnUpper) {
     2542          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2543               double value = columnUpper[iColumn];
     2544               if (value > 1.0e20)
     2545                    value = COIN_DBL_MAX;
     2546               columnUpper_[iColumn] = value;
     2547          }
     2548     } else {
     2549          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2550               columnUpper_[iColumn] = COIN_DBL_MAX;;
     2551          }
     2552     }
    25502553}
    25512554// chgObjCoefficients
    2552 void 
    2553 ClpModel::chgObjCoefficients(const double * objIn) 
    2554 {
    2555   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2556   double * obj = objective();
    2557   int numberColumns = numberColumns_;
    2558   int iColumn;
    2559   if (objIn) {
    2560     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2561       obj[iColumn] = objIn[iColumn];
    2562     }
    2563   } else {
    2564     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2565       obj[iColumn]= 0.0;
    2566     }
    2567   }
     2555void
     2556ClpModel::chgObjCoefficients(const double * objIn)
     2557{
     2558     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2559     double * obj = objective();
     2560     int numberColumns = numberColumns_;
     2561     int iColumn;
     2562     if (objIn) {
     2563          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2564               obj[iColumn] = objIn[iColumn];
     2565          }
     2566     } else {
     2567          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2568               obj[iColumn] = 0.0;
     2569          }
     2570     }
    25682571}
    25692572// Infeasibility/unbounded ray (NULL returned if none/wrong)
    2570 double * 
     2573double *
    25712574ClpModel::infeasibilityRay() const
    25722575{
    2573   double * array = NULL;
    2574   if (problemStatus_==1) {
    2575     array = ClpCopyOfArray(ray_,numberRows_);
     2576     double * array = NULL;
     2577     if (problemStatus_ == 1) {
     2578          array = ClpCopyOfArray(ray_, numberRows_);
    25762579#ifndef CLP_NO_SWAP_SIGN
    2577     // swap signs to be consistent with norm
    2578     for (int i=0;i<numberRows_;i++)
    2579       array[i] = -array[i];
     2580          // swap signs to be consistent with norm
     2581          for (int i = 0; i < numberRows_; i++)
     2582               array[i] = -array[i];
    25802583#endif
    25812584#if 0
    2582     // clean up
    2583     double largest=1.0e-30;
    2584     double smallest=COIN_DBL_MAX;
    2585     int i;
    2586     for (i=0;i<numberRows_;i++) {
    2587       double value = fabs(array[i]);
    2588       smallest = CoinMin(smallest,value);
    2589       largest = CoinMax(largest,value);
    2590     }
    2591 #endif
    2592   }
    2593   return array;
    2594 }
    2595 double * 
     2585          // clean up
     2586          double largest = 1.0e-30;
     2587          double smallest = COIN_DBL_MAX;
     2588          int i;
     2589          for (i = 0; i < numberRows_; i++) {
     2590               double value = fabs(array[i]);
     2591               smallest = CoinMin(smallest, value);
     2592               largest = CoinMax(largest, value);
     2593          }
     2594#endif
     2595     }
     2596     return array;
     2597}
     2598double *
    25962599ClpModel::unboundedRay() const
    25972600{
    2598   double * array = NULL;
    2599   if (problemStatus_==2)
    2600     array = ClpCopyOfArray(ray_,numberColumns_);
    2601   return array;
    2602 }
    2603 void 
     2601     double * array = NULL;
     2602     if (problemStatus_ == 2)
     2603          array = ClpCopyOfArray(ray_, numberColumns_);
     2604     return array;
     2605}
     2606void
    26042607ClpModel::setMaximumIterations(int value)
    26052608{
    2606   if(value>=0)
    2607     intParam_[ClpMaxNumIteration]=value;
    2608 }
    2609 void 
     2609     if(value >= 0)
     2610          intParam_[ClpMaxNumIteration] = value;
     2611}
     2612void
    26102613ClpModel::setMaximumSeconds(double value)
    26112614{
    2612   if(value>=0)
    2613     dblParam_[ClpMaxSeconds]=value+CoinCpuTime();
    2614   else
    2615     dblParam_[ClpMaxSeconds]=-1.0;
     2615     if(value >= 0)
     2616          dblParam_[ClpMaxSeconds] = value + CoinCpuTime();
     2617     else
     2618          dblParam_[ClpMaxSeconds] = -1.0;
    26162619}
    26172620// Returns true if hit maximum iterations (or time)
    2618 bool 
     2621bool
    26192622ClpModel::hitMaximumIterations() const
    26202623{
    2621   // replaced - compiler error? bool hitMax= (numberIterations_>=maximumIterations());
    2622   bool hitMax = (numberIterations_ >= intParam_[ClpMaxNumIteration]);
    2623   if (dblParam_[ClpMaxSeconds]>=0.0&&!hitMax) {
    2624     hitMax = (CoinCpuTime()>=dblParam_[ClpMaxSeconds]);
    2625   }
    2626   return hitMax;
     2624     // replaced - compiler error? bool hitMax= (numberIterations_>=maximumIterations());
     2625     bool hitMax = (numberIterations_ >= intParam_[ClpMaxNumIteration]);
     2626     if (dblParam_[ClpMaxSeconds] >= 0.0 && !hitMax) {
     2627          hitMax = (CoinCpuTime() >= dblParam_[ClpMaxSeconds]);
     2628     }
     2629     return hitMax;
    26272630}
    26282631// On stopped - sets secondary status
    2629 void 
     2632void
    26302633ClpModel::onStopped()
    26312634{
    2632   if (problemStatus_==3) {
    2633     secondaryStatus_=0;
    2634     if (CoinCpuTime()>=dblParam_[ClpMaxSeconds]&&dblParam_[ClpMaxSeconds]>=0.0)
    2635       secondaryStatus_=9;
    2636   }
     2635     if (problemStatus_ == 3) {
     2636          secondaryStatus_ = 0;
     2637          if (CoinCpuTime() >= dblParam_[ClpMaxSeconds] && dblParam_[ClpMaxSeconds] >= 0.0)
     2638               secondaryStatus_ = 9;
     2639     }
    26372640}
    26382641// Pass in Message handler (not deleted at end)
    2639 void 
     2642void
    26402643ClpModel::passInMessageHandler(CoinMessageHandler * handler)
    26412644{
    2642   if (defaultHandler_)
    2643     delete handler_;
    2644   defaultHandler_=false;
    2645   handler_=handler;
     2645     if (defaultHandler_)
     2646          delete handler_;
     2647     defaultHandler_ = false;
     2648     handler_ = handler;
    26462649}
    26472650// Pass in Message handler (not deleted at end) and return current
    26482651CoinMessageHandler *
    26492652ClpModel::pushMessageHandler(CoinMessageHandler * handler,
    2650                              bool & oldDefault)
    2651 {
    2652   CoinMessageHandler * returnValue = handler_;
    2653   oldDefault = defaultHandler_;
    2654   defaultHandler_=false;
    2655   handler_=handler;
    2656   return returnValue;
     2653                             bool & oldDefault)
     2654{
     2655     CoinMessageHandler * returnValue = handler_;
     2656     oldDefault = defaultHandler_;
     2657     defaultHandler_ = false;
     2658     handler_ = handler;
     2659     return returnValue;
    26572660}
    26582661// back to previous message handler
    26592662void
    2660 ClpModel::popMessageHandler(CoinMessageHandler * oldHandler,bool oldDefault)
    2661 {
    2662   if (defaultHandler_)
    2663     delete handler_;
    2664   defaultHandler_=oldDefault;
    2665   handler_=oldHandler;
     2663ClpModel::popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault)
     2664{
     2665     if (defaultHandler_)
     2666          delete handler_;
     2667     defaultHandler_ = oldDefault;
     2668     handler_ = oldHandler;
    26662669}
    26672670// Set language
    2668 void 
     2671void
    26692672ClpModel::newLanguage(CoinMessages::Language language)
    26702673{
    2671   messages_ = ClpMessage(language);
     2674     messages_ = ClpMessage(language);
    26722675}
    26732676#ifndef SLIM_NOIO
    26742677// Read an mps file from the given filename
    2675 int 
     2678int
    26762679ClpModel::readMps(const char *fileName,
    2677                   bool keepNames,
    2678                   bool ignoreErrors)
    2679 {
    2680   if (!strcmp(fileName,"-")||!strcmp(fileName,"stdin")) {
    2681     // stdin
    2682   } else {
    2683     std::string name=fileName;
    2684     bool readable = fileCoinReadable(name);
    2685     if (!readable) {
    2686       handler_->message(CLP_UNABLE_OPEN,messages_)
    2687         <<fileName<<CoinMessageEol;
    2688       return -1;
    2689     }
    2690   }
    2691   CoinMpsIO m;
    2692   m.passInMessageHandler(handler_);
    2693   *m.messagesPointer()=coinMessages();
    2694   bool savePrefix =m.messageHandler()->prefix();
    2695   m.messageHandler()->setPrefix(handler_->prefix());
    2696   m.setSmallElementValue(CoinMax(smallElement_,m.getSmallElementValue()));
    2697   double time1 = CoinCpuTime(),time2;
    2698   int status=0;
    2699   try {
    2700     status=m.readMps(fileName,"");
    2701   }
    2702   catch (CoinError e) {
    2703     e.print();
    2704     status=-1;
    2705   }
    2706   m.messageHandler()->setPrefix(savePrefix);
    2707   if (!status||(ignoreErrors&&(status>0&&status<100000))) {
    2708     loadProblem(*m.getMatrixByCol(),
    2709                 m.getColLower(),m.getColUpper(),
    2710                 m.getObjCoefficients(),
    2711                 m.getRowLower(),m.getRowUpper());
    2712     if (m.integerColumns()) {
    2713       integerType_ = new char[numberColumns_];
    2714       CoinMemcpyN(m.integerColumns(),numberColumns_,integerType_);
    2715     } else {
    2716       integerType_ = NULL;
    2717     }
     2680                  bool keepNames,
     2681                  bool ignoreErrors)
     2682{
     2683     if (!strcmp(fileName, "-") || !strcmp(fileName, "stdin")) {
     2684          // stdin
     2685     } else {
     2686          std::string name = fileName;
     2687          bool readable = fileCoinReadable(name);
     2688          if (!readable) {
     2689               handler_->message(CLP_UNABLE_OPEN, messages_)
     2690                         << fileName << CoinMessageEol;
     2691               return -1;
     2692          }
     2693     }
     2694     CoinMpsIO m;
     2695     m.passInMessageHandler(handler_);
     2696     *m.messagesPointer() = coinMessages();
     2697     bool savePrefix = m.messageHandler()->prefix();
     2698     m.messageHandler()->setPrefix(handler_->prefix());
     2699     m.setSmallElementValue(CoinMax(smallElement_, m.getSmallElementValue()));
     2700     double time1 = CoinCpuTime(), time2;
     2701     int status = 0;
     2702     try {
     2703          status = m.readMps(fileName, "");
     2704     } catch (CoinError e) {
     2705          e.print();
     2706          status = -1;
     2707     }
     2708     m.messageHandler()->setPrefix(savePrefix);
     2709     if (!status || (ignoreErrors && (status > 0 && status < 100000))) {
     2710          loadProblem(*m.getMatrixByCol(),
     2711                      m.getColLower(), m.getColUpper(),
     2712                      m.getObjCoefficients(),
     2713                      m.getRowLower(), m.getRowUpper());
     2714          if (m.integerColumns()) {
     2715               integerType_ = new char[numberColumns_];
     2716               CoinMemcpyN(m.integerColumns(), numberColumns_, integerType_);
     2717          } else {
     2718               integerType_ = NULL;
     2719          }
    27182720#ifndef SLIM_CLP
    2719     // get quadratic part
    2720     if (m.reader()->whichSection (  ) == COIN_QUAD_SECTION ) {
    2721       int * start=NULL;
    2722       int * column = NULL;
    2723       double * element = NULL;
    2724       status=m.readQuadraticMps(NULL,start,column,element,2);
    2725       if (!status||ignoreErrors)
    2726         loadQuadraticObjective(numberColumns_,start,column,element);
    2727       delete [] start;
    2728       delete [] column;
    2729       delete [] element;
    2730     }
    2731 #endif
    2732 #ifndef CLP_NO_STD   
    2733     // set problem name
    2734     setStrParam(ClpProbName,m.getProblemName());
    2735     // do names
    2736     if (keepNames) {
    2737       unsigned int maxLength=0;
    2738       int iRow;
    2739       rowNames_ = std::vector<std::string> ();
    2740       columnNames_ = std::vector<std::string> ();
    2741       rowNames_.reserve(numberRows_);
    2742       for (iRow=0;iRow<numberRows_;iRow++) {
    2743         const char * name = m.rowName(iRow);
    2744         maxLength = CoinMax(maxLength,static_cast<unsigned int> (strlen(name)));
    2745           rowNames_.push_back(name);
    2746       }
    2747      
    2748       int iColumn;
    2749       columnNames_.reserve(numberColumns_);
    2750       for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2751         const char * name = m.columnName(iColumn);
    2752         maxLength = CoinMax(maxLength,static_cast<unsigned int> (strlen(name)));
    2753         columnNames_.push_back(name);
    2754       }
    2755       lengthNames_=static_cast<int> (maxLength);
    2756     } else {
    2757       lengthNames_=0;
    2758     }
    2759 #endif
    2760     setDblParam(ClpObjOffset,m.objectiveOffset());
    2761     time2 = CoinCpuTime();
    2762     handler_->message(CLP_IMPORT_RESULT,messages_)
    2763       <<fileName
    2764       <<time2-time1<<CoinMessageEol;
    2765   } else {
    2766     // errors
    2767     handler_->message(CLP_IMPORT_ERRORS,messages_)
    2768       <<status<<fileName<<CoinMessageEol;
    2769   }
    2770 
    2771   return status;
     2721          // get quadratic part
     2722          if (m.reader()->whichSection (  ) == COIN_QUAD_SECTION ) {
     2723               int * start = NULL;
     2724               int * column = NULL;
     2725               double * element = NULL;
     2726               status = m.readQuadraticMps(NULL, start, column, element, 2);
     2727               if (!status || ignoreErrors)
     2728                    loadQuadraticObjective(numberColumns_, start, column, element);
     2729               delete [] start;
     2730               delete [] column;
     2731               delete [] element;
     2732          }
     2733#endif
     2734#ifndef CLP_NO_STD
     2735          // set problem name
     2736          setStrParam(ClpProbName, m.getProblemName());
     2737          // do names
     2738          if (keepNames) {
     2739               unsigned int maxLength = 0;
     2740               int iRow;
     2741               rowNames_ = std::vector<std::string> ();
     2742               columnNames_ = std::vector<std::string> ();
     2743               rowNames_.reserve(numberRows_);
     2744               for (iRow = 0; iRow < numberRows_; iRow++) {
     2745                    const char * name = m.rowName(iRow);
     2746                    maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
     2747                    rowNames_.push_back(name);
     2748               }
     2749
     2750               int iColumn;
     2751               columnNames_.reserve(numberColumns_);
     2752               for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2753                    const char * name = m.columnName(iColumn);
     2754                    maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
     2755                    columnNames_.push_back(name);
     2756               }
     2757               lengthNames_ = static_cast<int> (maxLength);
     2758          } else {
     2759               lengthNames_ = 0;
     2760          }
     2761#endif
     2762          setDblParam(ClpObjOffset, m.objectiveOffset());
     2763          time2 = CoinCpuTime();
     2764          handler_->message(CLP_IMPORT_RESULT, messages_)
     2765                    << fileName
     2766                    << time2 - time1 << CoinMessageEol;
     2767     } else {
     2768          // errors
     2769          handler_->message(CLP_IMPORT_ERRORS, messages_)
     2770                    << status << fileName << CoinMessageEol;
     2771     }
     2772
     2773     return status;
    27722774}
    27732775// Read GMPL files from the given filenames
    2774 int 
    2775 ClpModel::readGMPL(const char *fileName,const char * dataName,
     2776int
     2777ClpModel::readGMPL(const char *fileName, const char * dataName,
    27762778                   bool keepNames)
    27772779{
    2778   FILE *fp=fopen(fileName,"r");
    2779   if (fp) {
    2780     // can open - lets go for it
    2781     fclose(fp);
    2782     if (dataName) {
    2783       fp=fopen(dataName,"r");
    2784       if (fp) {
    2785         fclose(fp);
    2786       } else {
    2787         handler_->message(CLP_UNABLE_OPEN,messages_)
    2788           <<dataName<<CoinMessageEol;
    2789         return -1;
    2790       }
    2791     }
    2792   } else {
    2793     handler_->message(CLP_UNABLE_OPEN,messages_)
    2794       <<fileName<<CoinMessageEol;
    2795     return -1;
    2796   }
    2797   CoinMpsIO m;
    2798   m.passInMessageHandler(handler_);
    2799   *m.messagesPointer()=coinMessages();
    2800   bool savePrefix =m.messageHandler()->prefix();
    2801   m.messageHandler()->setPrefix(handler_->prefix());
    2802   double time1 = CoinCpuTime(),time2;
    2803   int status=m.readGMPL(fileName,dataName,keepNames);
    2804   m.messageHandler()->setPrefix(savePrefix);
    2805   if (!status) {
    2806     loadProblem(*m.getMatrixByCol(),
    2807                 m.getColLower(),m.getColUpper(),
    2808                 m.getObjCoefficients(),
    2809                 m.getRowLower(),m.getRowUpper());
    2810     if (m.integerColumns()) {
    2811       integerType_ = new char[numberColumns_];
    2812       CoinMemcpyN(m.integerColumns(),numberColumns_,integerType_);
    2813     } else {
    2814       integerType_ = NULL;
    2815     }
     2780     FILE *fp = fopen(fileName, "r");
     2781     if (fp) {
     2782          // can open - lets go for it
     2783          fclose(fp);
     2784          if (dataName) {
     2785               fp = fopen(dataName, "r");
     2786               if (fp) {
     2787                    fclose(fp);
     2788               } else {
     2789                    handler_->message(CLP_UNABLE_OPEN, messages_)
     2790                              << dataName << CoinMessageEol;
     2791                    return -1;
     2792               }
     2793          }
     2794     } else {
     2795          handler_->message(CLP_UNABLE_OPEN, messages_)
     2796                    << fileName << CoinMessageEol;
     2797          return -1;
     2798     }
     2799     CoinMpsIO m;
     2800     m.passInMessageHandler(handler_);
     2801     *m.messagesPointer() = coinMessages();
     2802     bool savePrefix = m.messageHandler()->prefix();
     2803     m.messageHandler()->setPrefix(handler_->prefix());
     2804     double time1 = CoinCpuTime(), time2;
     2805     int status = m.readGMPL(fileName, dataName, keepNames);
     2806     m.messageHandler()->setPrefix(savePrefix);
     2807     if (!status) {
     2808          loadProblem(*m.getMatrixByCol(),
     2809                      m.getColLower(), m.getColUpper(),
     2810                      m.getObjCoefficients(),
     2811                      m.getRowLower(), m.getRowUpper());
     2812          if (m.integerColumns()) {
     2813               integerType_ = new char[numberColumns_];
     2814               CoinMemcpyN(m.integerColumns(), numberColumns_, integerType_);
     2815          } else {
     2816               integerType_ = NULL;
     2817          }
    28162818#ifndef CLP_NO_STD
    2817     // set problem name
    2818     setStrParam(ClpProbName,m.getProblemName());
    2819     // do names
    2820     if (keepNames) {
    2821       unsigned int maxLength=0;
    2822       int iRow;
    2823       rowNames_ = std::vector<std::string> ();
    2824       columnNames_ = std::vector<std::string> ();
    2825       rowNames_.reserve(numberRows_);
    2826       for (iRow=0;iRow<numberRows_;iRow++) {
    2827         const char * name = m.rowName(iRow);
    2828         maxLength = CoinMax(maxLength,static_cast<unsigned int> (strlen(name)));
    2829           rowNames_.push_back(name);
    2830       }
    2831      
    2832       int iColumn;
    2833       columnNames_.reserve(numberColumns_);
    2834       for (iColumn=0;iColumn<numberColumns_;iColumn++) {
    2835         const char * name = m.columnName(iColumn);
    2836         maxLength = CoinMax(maxLength,static_cast<unsigned int> (strlen(name)));
    2837         columnNames_.push_back(name);
    2838       }
    2839       lengthNames_=static_cast<int> (maxLength);
    2840     } else {
    2841       lengthNames_=0;
    2842     }
    2843 #endif
    2844     setDblParam(ClpObjOffset,m.objectiveOffset());
    2845     time2 = CoinCpuTime();
    2846     handler_->message(CLP_IMPORT_RESULT,messages_)
    2847       <<fileName
    2848       <<time2-time1<<CoinMessageEol;
    2849   } else {
    2850     // errors
    2851     handler_->message(CLP_IMPORT_ERRORS,messages_)
    2852       <<status<<fileName<<CoinMessageEol;
    2853   }
    2854   return status;
     2819          // set problem name
     2820          setStrParam(ClpProbName, m.getProblemName());
     2821          // do names
     2822          if (keepNames) {
     2823               unsigned int maxLength = 0;
     2824               int iRow;
     2825               rowNames_ = std::vector<std::string> ();
     2826               columnNames_ = std::vector<std::string> ();
     2827               rowNames_.reserve(numberRows_);
     2828               for (iRow = 0; iRow < numberRows_; iRow++) {
     2829                    const char * name = m.rowName(iRow);
     2830                    maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
     2831                    rowNames_.push_back(name);
     2832               }
     2833
     2834               int iColumn;
     2835               columnNames_.reserve(numberColumns_);
     2836               for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2837                    const char * name = m.columnName(iColumn);
     2838                    maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
     2839                    columnNames_.push_back(name);
     2840               }
     2841               lengthNames_ = static_cast<int> (maxLength);
     2842          } else {
     2843               lengthNames_ = 0;
     2844          }
     2845#endif
     2846          setDblParam(ClpObjOffset, m.objectiveOffset());
     2847          time2 = CoinCpuTime();
     2848          handler_->message(CLP_IMPORT_RESULT, messages_)
     2849                    << fileName
     2850                    << time2 - time1 << CoinMessageEol;
     2851     } else {
     2852          // errors
     2853          handler_->message(CLP_IMPORT_ERRORS, messages_)
     2854                    << status << fileName << CoinMessageEol;
     2855     }
     2856     return status;
    28552857}
    28562858#endif
    28572859bool ClpModel::isPrimalObjectiveLimitReached() const
    28582860{
    2859   double limit = 0.0;
    2860   getDblParam(ClpPrimalObjectiveLimit, limit);
    2861   if (limit > 1e30) {
    2862     // was not ever set
    2863     return false;
    2864   }
    2865    
    2866   const double obj = objectiveValue();
    2867   const double maxmin = optimizationDirection();
    2868 
    2869   if (problemStatus_ == 0) // optimal
    2870     return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
    2871   else if (problemStatus_==2)
    2872     return true;
    2873   else
    2874     return false;
     2861     double limit = 0.0;
     2862     getDblParam(ClpPrimalObjectiveLimit, limit);
     2863     if (limit > 1e30) {
     2864          // was not ever set
     2865          return false;
     2866     }
     2867
     2868     const double obj = objectiveValue();
     2869     const double maxmin = optimizationDirection();
     2870
     2871     if (problemStatus_ == 0) // optimal
     2872          return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
     2873     else if (problemStatus_ == 2)
     2874          return true;
     2875     else
     2876          return false;
    28752877}
    28762878
     
    28782880{
    28792881
    2880   double limit = 0.0;
    2881   getDblParam(ClpDualObjectiveLimit, limit);
    2882   if (limit > 1e30) {
    2883     // was not ever set
    2884     return false;
    2885   }
    2886    
    2887   const double obj = objectiveValue();
    2888   const double maxmin = optimizationDirection();
    2889 
    2890   if (problemStatus_ == 0) // optimal
    2891     return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
    2892   else if (problemStatus_==1)
    2893     return true;
    2894   else
    2895     return false;
    2896 
    2897 }
    2898 void 
     2882     double limit = 0.0;
     2883     getDblParam(ClpDualObjectiveLimit, limit);
     2884     if (limit > 1e30) {
     2885          // was not ever set
     2886          return false;
     2887     }
     2888
     2889     const double obj = objectiveValue();
     2890     const double maxmin = optimizationDirection();
     2891
     2892     if (problemStatus_ == 0) // optimal
     2893          return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
     2894     else if (problemStatus_ == 1)
     2895          return true;
     2896     else
     2897          return false;
     2898
     2899}
     2900void
    28992901ClpModel::copyInIntegerInformation(const char * information)
    29002902{
    2901   delete [] integerType_;
    2902   if (information) {
    2903     integerType_ = new char[numberColumns_];
    2904     CoinMemcpyN(information,numberColumns_,integerType_);
    2905   } else {
    2906     integerType_ = NULL;
    2907   }
     2903     delete [] integerType_;
     2904     if (information) {
     2905          integerType_ = new char[numberColumns_];
     2906          CoinMemcpyN(information, numberColumns_, integerType_);
     2907     } else {
     2908          integerType_ = NULL;
     2909     }
    29082910}
    29092911void
     
    29112913{
    29122914
    2913   if (integerType_) {
     2915     if (integerType_) {
    29142916#ifndef NDEBUG
    2915     if (index<0||index>=numberColumns_) {
    2916       indexError(index,"setContinuous");
    2917     }
    2918 #endif
    2919     integerType_[index]=0;
    2920   }
     2917          if (index < 0 || index >= numberColumns_) {
     2918               indexError(index, "setContinuous");
     2919          }
     2920#endif
     2921          integerType_[index] = 0;
     2922     }
    29212923}
    29222924//-----------------------------------------------------------------------------
     
    29242926ClpModel::setInteger(int index)
    29252927{
    2926   if (!integerType_) {
    2927     integerType_ = new char[numberColumns_];
    2928     CoinZeroN ( integerType_, numberColumns_);
    2929   }
     2928     if (!integerType_) {
     2929          integerType_ = new char[numberColumns_];
     2930          CoinZeroN ( integerType_, numberColumns_);
     2931     }
    29302932#ifndef NDEBUG
    2931   if (index<0||index>=numberColumns_) {
    2932     indexError(index,"setInteger");
    2933   }
    2934 #endif
    2935   integerType_[index]=1;
     2933     if (index < 0 || index >= numberColumns_) {
     2934          indexError(index, "setInteger");
     2935     }
     2936#endif
     2937     integerType_[index] = 1;
    29362938}
    29372939/* Return true if the index-th variable is an integer variable */
    2938 bool 
     2940bool
    29392941ClpModel::isInteger(int index) const
    29402942{
    2941   if (!integerType_) {
    2942     return false;
    2943   } else {
     2943     if (!integerType_) {
     2944          return false;
     2945     } else {
    29442946#ifndef NDEBUG
    2945     if (index<0||index>=numberColumns_) {
    2946       indexError(index,"isInteger");
    2947     }
    2948 #endif
    2949     return (integerType_[index]!=0);
    2950   }
     2947          if (index < 0 || index >= numberColumns_) {
     2948               indexError(index, "isInteger");
     2949          }
     2950#endif
     2951          return (integerType_[index] != 0);
     2952     }
    29512953}
    29522954#ifndef CLP_NO_STD
    29532955// Drops names - makes lengthnames 0 and names empty
    2954 void 
     2956void
    29552957ClpModel::dropNames()
    29562958{
    2957   lengthNames_=0;
    2958   rowNames_ = std::vector<std::string> ();
    2959   columnNames_ = std::vector<std::string> ();
     2959     lengthNames_ = 0;
     2960     rowNames_ = std::vector<std::string> ();
     2961     columnNames_ = std::vector<std::string> ();
    29602962}
    29612963#endif
    29622964// Drop integer informations
    2963 void 
     2965void
    29642966ClpModel::deleteIntegerInformation()
    29652967{
    2966   delete [] integerType_;
    2967   integerType_ = NULL;
     2968     delete [] integerType_;
     2969     integerType_ = NULL;
    29682970}
    29692971/* Return copy of status array (char[numberRows+numberColumns]),
    29702972   use delete [] */
    2971 unsigned char * 
     2973unsigned char *
    29722974ClpModel::statusCopy() const
    29732975{
    2974   return ClpCopyOfArray(status_,numberRows_+numberColumns_);
     2976     return ClpCopyOfArray(status_, numberRows_ + numberColumns_);
    29752977}
    29762978// Copy in status vector
    2977 void 
     2979void
    29782980ClpModel::copyinStatus(const unsigned char * statusArray)
    29792981{
    2980   delete [] status_;
    2981   if (statusArray) {
    2982     status_ = new unsigned char [numberRows_+numberColumns_];
    2983     CoinMemcpyN(statusArray,(numberRows_+numberColumns_),status_);
    2984   } else {
    2985     status_=NULL;
    2986   }
     2982     delete [] status_;
     2983     if (statusArray) {
     2984          status_ = new unsigned char [numberRows_+numberColumns_];
     2985          CoinMemcpyN(statusArray, (numberRows_ + numberColumns_), status_);
     2986     } else {
     2987          status_ = NULL;
     2988     }
    29872989}
    29882990#ifndef SLIM_CLP
    2989 // Load up quadratic objective 
    2990 void 
     2991// Load up quadratic objective
     2992void
    29912993ClpModel::loadQuadraticObjective(const int numberColumns, const CoinBigIndex * start,
    2992                               const int * column, const double * element)
    2993 {
    2994   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2995   CoinAssert (numberColumns==numberColumns_);
    2996   assert ((dynamic_cast< ClpLinearObjective*>(objective_)));
    2997   double offset;
    2998   ClpObjective * obj = new ClpQuadraticObjective(objective_->gradient(NULL,NULL,offset,false),
    2999                                                 numberColumns,
    3000                                                  start,column,element);
    3001   delete objective_;
    3002   objective_ = obj;
    3003 
    3004 }
    3005 void 
     2994                                 const int * column, const double * element)
     2995{
     2996     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2997     CoinAssert (numberColumns == numberColumns_);
     2998     assert ((dynamic_cast< ClpLinearObjective*>(objective_)));
     2999     double offset;
     3000     ClpObjective * obj = new ClpQuadraticObjective(objective_->gradient(NULL, NULL, offset, false),
     3001              numberColumns,
     3002               start, column, element);
     3003     delete objective_;
     3004     objective_ = obj;
     3005
     3006}
     3007void
    30063008ClpModel::loadQuadraticObjective (  const CoinPackedMatrix& matrix)
    30073009{
    3008   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3009   CoinAssert (matrix.getNumCols()==numberColumns_);
    3010   assert ((dynamic_cast< ClpLinearObjective*>(objective_)));
    3011   double offset;
    3012   ClpQuadraticObjective * obj =
    3013     new ClpQuadraticObjective(objective_->gradient(NULL,NULL,offset,false),
    3014                               numberColumns_,
    3015                               NULL,NULL,NULL);
    3016   delete objective_;
    3017   objective_ = obj;
    3018   obj->loadQuadraticObjective(matrix);
     3010     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3011     CoinAssert (matrix.getNumCols() == numberColumns_);
     3012     assert ((dynamic_cast< ClpLinearObjective*>(objective_)));
     3013     double offset;
     3014     ClpQuadraticObjective * obj =
     3015          new ClpQuadraticObjective(objective_->gradient(NULL, NULL, offset, false),
     3016                                    numberColumns_,
     3017                                    NULL, NULL, NULL);
     3018     delete objective_;
     3019     objective_ = obj;
     3020     obj->loadQuadraticObjective(matrix);
    30193021}
    30203022// Get rid of quadratic objective
    3021 void 
     3023void
    30223024ClpModel::deleteQuadraticObjective()
    30233025{
    3024   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3025   ClpQuadraticObjective * obj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
    3026   if (obj)
    3027     obj->deleteQuadraticObjective();
    3028 }
    3029 #endif
    3030 void 
     3026     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3027     ClpQuadraticObjective * obj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
     3028     if (obj)
     3029          obj->deleteQuadraticObjective();
     3030}
     3031#endif
     3032void
    30313033ClpModel::setObjective(ClpObjective * objective)
    30323034{
    3033   whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3034   delete objective_;
    3035   objective_=objective->clone();
     3035     whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3036     delete objective_;
     3037     objective_ = objective->clone();
    30363038}
    30373039// Returns resized array and updates size
    30383040double * whichDouble(double * array , int number, const int * which)
    30393041{
    3040   double * newArray=NULL;
    3041   if (array&&number) {
    3042     int i ;
    3043     newArray = new double[number];
    3044     for (i=0;i<number;i++)
    3045       newArray[i]=array[which[i]];
    3046   }
    3047   return newArray;
     3042     double * newArray = NULL;
     3043     if (array && number) {
     3044          int i ;
     3045          newArray = new double[number];
     3046          for (i = 0; i < number; i++)
     3047               newArray[i] = array[which[i]];
     3048     }
     3049     return newArray;
    30483050}
    30493051char * whichChar(char * array , int number, const int * which)
    30503052{
    3051   char * newArray=NULL;
    3052   if (array&&number) {
    3053     int i ;
    3054     newArray = new char[number];
    3055     for (i=0;i<number;i++)
    3056       newArray[i]=array[which[i]];
    3057   }
    3058   return newArray;
    3059 }
    3060 unsigned char * whichUnsignedChar(unsigned char * array , 
    3061                                   int number, const int * which)
    3062 {
    3063   unsigned char * newArray=NULL;
    3064   if (array&&number) {
    3065     int i ;
    3066     newArray = new unsigned char[number];
    3067     for (i=0;i<number;i++)
    3068       newArray[i]=array[which[i]];
    3069   }
    3070   return newArray;
     3053     char * newArray = NULL;
     3054     if (array && number) {
     3055          int i ;
     3056          newArray = new char[number];
     3057          for (i = 0; i < number; i++)
     3058               newArray[i] = array[which[i]];
     3059     }
     3060     return newArray;
     3061}