Ignore:
Timestamp:
Jan 6, 2019 2:43:06 PM (3 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

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

    r2369 r2385  
    3535*/
    3636
    37 
    3837#include "CoinPragma.hpp"
    3938
     
    5049#endif
    5150#include "CoinIndexedVector.hpp"
    52 #if SLIM_CLP==2
     51#if SLIM_CLP == 2
    5352#define SLIM_NOIO
    5453#endif
     
    6766
    6867//#############################################################################
    69 ClpModel::ClpModel (bool emptyMessages) :
    70 
    71      optimizationDirection_(1),
    72      objectiveValue_(0.0),
    73      smallElement_(1.0e-20),
    74      objectiveScale_(1.0),
    75      rhsScale_(1.0),
    76      numberRows_(0),
    77      numberColumns_(0),
    78      rowActivity_(NULL),
    79      columnActivity_(NULL),
    80      dual_(NULL),
    81      reducedCost_(NULL),
    82      rowLower_(NULL),
    83      rowUpper_(NULL),
    84      objective_(NULL),
    85      rowObjective_(NULL),
    86      columnLower_(NULL),
    87      columnUpper_(NULL),
    88      matrix_(NULL),
    89      rowCopy_(NULL),
    90      scaledMatrix_(NULL),
    91      ray_(NULL),
    92      rowScale_(NULL),
    93      columnScale_(NULL),
    94      inverseRowScale_(NULL),
    95      inverseColumnScale_(NULL),
    96      scalingFlag_(3),
    97      status_(NULL),
    98      integerType_(NULL),
    99      userPointer_(NULL),
    100      trustedUserPointer_(NULL),
    101      numberIterations_(0),
    102      solveType_(0),
    103      whatsChanged_(0),
    104      problemStatus_(-1),
    105      secondaryStatus_(0),
    106      lengthNames_(0),
    107      numberThreads_(0),
    108      specialOptions_(0),
     68ClpModel::ClpModel(bool emptyMessages)
     69  :
     70
     71  optimizationDirection_(1)
     72  , objectiveValue_(0.0)
     73  , smallElement_(1.0e-20)
     74  , objectiveScale_(1.0)
     75  , rhsScale_(1.0)
     76  , numberRows_(0)
     77  , numberColumns_(0)
     78  , rowActivity_(NULL)
     79  , columnActivity_(NULL)
     80  , dual_(NULL)
     81  , reducedCost_(NULL)
     82  , rowLower_(NULL)
     83  , rowUpper_(NULL)
     84  , objective_(NULL)
     85  , rowObjective_(NULL)
     86  , columnLower_(NULL)
     87  , columnUpper_(NULL)
     88  , matrix_(NULL)
     89  , rowCopy_(NULL)
     90  , scaledMatrix_(NULL)
     91  , ray_(NULL)
     92  , rowScale_(NULL)
     93  , columnScale_(NULL)
     94  , inverseRowScale_(NULL)
     95  , inverseColumnScale_(NULL)
     96  , scalingFlag_(3)
     97  , status_(NULL)
     98  , integerType_(NULL)
     99  , userPointer_(NULL)
     100  , trustedUserPointer_(NULL)
     101  , numberIterations_(0)
     102  , solveType_(0)
     103  , whatsChanged_(0)
     104  , problemStatus_(-1)
     105  , secondaryStatus_(0)
     106  , lengthNames_(0)
     107  , numberThreads_(0)
     108  , specialOptions_(0)
     109  ,
    109110#ifndef CLP_NO_STD
    110      defaultHandler_(true),
    111      rowNames_(),
    112      columnNames_(),
     111  defaultHandler_(true)
     112  , rowNames_()
     113  , columnNames_()
     114  ,
    113115#else
    114      defaultHandler_(true),
    115 #endif
    116      maximumColumns_(-1),
    117      maximumRows_(-1),
    118      maximumInternalColumns_(-1),
    119      maximumInternalRows_(-1),
    120      savedRowScale_(NULL),
    121      savedColumnScale_(NULL)
    122 {
    123      intParam_[ClpMaxNumIteration] = 2147483647;
    124      intParam_[ClpMaxNumIterationHotStart] = 9999999;
    125      intParam_[ClpNameDiscipline] = 1;
    126 
    127      dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
    128      dblParam_[ClpPrimalObjectiveLimit] = COIN_DBL_MAX;
    129      dblParam_[ClpDualTolerance] = 1e-7;
    130      dblParam_[ClpPrimalTolerance] = 1e-7;
    131      dblParam_[ClpObjOffset] = 0.0;
    132      dblParam_[ClpMaxSeconds] = -1.0;
    133      dblParam_[ClpMaxWallSeconds] = -1.0;
    134      dblParam_[ClpPresolveTolerance] = 1.0e-8;
     116  defaultHandler_(true)
     117  ,
     118#endif
     119  maximumColumns_(-1)
     120  , maximumRows_(-1)
     121  , maximumInternalColumns_(-1)
     122  , maximumInternalRows_(-1)
     123  , savedRowScale_(NULL)
     124  , savedColumnScale_(NULL)
     125{
     126  intParam_[ClpMaxNumIteration] = 2147483647;
     127  intParam_[ClpMaxNumIterationHotStart] = 9999999;
     128  intParam_[ClpNameDiscipline] = 1;
     129
     130  dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
     131  dblParam_[ClpPrimalObjectiveLimit] = COIN_DBL_MAX;
     132  dblParam_[ClpDualTolerance] = 1e-7;
     133  dblParam_[ClpPrimalTolerance] = 1e-7;
     134  dblParam_[ClpObjOffset] = 0.0;
     135  dblParam_[ClpMaxSeconds] = -1.0;
     136  dblParam_[ClpMaxWallSeconds] = -1.0;
     137  dblParam_[ClpPresolveTolerance] = 1.0e-8;
    135138
    136139#ifndef CLP_NO_STD
    137      strParam_[ClpProbName] = "ClpDefaultName";
    138 #endif
    139      handler_ = new CoinMessageHandler();
    140      handler_->setLogLevel(1);
    141      eventHandler_ = new ClpEventHandler();
    142      if (!emptyMessages) {
    143           messages_ = ClpMessage();
    144           coinMessages_ = CoinMessage();
    145      }
    146      randomNumberGenerator_.setSeed(1234567);
     140  strParam_[ClpProbName] = "ClpDefaultName";
     141#endif
     142  handler_ = new CoinMessageHandler();
     143  handler_->setLogLevel(1);
     144  eventHandler_ = new ClpEventHandler();
     145  if (!emptyMessages) {
     146    messages_ = ClpMessage();
     147    coinMessages_ = CoinMessage();
     148  }
     149  randomNumberGenerator_.setSeed(1234567);
    147150}
    148151
    149152//-----------------------------------------------------------------------------
    150153
    151 ClpModel::~ClpModel ()
    152 {
    153      if (defaultHandler_) {
    154           delete handler_;
    155           handler_ = NULL;
    156      }
    157      gutsOfDelete(0);
     154ClpModel::~ClpModel()
     155{
     156  if (defaultHandler_) {
     157    delete handler_;
     158    handler_ = NULL;
     159  }
     160  gutsOfDelete(0);
    158161}
    159162// Does most of deletion (0 = all, 1 = most)
    160 void
    161 ClpModel::gutsOfDelete(int type)
    162 {
    163      if (!type || !permanentArrays()) {
    164           maximumRows_ = -1;
    165           maximumColumns_ = -1;
    166           delete [] rowActivity_;
    167           rowActivity_ = NULL;
    168           delete [] columnActivity_;
    169           columnActivity_ = NULL;
    170           delete [] dual_;
    171           dual_ = NULL;
    172           delete [] reducedCost_;
    173           reducedCost_ = NULL;
    174           delete [] rowLower_;
    175           delete [] rowUpper_;
    176           delete [] rowObjective_;
    177           rowLower_ = NULL;
    178           rowUpper_ = NULL;
    179           rowObjective_ = NULL;
    180           delete [] columnLower_;
    181           delete [] columnUpper_;
    182           delete objective_;
    183           columnLower_ = NULL;
    184           columnUpper_ = NULL;
    185           objective_ = NULL;
    186           delete [] savedRowScale_;
    187           if (rowScale_ == savedRowScale_)
    188                rowScale_ = NULL;
    189           savedRowScale_ = NULL;
    190           delete [] savedColumnScale_;
    191           if (columnScale_ == savedColumnScale_)
    192                columnScale_ = NULL;
    193           savedColumnScale_ = NULL;
    194           delete [] rowScale_;
    195           rowScale_ = NULL;
    196           delete [] columnScale_;
    197           columnScale_ = NULL;
    198           delete [] integerType_;
    199           integerType_ = NULL;
    200           delete [] status_;
    201           status_ = NULL;
    202           delete eventHandler_;
    203           eventHandler_ = NULL;
    204      }
    205      whatsChanged_ = 0;
    206      delete matrix_;
    207      matrix_ = NULL;
    208      delete rowCopy_;
    209      rowCopy_ = NULL;
    210      delete scaledMatrix_;
    211      scaledMatrix_ = NULL,
    212      delete [] ray_;
    213      ray_ = NULL;
    214      specialOptions_ = 0;
    215 }
    216 void
    217 ClpModel::setRowScale(double * scale)
    218 {
    219      if (!savedRowScale_) {
    220           delete [] reinterpret_cast<double *> (rowScale_);
    221           rowScale_ = scale;
    222      } else {
    223           assert (!scale);
    224           rowScale_ = NULL;
    225      }
    226 }
    227 void
    228 ClpModel::setColumnScale(double * scale)
    229 {
    230      if (!savedColumnScale_) {
    231           delete [] reinterpret_cast<double *> (columnScale_);
    232           columnScale_ = scale;
    233      } else {
    234           assert (!scale);
    235           columnScale_ = NULL;
    236      }
     163void ClpModel::gutsOfDelete(int type)
     164{
     165  if (!type || !permanentArrays()) {
     166    maximumRows_ = -1;
     167    maximumColumns_ = -1;
     168    delete[] rowActivity_;
     169    rowActivity_ = NULL;
     170    delete[] columnActivity_;
     171    columnActivity_ = NULL;
     172    delete[] dual_;
     173    dual_ = NULL;
     174    delete[] reducedCost_;
     175    reducedCost_ = NULL;
     176    delete[] rowLower_;
     177    delete[] rowUpper_;
     178    delete[] rowObjective_;
     179    rowLower_ = NULL;
     180    rowUpper_ = NULL;
     181    rowObjective_ = NULL;
     182    delete[] columnLower_;
     183    delete[] columnUpper_;
     184    delete objective_;
     185    columnLower_ = NULL;
     186    columnUpper_ = NULL;
     187    objective_ = NULL;
     188    delete[] savedRowScale_;
     189    if (rowScale_ == savedRowScale_)
     190      rowScale_ = NULL;
     191    savedRowScale_ = NULL;
     192    delete[] savedColumnScale_;
     193    if (columnScale_ == savedColumnScale_)
     194      columnScale_ = NULL;
     195    savedColumnScale_ = NULL;
     196    delete[] rowScale_;
     197    rowScale_ = NULL;
     198    delete[] columnScale_;
     199    columnScale_ = NULL;
     200    delete[] integerType_;
     201    integerType_ = NULL;
     202    delete[] status_;
     203    status_ = NULL;
     204    delete eventHandler_;
     205    eventHandler_ = NULL;
     206  }
     207  whatsChanged_ = 0;
     208  delete matrix_;
     209  matrix_ = NULL;
     210  delete rowCopy_;
     211  rowCopy_ = NULL;
     212  delete scaledMatrix_;
     213  scaledMatrix_ = NULL,
     214  delete[] ray_;
     215  ray_ = NULL;
     216  specialOptions_ = 0;
     217}
     218void ClpModel::setRowScale(double *scale)
     219{
     220  if (!savedRowScale_) {
     221    delete[] reinterpret_cast< double * >(rowScale_);
     222    rowScale_ = scale;
     223  } else {
     224    assert(!scale);
     225    rowScale_ = NULL;
     226  }
     227}
     228void ClpModel::setColumnScale(double *scale)
     229{
     230  if (!savedColumnScale_) {
     231    delete[] reinterpret_cast< double * >(columnScale_);
     232    columnScale_ = scale;
     233  } else {
     234    assert(!scale);
     235    columnScale_ = NULL;
     236  }
    237237}
    238238//#############################################################################
    239 void ClpModel::setPrimalTolerance( double value)
    240 {
    241      if (value > 0.0 && value < 1.0e10)
    242           dblParam_[ClpPrimalTolerance] = value;
    243 }
    244 void ClpModel::setDualTolerance( double value)
    245 {
    246      if (value > 0.0 && value < 1.0e10)
    247           dblParam_[ClpDualTolerance] = value;
    248 }
    249 void ClpModel::setOptimizationDirection( double value)
    250 {
    251      optimizationDirection_ = value;
    252 }
    253 void
    254 ClpModel::gutsOfLoadModel (int numberRows, int numberColumns,
    255                            const double* collb, const double* colub,
    256                            const double* obj,
    257                            const double* rowlb, const double* rowub,
    258                            const double * rowObjective)
    259 {
    260      // save event handler in case already set
    261      ClpEventHandler * handler = eventHandler_->clone();
    262      // Save specialOptions
    263      int saveOptions = specialOptions_;
    264      gutsOfDelete(0);
    265      specialOptions_ = saveOptions;
    266      eventHandler_ = handler;
    267      numberRows_ = numberRows;
    268      numberColumns_ = numberColumns;
    269      rowActivity_ = new double[numberRows_];
    270      columnActivity_ = new double[numberColumns_];
    271      dual_ = new double[numberRows_];
    272      reducedCost_ = new double[numberColumns_];
    273 
    274      CoinZeroN(dual_, numberRows_);
    275      CoinZeroN(reducedCost_, numberColumns_);
    276      int iRow, iColumn;
    277 
    278      rowLower_ = ClpCopyOfArray(rowlb, numberRows_, -COIN_DBL_MAX);
    279      rowUpper_ = ClpCopyOfArray(rowub, numberRows_, COIN_DBL_MAX);
    280      double * objective = ClpCopyOfArray(obj, numberColumns_, 0.0);
    281      objective_ = new ClpLinearObjective(objective, numberColumns_);
    282      delete [] objective;
    283      rowObjective_ = ClpCopyOfArray(rowObjective, numberRows_);
    284      columnLower_ = ClpCopyOfArray(collb, numberColumns_, 0.0);
    285      columnUpper_ = ClpCopyOfArray(colub, numberColumns_, COIN_DBL_MAX);
    286      // set default solution and clean bounds
    287      for (iRow = 0; iRow < numberRows_; iRow++) {
    288           if (rowLower_[iRow] > 0.0) {
    289                rowActivity_[iRow] = rowLower_[iRow];
    290           } else if (rowUpper_[iRow] < 0.0) {
    291                rowActivity_[iRow] = rowUpper_[iRow];
    292           } else {
    293                rowActivity_[iRow] = 0.0;
    294           }
    295           if (rowLower_[iRow] < -1.0e27)
    296                rowLower_[iRow] = -COIN_DBL_MAX;
    297           if (rowUpper_[iRow] > 1.0e27)
    298                rowUpper_[iRow] = COIN_DBL_MAX;
    299      }
    300      for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
    301           if (columnLower_[iColumn] > 0.0) {
    302                columnActivity_[iColumn] = columnLower_[iColumn];
    303           } else if (columnUpper_[iColumn] < 0.0) {
    304                columnActivity_[iColumn] = columnUpper_[iColumn];
    305           } else {
    306                columnActivity_[iColumn] = 0.0;
    307           }
    308           if (columnLower_[iColumn] < -1.0e27)
    309                columnLower_[iColumn] = -COIN_DBL_MAX;
    310           if (columnUpper_[iColumn] > 1.0e27)
    311                columnUpper_[iColumn] = COIN_DBL_MAX;
    312      }
     239void ClpModel::setPrimalTolerance(double value)
     240{
     241  if (value > 0.0 && value < 1.0e10)
     242    dblParam_[ClpPrimalTolerance] = value;
     243}
     244void ClpModel::setDualTolerance(double value)
     245{
     246  if (value > 0.0 && value < 1.0e10)
     247    dblParam_[ClpDualTolerance] = value;
     248}
     249void ClpModel::setOptimizationDirection(double value)
     250{
     251  optimizationDirection_ = value;
     252}
     253void ClpModel::gutsOfLoadModel(int numberRows, int numberColumns,
     254  const double *collb, const double *colub,
     255  const double *obj,
     256  const double *rowlb, const double *rowub,
     257  const double *rowObjective)
     258{
     259  // save event handler in case already set
     260  ClpEventHandler *handler = eventHandler_->clone();
     261  // Save specialOptions
     262  int saveOptions = specialOptions_;
     263  gutsOfDelete(0);
     264  specialOptions_ = saveOptions;
     265  eventHandler_ = handler;
     266  numberRows_ = numberRows;
     267  numberColumns_ = numberColumns;
     268  rowActivity_ = new double[numberRows_];
     269  columnActivity_ = new double[numberColumns_];
     270  dual_ = new double[numberRows_];
     271  reducedCost_ = new double[numberColumns_];
     272
     273  CoinZeroN(dual_, numberRows_);
     274  CoinZeroN(reducedCost_, numberColumns_);
     275  int iRow, iColumn;
     276
     277  rowLower_ = ClpCopyOfArray(rowlb, numberRows_, -COIN_DBL_MAX);
     278  rowUpper_ = ClpCopyOfArray(rowub, numberRows_, COIN_DBL_MAX);
     279  double *objective = ClpCopyOfArray(obj, numberColumns_, 0.0);
     280  objective_ = new ClpLinearObjective(objective, numberColumns_);
     281  delete[] objective;
     282  rowObjective_ = ClpCopyOfArray(rowObjective, numberRows_);
     283  columnLower_ = ClpCopyOfArray(collb, numberColumns_, 0.0);
     284  columnUpper_ = ClpCopyOfArray(colub, numberColumns_, COIN_DBL_MAX);
     285  // set default solution and clean bounds
     286  for (iRow = 0; iRow < numberRows_; iRow++) {
     287    if (rowLower_[iRow] > 0.0) {
     288      rowActivity_[iRow] = rowLower_[iRow];
     289    } else if (rowUpper_[iRow] < 0.0) {
     290      rowActivity_[iRow] = rowUpper_[iRow];
     291    } else {
     292      rowActivity_[iRow] = 0.0;
     293    }
     294    if (rowLower_[iRow] < -1.0e27)
     295      rowLower_[iRow] = -COIN_DBL_MAX;
     296    if (rowUpper_[iRow] > 1.0e27)
     297      rowUpper_[iRow] = COIN_DBL_MAX;
     298  }
     299  for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     300    if (columnLower_[iColumn] > 0.0) {
     301      columnActivity_[iColumn] = columnLower_[iColumn];
     302    } else if (columnUpper_[iColumn] < 0.0) {
     303      columnActivity_[iColumn] = columnUpper_[iColumn];
     304    } else {
     305      columnActivity_[iColumn] = 0.0;
     306    }
     307    if (columnLower_[iColumn] < -1.0e27)
     308      columnLower_[iColumn] = -COIN_DBL_MAX;
     309    if (columnUpper_[iColumn] > 1.0e27)
     310      columnUpper_[iColumn] = COIN_DBL_MAX;
     311  }
    313312}
    314313// This just loads up a row objective
    315 void ClpModel::setRowObjective(const double * rowObjective)
    316 {
    317      delete [] rowObjective_;
    318      rowObjective_ = ClpCopyOfArray(rowObjective, numberRows_);
    319      whatsChanged_ = 0;
    320 }
    321 void
    322 ClpModel::loadProblem (  const ClpMatrixBase& matrix,
    323                          const double* collb, const double* colub,
    324                          const double* obj,
    325                          const double* rowlb, const double* rowub,
    326                          const double * rowObjective)
    327 {
    328      gutsOfLoadModel(matrix.getNumRows(), matrix.getNumCols(),
    329                      collb, colub, obj, rowlb, rowub, rowObjective);
    330      if (matrix.isColOrdered()) {
    331           matrix_ = matrix.clone();
    332      } else {
    333           // later may want to keep as unknown class
    334           CoinPackedMatrix matrix2;
    335           matrix2.setExtraGap(0.0);
    336           matrix2.setExtraMajor(0.0);
    337           matrix2.reverseOrderedCopyOf(*matrix.getPackedMatrix());
    338           matrix.releasePackedMatrix();
    339           matrix_ = new ClpPackedMatrix(matrix2);
    340      }
    341      matrix_->setDimensions(numberRows_, numberColumns_);
    342 }
    343 void
    344 ClpModel::loadProblem (  const CoinPackedMatrix& matrix,
    345                          const double* collb, const double* colub,
    346                          const double* obj,
    347                          const double* rowlb, const double* rowub,
    348                          const double * rowObjective)
    349 {
    350      ClpPackedMatrix* clpMatrix =
    351           dynamic_cast< ClpPackedMatrix*>(matrix_);
    352      bool special = (clpMatrix) ? clpMatrix->wantsSpecialColumnCopy() : false;
    353      gutsOfLoadModel(matrix.getNumRows(), matrix.getNumCols(),
    354                      collb, colub, obj, rowlb, rowub, rowObjective);
    355      if (matrix.isColOrdered()) {
    356           matrix_ = new ClpPackedMatrix(matrix);
    357           if (special) {
    358                clpMatrix = static_cast< ClpPackedMatrix*>(matrix_);
    359                clpMatrix->makeSpecialColumnCopy();
    360           }
    361      } else {
    362           CoinPackedMatrix matrix2;
    363           matrix2.setExtraGap(0.0);
    364           matrix2.setExtraMajor(0.0);
    365           matrix2.reverseOrderedCopyOf(matrix);
    366           matrix_ = new ClpPackedMatrix(matrix2);
    367      }
    368      matrix_->setDimensions(numberRows_, numberColumns_);
    369 }
    370 void
    371 ClpModel::loadProblem (
    372      const int numcols, const int numrows,
    373      const CoinBigIndex* start, const int* index,
    374      const double* value,
    375      const double* collb, const double* colub,
    376      const double* obj,
    377      const double* rowlb, const double* rowub,
    378      const double * rowObjective)
    379 {
    380      gutsOfLoadModel(numrows, numcols,
    381                      collb, colub, obj, rowlb, rowub, rowObjective);
    382      CoinBigIndex numberElements = start ? start[numcols] : 0;
    383      CoinPackedMatrix matrix(true, numrows, numrows ? numcols : 0, numberElements,
    384                              value, index, start, NULL);
    385      matrix_ = new ClpPackedMatrix(matrix);
    386      matrix_->setDimensions(numberRows_, numberColumns_);
    387 }
    388 void
    389 ClpModel::loadProblem (
    390      const int numcols, const int numrows,
    391      const CoinBigIndex* start, const int* index,
    392      const double* value, const int* length,
    393      const double* collb, const double* colub,
    394      const double* obj,
    395      const double* rowlb, const double* rowub,
    396      const double * rowObjective)
    397 {
    398      gutsOfLoadModel(numrows, numcols,
    399                      collb, colub, obj, rowlb, rowub, rowObjective);
    400      // Compute number of elements
    401      int numberElements = 0;
    402      int i;
    403      for (i = 0; i < numcols; i++)
    404           numberElements += length[i];
    405      CoinPackedMatrix matrix(true, numrows, numcols, numberElements,
    406                              value, index, start, length);
    407      matrix_ = new ClpPackedMatrix(matrix);
     314void ClpModel::setRowObjective(const double *rowObjective)
     315{
     316  delete[] rowObjective_;
     317  rowObjective_ = ClpCopyOfArray(rowObjective, numberRows_);
     318  whatsChanged_ = 0;
     319}
     320void ClpModel::loadProblem(const ClpMatrixBase &matrix,
     321  const double *collb, const double *colub,
     322  const double *obj,
     323  const double *rowlb, const double *rowub,
     324  const double *rowObjective)
     325{
     326  gutsOfLoadModel(matrix.getNumRows(), matrix.getNumCols(),
     327    collb, colub, obj, rowlb, rowub, rowObjective);
     328  if (matrix.isColOrdered()) {
     329    matrix_ = matrix.clone();
     330  } else {
     331    // later may want to keep as unknown class
     332    CoinPackedMatrix matrix2;
     333    matrix2.setExtraGap(0.0);
     334    matrix2.setExtraMajor(0.0);
     335    matrix2.reverseOrderedCopyOf(*matrix.getPackedMatrix());
     336    matrix.releasePackedMatrix();
     337    matrix_ = new ClpPackedMatrix(matrix2);
     338  }
     339  matrix_->setDimensions(numberRows_, numberColumns_);
     340}
     341void ClpModel::loadProblem(const CoinPackedMatrix &matrix,
     342  const double *collb, const double *colub,
     343  const double *obj,
     344  const double *rowlb, const double *rowub,
     345  const double *rowObjective)
     346{
     347  ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(matrix_);
     348  bool special = (clpMatrix) ? clpMatrix->wantsSpecialColumnCopy() : false;
     349  gutsOfLoadModel(matrix.getNumRows(), matrix.getNumCols(),
     350    collb, colub, obj, rowlb, rowub, rowObjective);
     351  if (matrix.isColOrdered()) {
     352    matrix_ = new ClpPackedMatrix(matrix);
     353    if (special) {
     354      clpMatrix = static_cast< ClpPackedMatrix * >(matrix_);
     355      clpMatrix->makeSpecialColumnCopy();
     356    }
     357  } else {
     358    CoinPackedMatrix matrix2;
     359    matrix2.setExtraGap(0.0);
     360    matrix2.setExtraMajor(0.0);
     361    matrix2.reverseOrderedCopyOf(matrix);
     362    matrix_ = new ClpPackedMatrix(matrix2);
     363  }
     364  matrix_->setDimensions(numberRows_, numberColumns_);
     365}
     366void ClpModel::loadProblem(
     367  const int numcols, const int numrows,
     368  const CoinBigIndex *start, const int *index,
     369  const double *value,
     370  const double *collb, const double *colub,
     371  const double *obj,
     372  const double *rowlb, const double *rowub,
     373  const double *rowObjective)
     374{
     375  gutsOfLoadModel(numrows, numcols,
     376    collb, colub, obj, rowlb, rowub, rowObjective);
     377  CoinBigIndex numberElements = start ? start[numcols] : 0;
     378  CoinPackedMatrix matrix(true, numrows, numrows ? numcols : 0, numberElements,
     379    value, index, start, NULL);
     380  matrix_ = new ClpPackedMatrix(matrix);
     381  matrix_->setDimensions(numberRows_, numberColumns_);
     382}
     383void ClpModel::loadProblem(
     384  const int numcols, const int numrows,
     385  const CoinBigIndex *start, const int *index,
     386  const double *value, const int *length,
     387  const double *collb, const double *colub,
     388  const double *obj,
     389  const double *rowlb, const double *rowub,
     390  const double *rowObjective)
     391{
     392  gutsOfLoadModel(numrows, numcols,
     393    collb, colub, obj, rowlb, rowub, rowObjective);
     394  // Compute number of elements
     395  int numberElements = 0;
     396  int i;
     397  for (i = 0; i < numcols; i++)
     398    numberElements += length[i];
     399  CoinPackedMatrix matrix(true, numrows, numcols, numberElements,
     400    value, index, start, length);
     401  matrix_ = new ClpPackedMatrix(matrix);
    408402}
    409403#ifndef SLIM_NOIO
    410404// This loads a model from a coinModel object - returns number of errors
    411 int
    412 ClpModel::loadProblem (  CoinModel & modelObject, bool tryPlusMinusOne)
    413 {
    414      if (modelObject.numberColumns() == 0 && modelObject.numberRows() == 0)
    415           return 0;
    416      int numberErrors = 0;
    417      // Set arrays for normal use
    418      double * rowLower = modelObject.rowLowerArray();
    419      double * rowUpper = modelObject.rowUpperArray();
    420      double * columnLower = modelObject.columnLowerArray();
    421      double * columnUpper = modelObject.columnUpperArray();
    422      double * objective = modelObject.objectiveArray();
    423      int * integerType = modelObject.integerTypeArray();
    424      double * associated = modelObject.associatedArray();
    425      // If strings then do copies
    426      if (modelObject.stringsExist()) {
    427           numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
    428                                                   objective, integerType, associated);
    429      }
    430      int numberRows = modelObject.numberRows();
    431      int numberColumns = modelObject.numberColumns();
    432      gutsOfLoadModel(numberRows, numberColumns,
    433                      columnLower, columnUpper, objective, rowLower, rowUpper, NULL);
    434      setObjectiveOffset(modelObject.objectiveOffset());
    435      CoinBigIndex * startPositive = NULL;
    436      CoinBigIndex * startNegative = NULL;
    437      delete matrix_;
    438      if (tryPlusMinusOne) {
    439           startPositive = new CoinBigIndex[numberColumns+1];
    440           startNegative = new CoinBigIndex[numberColumns];
    441           modelObject.countPlusMinusOne(startPositive, startNegative, associated);
    442           if (startPositive[0] < 0) {
    443                // no good
    444                tryPlusMinusOne = false;
    445                delete [] startPositive;
    446                delete [] startNegative;
    447           }
    448      }
     405int ClpModel::loadProblem(CoinModel &modelObject, bool tryPlusMinusOne)
     406{
     407  if (modelObject.numberColumns() == 0 && modelObject.numberRows() == 0)
     408    return 0;
     409  int numberErrors = 0;
     410  // Set arrays for normal use
     411  double *rowLower = modelObject.rowLowerArray();
     412  double *rowUpper = modelObject.rowUpperArray();
     413  double *columnLower = modelObject.columnLowerArray();
     414  double *columnUpper = modelObject.columnUpperArray();
     415  double *objective = modelObject.objectiveArray();
     416  int *integerType = modelObject.integerTypeArray();
     417  double *associated = modelObject.associatedArray();
     418  // If strings then do copies
     419  if (modelObject.stringsExist()) {
     420    numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
     421      objective, integerType, associated);
     422  }
     423  int numberRows = modelObject.numberRows();
     424  int numberColumns = modelObject.numberColumns();
     425  gutsOfLoadModel(numberRows, numberColumns,
     426    columnLower, columnUpper, objective, rowLower, rowUpper, NULL);
     427  setObjectiveOffset(modelObject.objectiveOffset());
     428  CoinBigIndex *startPositive = NULL;
     429  CoinBigIndex *startNegative = NULL;
     430  delete matrix_;
     431  if (tryPlusMinusOne) {
     432    startPositive = new CoinBigIndex[numberColumns + 1];
     433    startNegative = new CoinBigIndex[numberColumns];
     434    modelObject.countPlusMinusOne(startPositive, startNegative, associated);
     435    if (startPositive[0] < 0) {
     436      // no good
     437      tryPlusMinusOne = false;
     438      delete[] startPositive;
     439      delete[] startNegative;
     440    }
     441  }
    449442#ifndef SLIM_CLP
    450      if (!tryPlusMinusOne) {
    451 #endif
    452           CoinPackedMatrix matrix;
    453           modelObject.createPackedMatrix(matrix, associated);
    454           matrix_ = new ClpPackedMatrix(matrix);
     443  if (!tryPlusMinusOne) {
     444#endif
     445    CoinPackedMatrix matrix;
     446    modelObject.createPackedMatrix(matrix, associated);
     447    matrix_ = new ClpPackedMatrix(matrix);
    455448#ifndef SLIM_CLP
    456      } else {
    457           // create +-1 matrix
    458           CoinBigIndex size = startPositive[numberColumns];
    459           int * indices = new int[size];
    460           modelObject.createPlusMinusOne(startPositive, startNegative, indices,
    461                                          associated);
    462           // Get good object
    463           ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    464           matrix->passInCopy(numberRows, numberColumns,
    465                              true, indices, startPositive, startNegative);
    466           matrix_ = matrix;
    467      }
     449  } else {
     450    // create +-1 matrix
     451    CoinBigIndex size = startPositive[numberColumns];
     452    int *indices = new int[size];
     453    modelObject.createPlusMinusOne(startPositive, startNegative, indices,
     454      associated);
     455    // Get good object
     456    ClpPlusMinusOneMatrix *matrix = new ClpPlusMinusOneMatrix();
     457    matrix->passInCopy(numberRows, numberColumns,
     458      true, indices, startPositive, startNegative);
     459    matrix_ = matrix;
     460  }
    468461#endif
    469462#ifndef CLP_NO_STD
    470      // Do names if wanted
    471      int numberItems;
    472      numberItems = modelObject.rowNames()->numberItems();
    473      if (numberItems) {
    474           const char *const * rowNames = modelObject.rowNames()->names();
    475           copyRowNames(rowNames, 0, numberItems);
    476      }
    477      numberItems = modelObject.columnNames()->numberItems();
    478      if (numberItems) {
    479           const char *const * columnNames = modelObject.columnNames()->names();
    480           copyColumnNames(columnNames, 0, numberItems);
    481      }
    482 #endif
    483      // Do integers if wanted
    484      assert(integerType);
    485      for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    486           if (integerType[iColumn])
    487                setInteger(iColumn);
    488      }
    489      if (rowLower != modelObject.rowLowerArray() ||
    490                columnLower != modelObject.columnLowerArray()) {
    491           delete [] rowLower;
    492           delete [] rowUpper;
    493           delete [] columnLower;
    494           delete [] columnUpper;
    495           delete [] objective;
    496           delete [] integerType;
    497           delete [] associated;
    498           if (numberErrors)
    499                handler_->message(CLP_BAD_STRING_VALUES, messages_)
    500                          << numberErrors
    501                          << CoinMessageEol;
    502      }
    503      matrix_->setDimensions(numberRows_, numberColumns_);
    504      return numberErrors;
    505 }
    506 #endif
    507 void
    508 ClpModel::getRowBound(int iRow, double& lower, double& upper) const
    509 {
    510      lower = -COIN_DBL_MAX;
    511      upper = COIN_DBL_MAX;
    512      if (rowUpper_)
    513           upper = rowUpper_[iRow];
    514      if (rowLower_)
    515           lower = rowLower_[iRow];
     463  // Do names if wanted
     464  int numberItems;
     465  numberItems = modelObject.rowNames()->numberItems();
     466  if (numberItems) {
     467    const char *const *rowNames = modelObject.rowNames()->names();
     468    copyRowNames(rowNames, 0, numberItems);
     469  }
     470  numberItems = modelObject.columnNames()->numberItems();
     471  if (numberItems) {
     472    const char *const *columnNames = modelObject.columnNames()->names();
     473    copyColumnNames(columnNames, 0, numberItems);
     474  }
     475#endif
     476  // Do integers if wanted
     477  assert(integerType);
     478  for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     479    if (integerType[iColumn])
     480      setInteger(iColumn);
     481  }
     482  if (rowLower != modelObject.rowLowerArray() || columnLower != modelObject.columnLowerArray()) {
     483    delete[] rowLower;
     484    delete[] rowUpper;
     485    delete[] columnLower;
     486    delete[] columnUpper;
     487    delete[] objective;
     488    delete[] integerType;
     489    delete[] associated;
     490    if (numberErrors)
     491      handler_->message(CLP_BAD_STRING_VALUES, messages_)
     492        << numberErrors
     493        << CoinMessageEol;
     494  }
     495  matrix_->setDimensions(numberRows_, numberColumns_);
     496  return numberErrors;
     497}
     498#endif
     499void ClpModel::getRowBound(int iRow, double &lower, double &upper) const
     500{
     501  lower = -COIN_DBL_MAX;
     502  upper = COIN_DBL_MAX;
     503  if (rowUpper_)
     504    upper = rowUpper_[iRow];
     505  if (rowLower_)
     506    lower = rowLower_[iRow];
    516507}
    517508//------------------------------------------------------------------
     
    520511// only called in debug mode
    521512static void indexError(int index,
    522                        std::string methodName)
    523 {
    524      std::cerr << "Illegal index " << index << " in ClpModel::" << methodName << std::endl;
    525      throw CoinError("Illegal index", methodName, "ClpModel");
     513  std::string methodName)
     514{
     515  std::cerr << "Illegal index " << index << " in ClpModel::" << methodName << std::endl;
     516  throw CoinError("Illegal index", methodName, "ClpModel");
    526517}
    527518#endif
    528519/* Set an objective function coefficient */
    529 void
    530 ClpModel::setObjectiveCoefficient( int elementIndex, double elementValue )
     520void ClpModel::setObjectiveCoefficient(int elementIndex, double elementValue)
    531521{
    532522#ifndef NDEBUG
    533      if (elementIndex < 0 || elementIndex >= numberColumns_) {
    534           indexError(elementIndex, "setObjectiveCoefficient");
    535      }
    536 #endif
    537      objective()[elementIndex] = elementValue;
    538      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     523  if (elementIndex < 0 || elementIndex >= numberColumns_) {
     524    indexError(elementIndex, "setObjectiveCoefficient");
     525  }
     526#endif
     527  objective()[elementIndex] = elementValue;
     528  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    539529}
    540530/* Set a single row lower bound<br>
    541531   Use -DBL_MAX for -infinity. */
    542 void
    543 ClpModel::setRowLower( int elementIndex, double elementValue )
    544 {
    545      if (elementValue < -1.0e27)
    546           elementValue = -COIN_DBL_MAX;
    547      rowLower_[elementIndex] = elementValue;
    548      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     532void ClpModel::setRowLower(int elementIndex, double elementValue)
     533{
     534  if (elementValue < -1.0e27)
     535    elementValue = -COIN_DBL_MAX;
     536  rowLower_[elementIndex] = elementValue;
     537  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    549538}
    550539
    551540/* Set a single row upper bound<br>
    552541   Use DBL_MAX for infinity. */
    553 void
    554 ClpModel::setRowUpper( int elementIndex, double elementValue )
    555 {
    556      if (elementValue > 1.0e27)
    557           elementValue = COIN_DBL_MAX;
    558      rowUpper_[elementIndex] = elementValue;
    559      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     542void ClpModel::setRowUpper(int elementIndex, double elementValue)
     543{
     544  if (elementValue > 1.0e27)
     545    elementValue = COIN_DBL_MAX;
     546  rowUpper_[elementIndex] = elementValue;
     547  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    560548}
    561549
    562550/* Set a single row lower and upper bound */
    563 void
    564 ClpModel::setRowBounds( int elementIndex,
    565                         double lower, double upper )
    566 {
    567      if (lower < -1.0e27)
    568           lower = -COIN_DBL_MAX;
    569      if (upper > 1.0e27)
    570           upper = COIN_DBL_MAX;
    571      CoinAssert (upper >= lower);
    572      rowLower_[elementIndex] = lower;
    573      rowUpper_[elementIndex] = upper;
    574      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    575 }
    576 void ClpModel::setRowSetBounds(const int* indexFirst,
    577                                const int* indexLast,
    578                                const double* boundList)
     551void ClpModel::setRowBounds(int elementIndex,
     552  double lower, double upper)
     553{
     554  if (lower < -1.0e27)
     555    lower = -COIN_DBL_MAX;
     556  if (upper > 1.0e27)
     557    upper = COIN_DBL_MAX;
     558  CoinAssert(upper >= lower);
     559  rowLower_[elementIndex] = lower;
     560  rowUpper_[elementIndex] = upper;
     561  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     562}
     563void ClpModel::setRowSetBounds(const int *indexFirst,
     564  const int *indexLast,
     565  const double *boundList)
    579566{
    580567#ifndef NDEBUG
    581      int n = numberRows_;
    582 #endif
    583      double * lower = rowLower_;
    584      double * upper = rowUpper_;
    585      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    586      while (indexFirst != indexLast) {
    587           const int iRow = *indexFirst++;
     568  int n = numberRows_;
     569#endif
     570  double *lower = rowLower_;
     571  double *upper = rowUpper_;
     572  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     573  while (indexFirst != indexLast) {
     574    const int iRow = *indexFirst++;
    588575#ifndef NDEBUG
    589           if (iRow < 0 || iRow >= n) {
    590                indexError(iRow, "setRowSetBounds");
    591           }
    592 #endif
    593           lower[iRow] = *boundList++;
    594           upper[iRow] = *boundList++;
    595           if (lower[iRow] < -1.0e27)
    596                lower[iRow] = -COIN_DBL_MAX;
    597           if (upper[iRow] > 1.0e27)
    598                upper[iRow] = COIN_DBL_MAX;
    599           CoinAssert (upper[iRow] >= lower[iRow]);
    600      }
     576    if (iRow < 0 || iRow >= n) {
     577      indexError(iRow, "setRowSetBounds");
     578    }
     579#endif
     580    lower[iRow] = *boundList++;
     581    upper[iRow] = *boundList++;
     582    if (lower[iRow] < -1.0e27)
     583      lower[iRow] = -COIN_DBL_MAX;
     584    if (upper[iRow] > 1.0e27)
     585      upper[iRow] = COIN_DBL_MAX;
     586    CoinAssert(upper[iRow] >= lower[iRow]);
     587  }
    601588}
    602589//-----------------------------------------------------------------------------
    603590/* Set a single column lower bound<br>
    604591   Use -DBL_MAX for -infinity. */
    605 void
    606 ClpModel::setColumnLower( int elementIndex, double elementValue )
     592void ClpModel::setColumnLower(int elementIndex, double elementValue)
    607593{
    608594#ifndef NDEBUG
    609      int n = numberColumns_;
    610      if (elementIndex < 0 || elementIndex >= n) {
    611           indexError(elementIndex, "setColumnLower");
    612      }
    613 #endif
    614      if (elementValue < -1.0e27)
    615           elementValue = -COIN_DBL_MAX;
    616      columnLower_[elementIndex] = elementValue;
    617      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     595  int n = numberColumns_;
     596  if (elementIndex < 0 || elementIndex >= n) {
     597    indexError(elementIndex, "setColumnLower");
     598  }
     599#endif
     600  if (elementValue < -1.0e27)
     601    elementValue = -COIN_DBL_MAX;
     602  columnLower_[elementIndex] = elementValue;
     603  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    618604}
    619605
    620606/* Set a single column upper bound<br>
    621607   Use DBL_MAX for infinity. */
    622 void
    623 ClpModel::setColumnUpper( int elementIndex, double elementValue )
     608void ClpModel::setColumnUpper(int elementIndex, double elementValue)
    624609{
    625610#ifndef NDEBUG
    626      int n = numberColumns_;
    627      if (elementIndex < 0 || elementIndex >= n) {
    628           indexError(elementIndex, "setColumnUpper");
    629      }
    630 #endif
    631      if (elementValue > 1.0e27)
    632           elementValue = COIN_DBL_MAX;
    633      columnUpper_[elementIndex] = elementValue;
    634      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     611  int n = numberColumns_;
     612  if (elementIndex < 0 || elementIndex >= n) {
     613    indexError(elementIndex, "setColumnUpper");
     614  }
     615#endif
     616  if (elementValue > 1.0e27)
     617    elementValue = COIN_DBL_MAX;
     618  columnUpper_[elementIndex] = elementValue;
     619  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    635620}
    636621
    637622/* Set a single column lower and upper bound */
    638 void
    639 ClpModel::setColumnBounds( int elementIndex,
    640                            double lower, double upper )
     623void ClpModel::setColumnBounds(int elementIndex,
     624  double lower, double upper)
    641625{
    642626#ifndef NDEBUG
    643      int n = numberColumns_;
    644      if (elementIndex < 0 || elementIndex >= n) {
    645           indexError(elementIndex, "setColumnBounds");
    646      }
    647 #endif
    648      if (lower < -1.0e27)
    649           lower = -COIN_DBL_MAX;
    650      if (upper > 1.0e27)
    651           upper = COIN_DBL_MAX;
    652      columnLower_[elementIndex] = lower;
    653      columnUpper_[elementIndex] = upper;
    654      CoinAssert (upper >= lower);
    655      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    656 }
    657 void ClpModel::setColumnSetBounds(const int* indexFirst,
    658                                   const int* indexLast,
    659                                   const double* boundList)
    660 {
    661      double * lower = columnLower_;
    662      double * upper = columnUpper_;
    663      whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     627  int n = numberColumns_;
     628  if (elementIndex < 0 || elementIndex >= n) {
     629    indexError(elementIndex, "setColumnBounds");
     630  }
     631#endif
     632  if (lower < -1.0e27)
     633    lower = -COIN_DBL_MAX;
     634  if (upper > 1.0e27)
     635    upper = COIN_DBL_MAX;
     636  columnLower_[elementIndex] = lower;
     637  columnUpper_[elementIndex] = upper;
     638  CoinAssert(upper >= lower);
     639  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
     640}
     641void ClpModel::setColumnSetBounds(const int *indexFirst,
     642  const int *indexLast,
     643  const double *boundList)
     644{
     645  double *lower = columnLower_;
     646  double *upper = columnUpper_;
     647  whatsChanged_ = 0; // Can't be sure (use ClpSimplex to keep)
    664648#ifndef NDEBUG
    665      int n = numberColumns_;
    666 #endif
    667      while (indexFirst != indexLast) {
    668           const int iColumn = *indexFirst++;
     649  int n = numberColumns_;
     650#endif
     651  while (indexFirst != indexLast) {
     652    const int iColumn = *indexFirst++;
    669653#ifndef NDEBUG
    670           if (iColumn < 0 || iColumn >= n) {
    671                indexError(iColumn, "setColumnSetBounds");
    672           }
    673 #endif
    674           lower[iColumn] = *boundList++;
    675           upper[iColumn] = *boundList++;
    676           CoinAssert (upper[iColumn] >= lower[iColumn]);
    677           if (lower[iColumn] < -1.0e27)
    678                lower[iColumn] = -COIN_DBL_MAX;
    679           if (upper[iColumn] > 1.0e27)
    680                upper[iColumn] = COIN_DBL_MAX;
    681      }
     654    if (iColumn < 0 || iColumn >= n) {
     655      indexError(iColumn, "setColumnSetBounds");
     656    }
     657#endif
     658    lower[iColumn] = *boundList++;
     659    upper[iColumn] = *boundList++;
     660    CoinAssert(upper[iColumn] >= lower[iColumn]);
     661    if (lower[iColumn] < -1.0e27)
     662      lower[iColumn] = -COIN_DBL_MAX;
     663    if (upper[iColumn] > 1.0e27)
     664      upper[iColumn] = COIN_DBL_MAX;
     665  }
    682666}
    683667//-----------------------------------------------------------------------------
    684668//#############################################################################
    685669// Copy constructor.
    686 ClpModel::ClpModel(const ClpModel &rhs, int scalingMode) :
    687      optimizationDirection_(rhs.optimizationDirection_),
    688      numberRows_(rhs.numberRows_),
    689      numberColumns_(rhs.numberColumns_),
    690      specialOptions_(rhs.specialOptions_),
    691      maximumColumns_(-1),
    692      maximumRows_(-1),
    693      maximumInternalColumns_(-1),
    694      maximumInternalRows_(-1),
    695      savedRowScale_(NULL),
    696      savedColumnScale_(NULL)
    697 {
    698      gutsOfCopy(rhs);
    699      if (scalingMode >= 0 && matrix_ &&
    700                matrix_->allElementsInRange(this, smallElement_, 1.0e20)) {
    701           // really do scaling
    702           scalingFlag_ = scalingMode;
    703           setRowScale(NULL);
    704           setColumnScale(NULL);
    705           delete rowCopy_; // in case odd
    706           rowCopy_ = NULL;
    707           delete scaledMatrix_;
    708           scaledMatrix_ = NULL;
    709           if (scalingMode && !matrix_->scale(this)) {
    710                // scaling worked - now apply
    711                inverseRowScale_ = rowScale_ + numberRows_;
    712                inverseColumnScale_ = columnScale_ + numberColumns_;
    713                gutsOfScaling();
    714                // pretend not scaled
    715                scalingFlag_ = -scalingFlag_;
    716           } else {
    717                // not scaled
    718                scalingFlag_ = 0;
    719           }
    720      }
    721      //randomNumberGenerator_.setSeed(1234567);
     670ClpModel::ClpModel(const ClpModel &rhs, int scalingMode)
     671  : optimizationDirection_(rhs.optimizationDirection_)
     672  , numberRows_(rhs.numberRows_)
     673  , numberColumns_(rhs.numberColumns_)
     674  , specialOptions_(rhs.specialOptions_)
     675  , maximumColumns_(-1)
     676  , maximumRows_(-1)
     677  , maximumInternalColumns_(-1)
     678  , maximumInternalRows_(-1)
     679  , savedRowScale_(NULL)
     680  , savedColumnScale_(NULL)
     681{
     682  gutsOfCopy(rhs);
     683  if (scalingMode >= 0 && matrix_ && matrix_->allElementsInRange(this, smallElement_, 1.0e20)) {
     684    // really do scaling
     685    scalingFlag_ = scalingMode;
     686    setRowScale(NULL);
     687    setColumnScale(NULL);
     688    delete rowCopy_; // in case odd
     689    rowCopy_ = NULL;
     690    delete scaledMatrix_;
     691    scaledMatrix_ = NULL;
     692    if (scalingMode && !matrix_->scale(this)) {
     693      // scaling worked - now apply
     694      inverseRowScale_ = rowScale_ + numberRows_;
     695      inverseColumnScale_ = columnScale_ + numberColumns_;
     696      gutsOfScaling();
     697      // pretend not scaled
     698      scalingFlag_ = -scalingFlag_;
     699    } else {
     700      // not scaled
     701      scalingFlag_ = 0;
     702    }
     703  }
     704  //randomNumberGenerator_.setSeed(1234567);
    722705}
    723706// Assignment operator. This copies the data
    724707ClpModel &
    725 ClpModel::operator=(const ClpModel & rhs)
    726 {
    727      if (this != &rhs) {
    728           if (defaultHandler_) {
    729                //delete handler_;
    730                //handler_ = NULL;
    731           }
    732           gutsOfDelete(1);
    733           optimizationDirection_ = rhs.optimizationDirection_;
    734           numberRows_ = rhs.numberRows_;
    735           numberColumns_ = rhs.numberColumns_;
    736           gutsOfCopy(rhs, -1);
    737      }
    738      return *this;
     708ClpModel::operator=(const ClpModel &rhs)
     709{
     710  if (this != &rhs) {
     711    if (defaultHandler_) {
     712      //delete handler_;
     713      //handler_ = NULL;
     714    }
     715    gutsOfDelete(1);
     716    optimizationDirection_ = rhs.optimizationDirection_;
     717    numberRows_ = rhs.numberRows_;
     718    numberColumns_ = rhs.numberColumns_;
     719    gutsOfCopy(rhs, -1);
     720  }
     721  return *this;
    739722}
    740723/* Does most of copying
    741724   If trueCopy 0 then just points to arrays
    742725   If -1 leaves as much as possible */
    743 void
    744 ClpModel::gutsOfCopy(const ClpModel & rhs, int trueCopy)
    745 {
    746      defaultHandler_ = rhs.defaultHandler_;
    747      randomNumberGenerator_ = rhs.randomNumberGenerator_;
    748      if (trueCopy >= 0) {
    749           if (defaultHandler_)
    750                handler_ = new CoinMessageHandler(*rhs.handler_);
    751           else
    752                handler_ = rhs.handler_;
    753           eventHandler_ = rhs.eventHandler_->clone();
    754           messages_ = rhs.messages_;
    755           coinMessages_ = rhs.coinMessages_;
    756      } else {
    757           if (!eventHandler_ && rhs.eventHandler_)
    758                eventHandler_ = rhs.eventHandler_->clone();
    759      }
    760      intParam_[ClpMaxNumIteration] = rhs.intParam_[ClpMaxNumIteration];
    761      intParam_[ClpMaxNumIterationHotStart] =
    762           rhs.intParam_[ClpMaxNumIterationHotStart];
    763      intParam_[ClpNameDiscipline] = rhs.intParam_[ClpNameDiscipline] ;
    764 
    765      dblParam_[ClpDualObjectiveLimit] = rhs.dblParam_[ClpDualObjectiveLimit];
    766      dblParam_[ClpPrimalObjectiveLimit] = rhs.dblParam_[ClpPrimalObjectiveLimit];
    767      dblParam_[ClpDualTolerance] = rhs.dblParam_[ClpDualTolerance];
    768      dblParam_[ClpPrimalTolerance] = rhs.dblParam_[ClpPrimalTolerance];
    769      dblParam_[ClpObjOffset] = rhs.dblParam_[ClpObjOffset];
    770      dblParam_[ClpMaxSeconds] = rhs.dblParam_[ClpMaxSeconds];
    771      dblParam_[ClpMaxWallSeconds] = rhs.dblParam_[ClpMaxWallSeconds];
    772      dblParam_[ClpPresolveTolerance] = rhs.dblParam_[ClpPresolveTolerance];
     726void ClpModel::gutsOfCopy(const ClpModel &rhs, int trueCopy)
     727{
     728  defaultHandler_ = rhs.defaultHandler_;
     729  randomNumberGenerator_ = rhs.randomNumberGenerator_;
     730  if (trueCopy >= 0) {
     731    if (defaultHandler_)
     732      handler_ = new CoinMessageHandler(*rhs.handler_);
     733    else
     734      handler_ = rhs.handler_;
     735    eventHandler_ = rhs.eventHandler_->clone();
     736    messages_ = rhs.messages_;
     737    coinMessages_ = rhs.coinMessages_;
     738  } else {
     739    if (!eventHandler_ && rhs.eventHandler_)
     740      eventHandler_ = rhs.eventHandler_->clone();
     741  }
     742  intParam_[ClpMaxNumIteration] = rhs.intParam_[ClpMaxNumIteration];
     743  intParam_[ClpMaxNumIterationHotStart] = rhs.intParam_[ClpMaxNumIterationHotStart];
     744  intParam_[ClpNameDiscipline] = rhs.intParam_[ClpNameDiscipline];
     745
     746  dblParam_[ClpDualObjectiveLimit] = rhs.dblParam_[ClpDualObjectiveLimit];
     747  dblParam_[ClpPrimalObjectiveLimit] = rhs.dblParam_[ClpPrimalObjectiveLimit];
     748  dblParam_[ClpDualTolerance] = rhs.dblParam_[ClpDualTolerance];
     749  dblParam_[ClpPrimalTolerance] = rhs.dblParam_[ClpPrimalTolerance];
     750  dblParam_[ClpObjOffset] = rhs.dblParam_[ClpObjOffset];
     751  dblParam_[ClpMaxSeconds] = rhs.dblParam_[ClpMaxSeconds];
     752  dblParam_[ClpMaxWallSeconds] = rhs.dblParam_[ClpMaxWallSeconds];
     753  dblParam_[ClpPresolveTolerance] = rhs.dblParam_[ClpPresolveTolerance];
    773754#ifndef CLP_NO_STD
    774755
    775      strParam_[ClpProbName] = rhs.strParam_[ClpProbName];
    776 #endif
    777 
    778      optimizationDirection_ = rhs.optimizationDirection_;
    779      objectiveValue_ = rhs.objectiveValue_;
    780      smallElement_ = rhs.smallElement_;
    781      objectiveScale_ = rhs.objectiveScale_;
    782      rhsScale_ = rhs.rhsScale_;
    783      numberIterations_ = rhs.numberIterations_;
    784      solveType_ = rhs.solveType_;
    785      whatsChanged_ = rhs.whatsChanged_;
    786      problemStatus_ = rhs.problemStatus_;
    787      secondaryStatus_ = rhs.secondaryStatus_;
    788      numberRows_ = rhs.numberRows_;
    789      numberColumns_ = rhs.numberColumns_;
    790      userPointer_ = rhs.userPointer_;
    791      trustedUserPointer_ = rhs.trustedUserPointer_;
    792      scalingFlag_ = rhs.scalingFlag_;
    793      specialOptions_ = rhs.specialOptions_;
    794      if (trueCopy) {
     756  strParam_[ClpProbName] = rhs.strParam_[ClpProbName];
     757#endif
     758
     759  optimizationDirection_ = rhs.optimizationDirection_;
     760  objectiveValue_ = rhs.objectiveValue_;
     761  smallElement_ = rhs.smallElement_;
     762  objectiveScale_ = rhs.objectiveScale_;
     763  rhsScale_ = rhs.rhsScale_;
     764  numberIterations_ = rhs.numberIterations_;
     765  solveType_ = rhs.solveType_;
     766  whatsChanged_ = rhs.whatsChanged_;
     767  problemStatus_ = rhs.problemStatus_;
     768  secondaryStatus_ = rhs.secondaryStatus_;
     769  numberRows_ = rhs.numberRows_;
     770  numberColumns_ = rhs.numberColumns_;
     771  userPointer_ = rhs.userPointer_;
     772  trustedUserPointer_ = rhs.trustedUserPointer_;
     773  scalingFlag_ = rhs.scalingFlag_;
     774  specialOptions_ = rhs.specialOptions_;
     775  if (trueCopy) {
    795776#ifndef CLP_NO_STD
    796           lengthNames_ = rhs.lengthNames_;
    797           if (lengthNames_) {
    798                rowNames_ = rhs.rowNames_;
    799                columnNames_ = rhs.columnNames_;
    800           }
    801 #endif
    802           numberThreads_ = rhs.numberThreads_;
    803           if (maximumRows_ < 0) {
    804                specialOptions_ &= ~65536;
    805                savedRowScale_ = NULL;
    806                savedColumnScale_ = NULL;
    807                integerType_ = CoinCopyOfArray(rhs.integerType_, numberColumns_);
    808                rowActivity_ = ClpCopyOfArray(rhs.rowActivity_, numberRows_);
    809                columnActivity_ = ClpCopyOfArray(rhs.columnActivity_, numberColumns_);
    810                dual_ = ClpCopyOfArray(rhs.dual_, numberRows_);
    811                reducedCost_ = ClpCopyOfArray(rhs.reducedCost_, numberColumns_);
    812                rowLower_ = ClpCopyOfArray ( rhs.rowLower_, numberRows_ );
    813                rowUpper_ = ClpCopyOfArray ( rhs.rowUpper_, numberRows_ );
    814                columnLower_ = ClpCopyOfArray ( rhs.columnLower_, numberColumns_ );
    815                columnUpper_ = ClpCopyOfArray ( rhs.columnUpper_, numberColumns_ );
    816                rowScale_ = ClpCopyOfArray(rhs.rowScale_, numberRows_ * 2);
    817                columnScale_ = ClpCopyOfArray(rhs.columnScale_, numberColumns_ * 2);
    818                if (rhs.objective_)
    819                     objective_ = rhs.objective_->clone();
    820                else
    821                     objective_ = NULL;
    822                rowObjective_ = ClpCopyOfArray ( rhs.rowObjective_, numberRows_ );
    823                status_ = ClpCopyOfArray( rhs.status_, numberColumns_ + numberRows_);
    824                ray_ = NULL;
    825                if (problemStatus_ == 1)
    826                     ray_ = ClpCopyOfArray (rhs.ray_, numberRows_);
    827                else if (problemStatus_ == 2)
    828                     ray_ = ClpCopyOfArray (rhs.ray_, numberColumns_);
    829                if (rhs.rowCopy_) {
    830                     rowCopy_ = rhs.rowCopy_->clone();
    831                } else {
    832                     rowCopy_ = NULL;
    833                }
    834                if (rhs.scaledMatrix_) {
    835                     scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
    836                } else {
    837                     scaledMatrix_ = NULL;
    838                }
    839                matrix_ = NULL;
    840                if (rhs.matrix_) {
    841                     matrix_ = rhs.matrix_->clone();
    842                }
    843           } else {
    844                // This already has arrays - just copy
    845                savedRowScale_ = NULL;
    846                savedColumnScale_ = NULL;
    847                startPermanentArrays();
    848                if (rhs.integerType_) {
    849                     assert (integerType_);
    850                     ClpDisjointCopyN(rhs.integerType_, numberColumns_, integerType_);
    851                } else {
    852                     integerType_ = NULL;
    853                }
    854                if (rhs.rowActivity_) {
    855                     ClpDisjointCopyN ( rhs.rowActivity_, numberRows_ ,
    856                                        rowActivity_);
    857                     ClpDisjointCopyN ( rhs.columnActivity_, numberColumns_ ,
    858                                        columnActivity_);
    859                     ClpDisjointCopyN ( rhs.dual_, numberRows_ ,
    860                                        dual_);
    861                     ClpDisjointCopyN ( rhs.reducedCost_, numberColumns_ ,
    862                                        reducedCost_);
    863                } else {
    864                     rowActivity_ = NULL;
    865                     columnActivity_ = NULL;
    866                     dual_ = NULL;
    867                     reducedCost_ = NULL;
    868                }
    869                ClpDisjointCopyN ( rhs.rowLower_, numberRows_, rowLower_ );
    870                ClpDisjointCopyN ( rhs.rowUpper_, numberRows_, rowUpper_ );
    871                ClpDisjointCopyN ( rhs.columnLower_, numberColumns_, columnLower_ );
    872                assert ((specialOptions_ & 131072) == 0);
    873                abort();
    874                ClpDisjointCopyN ( rhs.columnUpper_, numberColumns_, columnUpper_ );
    875                if (rhs.objective_) {
    876                     abort(); //check if same
    877                     objective_ = rhs.objective_->clone();
    878                } else {
    879                     objective_ = NULL;
    880                }
    881                assert (!rhs.rowObjective_);
    882                ClpDisjointCopyN( rhs.status_, numberColumns_ + numberRows_, status_);
    883                ray_ = NULL;
    884                if (problemStatus_ == 1)
    885                     ray_ = ClpCopyOfArray (rhs.ray_, numberRows_);
    886                else if (problemStatus_ == 2)
    887                     ray_ = ClpCopyOfArray (rhs.ray_, numberColumns_);
    888                assert (!ray_);
    889                delete rowCopy_;
    890                if (rhs.rowCopy_) {
    891                     rowCopy_ = rhs.rowCopy_->clone();
    892                } else {
    893                     rowCopy_ = NULL;
    894                }
    895                delete scaledMatrix_;
    896                if (rhs.scaledMatrix_) {
    897                     scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
    898                } else {
    899                     scaledMatrix_ = NULL;
    900                }
    901                delete matrix_;
    902                matrix_ = NULL;
    903                if (rhs.matrix_) {
    904                     matrix_ = rhs.matrix_->clone();
    905                }
    906                if (rhs.savedRowScale_) {
    907                     assert (savedRowScale_);
    908                     assert (!rowScale_);
    909                     ClpDisjointCopyN(rhs.savedRowScale_, 4 * maximumInternalRows_, savedRowScale_);
    910                     ClpDisjointCopyN(rhs.savedColumnScale_, 4 * maximumInternalColumns_, savedColumnScale_);
    911                } else {
    912                     assert (!savedRowScale_);
    913                     if (rowScale_) {
    914                          ClpDisjointCopyN(rhs.rowScale_, numberRows_, rowScale_);
    915                          ClpDisjointCopyN(rhs.columnScale_, numberColumns_, columnScale_);
    916                     } else {
    917                          rowScale_ = NULL;
    918                          columnScale_ = NULL;
    919                     }
    920                }
    921                abort(); // look at resizeDouble and resize
    922           }
    923      } else {
    924           savedRowScale_ = rhs.savedRowScale_;
    925           assert (!savedRowScale_);
    926           savedColumnScale_ = rhs.savedColumnScale_;
    927           rowActivity_ = rhs.rowActivity_;
    928           columnActivity_ = rhs.columnActivity_;
    929           dual_ = rhs.dual_;
    930           reducedCost_ = rhs.reducedCost_;
    931           rowLower_ = rhs.rowLower_;
    932           rowUpper_ = rhs.rowUpper_;
    933           objective_ = rhs.objective_;
    934           rowObjective_ = rhs.rowObjective_;
    935           columnLower_ = rhs.columnLower_;
    936           columnUpper_ = rhs.columnUpper_;
    937           matrix_ = rhs.matrix_;
    938           rowCopy_ = NULL;
    939           scaledMatrix_ = NULL;
    940           ray_ = rhs.ray_;
    941           //rowScale_ = rhs.rowScale_;
    942           //columnScale_ = rhs.columnScale_;
    943           lengthNames_ = 0;
    944           numberThreads_ = rhs.numberThreads_;
     777    lengthNames_ = rhs.lengthNames_;
     778    if (lengthNames_) {
     779      rowNames_ = rhs.rowNames_;
     780      columnNames_ = rhs.columnNames_;
     781    }
     782#endif
     783    numberThreads_ = rhs.numberThreads_;
     784    if (maximumRows_ < 0) {
     785      specialOptions_ &= ~65536;
     786      savedRowScale_ = NULL;
     787      savedColumnScale_ = NULL;
     788      integerType_ = CoinCopyOfArray(rhs.integerType_, numberColumns_);
     789      rowActivity_ = ClpCopyOfArray(rhs.rowActivity_, numberRows_);
     790      columnActivity_ = ClpCopyOfArray(rhs.columnActivity_, numberColumns_);
     791      dual_ = ClpCopyOfArray(rhs.dual_, numberRows_);
     792      reducedCost_ = ClpCopyOfArray(rhs.reducedCost_, numberColumns_);
     793      rowLower_ = ClpCopyOfArray(rhs.rowLower_, numberRows_);
     794      rowUpper_ = ClpCopyOfArray(rhs.rowUpper_, numberRows_);
     795      columnLower_ = ClpCopyOfArray(rhs.columnLower_, numberColumns_);
     796      columnUpper_ = ClpCopyOfArray(rhs.columnUpper_, numberColumns_);
     797      rowScale_ = ClpCopyOfArray(rhs.rowScale_, numberRows_ * 2);
     798      columnScale_ = ClpCopyOfArray(rhs.columnScale_, numberColumns_ * 2);
     799      if (rhs.objective_)
     800        objective_ = rhs.objective_->clone();
     801      else
     802        objective_ = NULL;
     803      rowObjective_ = ClpCopyOfArray(rhs.rowObjective_, numberRows_);
     804      status_ = ClpCopyOfArray(rhs.status_, numberColumns_ + numberRows_);
     805      ray_ = NULL;
     806      if (problemStatus_ == 1)
     807        ray_ = ClpCopyOfArray(rhs.ray_, numberRows_);
     808      else if (problemStatus_ == 2)
     809        ray_ = ClpCopyOfArray(rhs.ray_, numberColumns_);
     810      if (rhs.rowCopy_) {
     811        rowCopy_ = rhs.rowCopy_->clone();
     812      } else {
     813        rowCopy_ = NULL;
     814      }
     815      if (rhs.scaledMatrix_) {
     816        scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
     817      } else {
     818        scaledMatrix_ = NULL;
     819      }
     820      matrix_ = NULL;
     821      if (rhs.matrix_) {
     822        matrix_ = rhs.matrix_->clone();
     823      }
     824    } else {
     825      // This already has arrays - just copy
     826      savedRowScale_ = NULL;
     827      savedColumnScale_ = NULL;
     828      startPermanentArrays();
     829      if (rhs.integerType_) {
     830        assert(integerType_);
     831        ClpDisjointCopyN(rhs.integerType_, numberColumns_, integerType_);
     832      } else {
     833        integerType_ = NULL;
     834      }
     835      if (rhs.rowActivity_) {
     836        ClpDisjointCopyN(rhs.rowActivity_, numberRows_,
     837          rowActivity_);
     838        ClpDisjointCopyN(rhs.columnActivity_, numberColumns_,
     839          columnActivity_);
     840        ClpDisjointCopyN(rhs.dual_, numberRows_,
     841          dual_);
     842        ClpDisjointCopyN(rhs.reducedCost_, numberColumns_,
     843          reducedCost_);
     844      } else {
     845        rowActivity_ = NULL;
     846        columnActivity_ = NULL;
     847        dual_ = NULL;
     848        reducedCost_ = NULL;
     849      }
     850      ClpDisjointCopyN(rhs.rowLower_, numberRows_, rowLower_);
     851      ClpDisjointCopyN(rhs.rowUpper_, numberRows_, rowUpper_);
     852      ClpDisjointCopyN(rhs.columnLower_, numberColumns_, columnLower_);
     853      assert((specialOptions_ & 131072) == 0);
     854      abort();
     855      ClpDisjointCopyN(rhs.columnUpper_, numberColumns_, columnUpper_);
     856      if (rhs.objective_) {
     857        abort(); //check if same
     858        objective_ = rhs.objective_->clone();
     859      } else {
     860        objective_ = NULL;
     861      }
     862      assert(!rhs.rowObjective_);
     863      ClpDisjointCopyN(rhs.status_, numberColumns_ + numberRows_, status_);
     864      ray_ = NULL;
     865      if (problemStatus_ == 1)
     866        ray_ = ClpCopyOfArray(rhs.ray_, numberRows_);
     867      else if (problemStatus_ == 2)
     868        ray_ = ClpCopyOfArray(rhs.ray_, numberColumns_);
     869      assert(!ray_);
     870      delete rowCopy_;
     871      if (rhs.rowCopy_) {
     872        rowCopy_ = rhs.rowCopy_->clone();
     873      } else {
     874        rowCopy_ = NULL;
     875      }
     876      delete scaledMatrix_;
     877      if (rhs.scaledMatrix_) {
     878        scaledMatrix_ = new ClpPackedMatrix(*rhs.scaledMatrix_);
     879      } else {
     880        scaledMatrix_ = NULL;
     881      }
     882      delete matrix_;
     883      matrix_ = NULL;
     884      if (rhs.matrix_) {
     885        matrix_ = rhs.matrix_->clone();
     886      }
     887      if (rhs.savedRowScale_) {
     888        assert(savedRowScale_);
     889        assert(!rowScale_);
     890        ClpDisjointCopyN(rhs.savedRowScale_, 4 * maximumInternalRows_, savedRowScale_);
     891        ClpDisjointCopyN(rhs.savedColumnScale_, 4 * maximumInternalColumns_, savedColumnScale_);
     892      } else {
     893        assert(!savedRowScale_);
     894        if (rowScale_) {
     895          ClpDisjointCopyN(rhs.rowScale_, numberRows_, rowScale_);
     896          ClpDisjointCopyN(rhs.columnScale_, numberColumns_, columnScale_);
     897        } else {
     898          rowScale_ = NULL;
     899          columnScale_ = NULL;
     900        }
     901      }
     902      abort(); // look at resizeDouble and resize
     903    }
     904  } else {
     905    savedRowScale_ = rhs.savedRowScale_;
     906    assert(!savedRowScale_);
     907    savedColumnScale_ = rhs.savedColumnScale_;
     908    rowActivity_ = rhs.rowActivity_;
     909    columnActivity_ = rhs.columnActivity_;
     910    dual_ = rhs.dual_;
     911    reducedCost_ = rhs.reducedCost_;
     912    rowLower_ = rhs.rowLower_;
     913    rowUpper_ = rhs.rowUpper_;
     914    objective_ = rhs.objective_;
     915    rowObjective_ = rhs.rowObjective_;
     916    columnLower_ = rhs.columnLower_;
     917    columnUpper_ = rhs.columnUpper_;
     918    matrix_ = rhs.matrix_;
     919    rowCopy_ = NULL;
     920    scaledMatrix_ = NULL;
     921    ray_ = rhs.ray_;
     922    //rowScale_ = rhs.rowScale_;
     923    //columnScale_ = rhs.columnScale_;
     924    lengthNames_ = 0;
     925    numberThreads_ = rhs.numberThreads_;
    945926#ifndef CLP_NO_STD
    946           rowNames_ = std::vector<std::string> ();
    947           columnNames_ = std::vector<std::string> ();
    948 #endif
    949           integerType_ = NULL;
    950           status_ = rhs.status_;
    951      }
    952      inverseRowScale_ = NULL;
    953      inverseColumnScale_ = NULL;
     927    rowNames_ = std::vector< std::string >();
     928    columnNames_ = std::vector< std::string >();
     929#endif
     930    integerType_ = NULL;
     931    status_ = rhs.status_;
     932  }
     933  inverseRowScale_ = NULL;
     934  inverseColumnScale_ = NULL;
    954935}
    955936// Copy contents - resizing if necessary - otherwise re-use memory
    956 void
    957 ClpModel::copy(const ClpMatrixBase * from, ClpMatrixBase * & to)
    958 {
    959      assert (from);
    960      const ClpPackedMatrix * matrixFrom = (dynamic_cast<const ClpPackedMatrix*>(from));
    961      ClpPackedMatrix * matrixTo = (dynamic_cast< ClpPackedMatrix*>(to));
    962      if (matrixFrom && matrixTo) {
    963           matrixTo->copy(matrixFrom);
    964      } else {
    965           delete to;
    966           to =  from->clone();
    967      }
     937void ClpModel::copy(const ClpMatrixBase *from, ClpMatrixBase *&to)
     938{
     939  assert(from);
     940  const ClpPackedMatrix *matrixFrom = (dynamic_cast< const ClpPackedMatrix * >(from));
     941  ClpPackedMatrix *matrixTo = (dynamic_cast< ClpPackedMatrix * >(to));
     942  if (matrixFrom && matrixTo) {
     943    matrixTo->copy(matrixFrom);
     944  } else {
     945    delete to;
     946    to = from->clone();
     947  }
    968948#if 0
    969949     delete modelPtr_->matrix_;
     
    978958   of data around.  It assumes a derived class wants to overwrite
    979959   an empty model with a real one - while it does an algorithm */
    980 void
    981 ClpModel::borrowModel(ClpModel & rhs)
    982 {
    983      if (defaultHandler_) {
    984           delete handler_;
    985           handler_ = NULL;
    986      }
    987      gutsOfDelete(1);
    988      optimizationDirection_ = rhs.optimizationDirection_;
    989      numberRows_ = rhs.numberRows_;
    990      numberColumns_ = rhs.numberColumns_;
    991      delete [] rhs.ray_;
    992      rhs.ray_ = NULL;
    993      // make sure scaled matrix not copied
    994      ClpPackedMatrix * save = rhs.scaledMatrix_;
    995      rhs.scaledMatrix_ = NULL;
    996      delete scaledMatrix_;
    997      scaledMatrix_ = NULL;
    998      gutsOfCopy(rhs, 0);
    999      rhs.scaledMatrix_ = save;
    1000      specialOptions_ = rhs.specialOptions_ & ~65536;
    1001      savedRowScale_ = NULL;
    1002      savedColumnScale_ = NULL;
    1003      inverseRowScale_ = NULL;
    1004      inverseColumnScale_ = NULL;
     960void ClpModel::borrowModel(ClpModel &rhs)
     961{
     962  if (defaultHandler_) {
     963    delete handler_;
     964    handler_ = NULL;
     965  }
     966  gutsOfDelete(1);
     967  optimizationDirection_ = rhs.optimizationDirection_;
     968  numberRows_ = rhs.numberRows_;
     969  numberColumns_ = rhs.numberColumns_;
     970  delete[] rhs.ray_;
     971  rhs.ray_ = NULL;
     972  // make sure scaled matrix not copied
     973  ClpPackedMatrix *save = rhs.scaledMatrix_;
     974  rhs.scaledMatrix_ = NULL;
     975  delete scaledMatrix_;
     976  scaledMatrix_ = NULL;
     977  gutsOfCopy(rhs, 0);
     978  rhs.scaledMatrix_ = save;
     979  specialOptions_ = rhs.specialOptions_ & ~65536;
     980  savedRowScale_ = NULL;
     981  savedColumnScale_ = NULL;
     982  inverseRowScale_ = NULL;
     983  inverseColumnScale_ = NULL;
    1005984}
    1006985// Return model - nulls all arrays so can be deleted safely
    1007 void
    1008 ClpModel::returnModel(ClpModel & otherModel)
    1009 {
    1010      otherModel.objectiveValue_ = objectiveValue_;
    1011      otherModel.numberIterations_ = numberIterations_;
    1012      otherModel.problemStatus_ = problemStatus_;
    1013      otherModel.secondaryStatus_ = secondaryStatus_;
    1014      rowActivity_ = NULL;
    1015      columnActivity_ = NULL;
    1016      dual_ = NULL;
    1017      reducedCost_ = NULL;
    1018      rowLower_ = NULL;
    1019      rowUpper_ = NULL;
    1020      objective_ = NULL;
    1021      rowObjective_ = NULL;
    1022      columnLower_ = NULL;
    1023      columnUpper_ = NULL;
    1024      matrix_ = NULL;
    1025      if (rowCopy_ != otherModel.rowCopy_)
    1026        delete rowCopy_;
    1027      rowCopy_ = NULL;
    1028      delete scaledMatrix_;
    1029      scaledMatrix_ = NULL;
    1030      delete [] otherModel.ray_;
    1031      otherModel.ray_ = ray_;
    1032      ray_ = NULL;
    1033      if (rowScale_ && otherModel.rowScale_ != rowScale_) {
    1034           delete [] rowScale_;
    1035           delete [] columnScale_;
    1036      }
    1037      rowScale_ = NULL;
    1038      columnScale_ = NULL;
    1039      //rowScale_=NULL;
    1040      //columnScale_=NULL;
    1041      // do status
    1042      if (otherModel.status_ != status_) {
    1043           delete [] otherModel.status_;
    1044           otherModel.status_ = status_;
    1045      }
    1046      status_ = NULL;
    1047      if (defaultHandler_) {
    1048           delete handler_;
    1049           handler_ = NULL;
    1050      }
    1051      inverseRowScale_ = NULL;
    1052      inverseColumnScale_ = NULL;
     986void ClpModel::returnModel(ClpModel &otherModel)
     987{
     988  otherModel.objectiveValue_ = objectiveValue_;
     989  otherModel.numberIterations_ = numberIterations_;
     990  otherModel.problemStatus_ = problemStatus_;
     991  otherModel.secondaryStatus_ = secondaryStatus_;
     992  rowActivity_ = NULL;
     993  columnActivity_ = NULL;
     994  dual_ = NULL;
     995  reducedCost_ = NULL;
     996  rowLower_ = NULL;
     997  rowUpper_ = NULL;
     998  objective_ = NULL;
     999  rowObjective_ = NULL;
     1000  columnLower_ = NULL;
     1001  columnUpper_ = NULL;
     1002  matrix_ = NULL;
     1003  if (rowCopy_ != otherModel.rowCopy_)
     1004    delete rowCopy_;
     1005  rowCopy_ = NULL;
     1006  delete scaledMatrix_;
     1007  scaledMatrix_ = NULL;
     1008  delete[] otherModel.ray_;
     1009  otherModel.ray_ = ray_;
     1010  ray_ = NULL;
     1011  if (rowScale_ && otherModel.rowScale_ != rowScale_) {
     1012    delete[] rowScale_;
     1013    delete[] columnScale_;
     1014  }
     1015  rowScale_ = NULL;
     1016  columnScale_ = NULL;
     1017  //rowScale_=NULL;
     1018  //columnScale_=NULL;
     1019  // do status
     1020  if (otherModel.status_ != status_) {
     1021    delete[] otherModel.status_;
     1022    otherModel.status_ = status_;
     1023  }
     1024  status_ = NULL;
     1025  if (defaultHandler_) {
     1026    delete handler_;
     1027    handler_ = NULL;
     1028  }
     1029  inverseRowScale_ = NULL;
     1030  inverseColumnScale_ = NULL;
    10531031}
    10541032//#############################################################################
     
    10561034//#############################################################################
    10571035
    1058 bool
    1059 ClpModel::setIntParam(ClpIntParam key, int value)
    1060 {
    1061      switch (key) {
    1062      case ClpMaxNumIteration:
    1063           if (value < 0)
    1064                return false;
    1065           break;
    1066      case ClpMaxNumIterationHotStart:
    1067           if (value < 0)
    1068                return false;
    1069           break;
    1070      case ClpNameDiscipline:
    1071           if (value < 0)
    1072                return false;
    1073           break;
    1074      default:
    1075           return false;
    1076      }
    1077      intParam_[key] = value;
    1078      return true;
     1036bool ClpModel::setIntParam(ClpIntParam key, int value)
     1037{
     1038  switch (key) {
     1039  case ClpMaxNumIteration:
     1040    if (value < 0)
     1041      return false;
     1042    break;
     1043  case ClpMaxNumIterationHotStart:
     1044    if (value < 0)
     1045      return false;
     1046    break;
     1047  case ClpNameDiscipline:
     1048    if (value < 0)
     1049      return false;
     1050    break;
     1051  default:
     1052    return false;
     1053  }
     1054  intParam_[key] = value;
     1055  return true;
    10791056}
    10801057
    10811058//-----------------------------------------------------------------------------
    10821059
    1083 bool
    1084 ClpModel::setDblParam(ClpDblParam key, double value)
    1085 {
    1086 
    1087      switch (key) {
    1088      case ClpDualObjectiveLimit:
    1089           break;
    1090 
    1091      case ClpPrimalObjectiveLimit:
    1092           break;
    1093 
    1094      case ClpDualTolerance:
    1095           if (value <= 0.0 || value > 1.0e10)
    1096                return false;
    1097           break;
    1098 
    1099      case ClpPrimalTolerance:
    1100           if (value <= 0.0 || value > 1.0e10)
    1101                return false;
    1102           break;
    1103 
    1104      case ClpObjOffset:
    1105           break;
    1106 
    1107      case ClpMaxSeconds:
    1108           if(value >= 0)
    1109                value += CoinCpuTime();
    1110           else
    1111                value = -1.0;
    1112           break;
    1113 
    1114      case ClpMaxWallSeconds:
    1115           if(value >= 0)
    1116                value += CoinWallclockTime();
    1117           else
    1118                value = -1.0;
    1119           break;
    1120 
    1121      case ClpPresolveTolerance:
    1122           if (value <= 0.0 || value > 1.0e10)
    1123                return false;
    1124           break;
    1125 
    1126      default:
    1127           return false;
    1128      }
    1129      dblParam_[key] = value;
    1130      return true;
     1060bool ClpModel::setDblParam(ClpDblParam key, double value)
     1061{
     1062
     1063  switch (key) {
     1064  case ClpDualObjectiveLimit:
     1065    break;
     1066
     1067  case ClpPrimalObjectiveLimit:
     1068    break;
     1069
     1070  case ClpDualTolerance:
     1071    if (value <= 0.0 || value > 1.0e10)
     1072      return false;
     1073    break;
     1074
     1075  case ClpPrimalTolerance:
     1076    if (value <= 0.0 || value > 1.0e10)
     1077      return false;
     1078    break;
     1079
     1080  case ClpObjOffset:
     1081    break;
     1082
     1083  case ClpMaxSeconds:
     1084    if (value >= 0)
     1085      value += CoinCpuTime();
     1086    else
     1087      value = -1.0;
     1088    break;
     1089
     1090  case ClpMaxWallSeconds:
     1091    if (value >= 0)
     1092      value += CoinWallclockTime();
     1093    else
     1094      value = -1.0;
     1095    break;
     1096
     1097  case ClpPresolveTolerance:
     1098    if (value <= 0.0 || value > 1.0e10)
     1099      return false;
     1100    break;
     1101
     1102  default:
     1103    return false;
     1104  }
     1105  dblParam_[key] = value;
     1106  return true;
    11311107}
    11321108
     
    11341110#ifndef CLP_NO_STD
    11351111
    1136 bool
    1137 ClpModel::setStrParam(ClpStrParam key, const std::string & value)
    1138 {
    1139 
    1140      switch (key) {
    1141      case ClpProbName:
    1142           break;
    1143 
    1144      default:
    1145           return false;
    1146      }
    1147      strParam_[key] = value;
    1148      return true;
     1112bool ClpModel::setStrParam(ClpStrParam key, const std::string &value)
     1113{
     1114
     1115  switch (key) {
     1116  case ClpProbName:
     1117    break;
     1118
     1119  default:
     1120    return false;
     1121  }
     1122  strParam_[key] = value;
     1123  return true;
    11491124}
    11501125#endif
    11511126// Useful routines
    11521127// Returns resized array and deletes incoming
    1153 double * resizeDouble(double * array , int size, int newSize, double fill,
    1154                       bool createArray)
    1155 {
    1156      if ((array || createArray) && size < newSize) {
    1157           int i;
    1158           double * newArray = new double[newSize];
    1159           if (array)
    1160                CoinMemcpyN(array, CoinMin(newSize, size), newArray);
    1161           delete [] array;
    1162           array = newArray;
    1163           for (i = size; i < newSize; i++)
    1164                array[i] = fill;
    1165      }
    1166      return array;
     1128double *resizeDouble(double *array, int size, int newSize, double fill,
     1129  bool createArray)
     1130{
     1131  if ((array || createArray) && size < newSize) {
     1132    int i;
     1133    double *newArray = new double[newSize];
     1134    if (array)
     1135      CoinMemcpyN(array, CoinMin(newSize, size), newArray);
     1136    delete[] array;
     1137    array = newArray;
     1138    for (i = size; i < newSize; i++)
     1139      array[i] = fill;
     1140  }
     1141  return array;
    11671142}
    11681143// Returns resized array and updates size
    1169 double * deleteDouble(double * array , int size,
    1170                       int number, const int * which, int & newSize)
    1171 {
    1172      if (array) {
    1173           int i ;
    1174           char * deleted = new char[size];
    1175           int numberDeleted = 0;
    1176           CoinZeroN(deleted, size);
    1177           for (i = 0; i < number; i++) {
    1178                int j = which[i];
    1179                if (j >= 0 && j < size && !deleted[j]) {
    1180                     numberDeleted++;
    1181                     deleted[j] = 1;
    1182                }
    1183           }
    1184           newSize = size - numberDeleted;
    1185           double * newArray = new double[newSize];
    1186           int put = 0;
    1187           for (i = 0; i < size; i++) {
    1188                if (!deleted[i]) {
    1189                     newArray[put++] = array[i];
    1190                }
    1191           }
    1192           delete [] array;
    1193           array = newArray;
    1194           delete [] deleted;
    1195      }
    1196      return array;
    1197 }
    1198 char * deleteChar(char * array , int size,
    1199                   int number, const int * which, int & newSize,
    1200                   bool ifDelete)
    1201 {
    1202      if (array) {
    1203           int i ;
    1204           char * deleted = new char[size];
    1205           int numberDeleted = 0;
    1206           CoinZeroN(deleted, size);
    1207           for (i = 0; i < number; i++) {
    1208                int j = which[i];
    1209                if (j >= 0 && j < size && !deleted[j]) {
    1210                     numberDeleted++;
    1211                     deleted[j] = 1;
    1212                }
    1213           }
    1214           newSize = size - numberDeleted;
    1215           char * newArray = new char[newSize];
    1216           int put = 0;
    1217           for (i = 0; i < size; i++) {
    1218                if (!deleted[i]) {
    1219                     newArray[put++] = array[i];
    1220                }
    1221           }
    1222           if (ifDelete)
    1223                delete [] array;
    1224           array = newArray;
    1225           delete [] deleted;
    1226      }
    1227      return array;
     1144double *deleteDouble(double *array, int size,
     1145  int number, const int *which, int &newSize)
     1146{
     1147  if (array) {
     1148    int i;
     1149    char *deleted = new char[size];
     1150    int numberDeleted = 0;
     1151    CoinZeroN(deleted, size);
     1152    for (i = 0; i < number; i++) {
     1153      int j = which[i];
     1154      if (j >= 0 && j < size && !deleted[j]) {
     1155        numberDeleted++;
     1156        deleted[j] = 1;
     1157      }
     1158    }
     1159    newSize = size - numberDeleted;
     1160    double *newArray = new double[newSize];
     1161    int put = 0;
     1162    for (i = 0; i < size; i++) {
     1163      if (!deleted[i]) {
     1164        newArray[put++] = array[i];
     1165      }
     1166    }
     1167    delete[] array;
     1168    array = newArray;
     1169    delete[] deleted;
     1170  }
     1171  return array;
     1172}
     1173char *deleteChar(char *array, int size,
     1174  int number, const int *which, int &newSize,
     1175  bool ifDelete)
     1176{
     1177  if (array) {
     1178    int i;
     1179    char *deleted = new char[size];
     1180    int numberDeleted = 0;
     1181    CoinZeroN(deleted, size);
     1182    for (i = 0; i < number; i++) {
     1183      int j = which[i];
     1184      if (j >= 0 && j < size && !deleted[j]) {
     1185        numberDeleted++;
     1186        deleted[j] = 1;
     1187      }
     1188    }
     1189    newSize = size - numberDeleted;
     1190    char *newArray = new char[newSize];
     1191    int put = 0;
     1192    for (i = 0; i < size; i++) {
     1193      if (!deleted[i]) {
     1194        newArray[put++] = array[i];
     1195      }
     1196    }
     1197    if (ifDelete)
     1198      delete[] array;
     1199    array = newArray;
     1200    delete[] deleted;
     1201  }
     1202  return array;
    12281203}
    12291204// Create empty ClpPackedMatrix
    1230 void
    1231 ClpModel::createEmptyMatrix()
    1232 {
    1233      delete matrix_;
    1234      whatsChanged_ = 0;
    1235      CoinPackedMatrix matrix2;
    1236      matrix_ = new ClpPackedMatrix(matrix2);
     1205void ClpModel::createEmptyMatrix()
     1206{
     1207  delete matrix_;
     1208  whatsChanged_ = 0;
     1209  CoinPackedMatrix matrix2;
     1210  matrix_ = new ClpPackedMatrix(matrix2);
    12371211}
    12381212/* Really clean up matrix.
     
    12461220ClpModel::cleanMatrix(double threshold)
    12471221{
    1248      ClpPackedMatrix * matrix = (dynamic_cast< ClpPackedMatrix*>(matrix_));
    1249      if (matrix) {
    1250           return matrix->getPackedMatrix()->cleanMatrix(threshold);
    1251      } else {
    1252           return -1;
    1253      }
     1222  ClpPackedMatrix *matrix = (dynamic_cast< ClpPackedMatrix * >(matrix_));
     1223  if (matrix) {
     1224    return matrix->getPackedMatrix()->cleanMatrix(threshold);
     1225  } else {
     1226    return -1;
     1227  }
    12541228}
    12551229// Resizes
    1256 void
    1257 ClpModel::resize (int newNumberRows, int newNumberColumns)
    1258 {
    1259      if (newNumberRows == numberRows_ &&
    1260                newNumberColumns == numberColumns_)
    1261           return; // nothing to do
    1262      whatsChanged_ = 0;
    1263      int numberRows2 = newNumberRows;
    1264      int numberColumns2 = newNumberColumns;
    1265      if (numberRows2 < maximumRows_)
    1266           numberRows2 = maximumRows_;
    1267      if (numberColumns2 < maximumColumns_)
    1268           numberColumns2 = maximumColumns_;
    1269      if (numberRows2 > maximumRows_) {
    1270           rowActivity_ = resizeDouble(rowActivity_, numberRows_,
    1271                                       newNumberRows, 0.0, true);
    1272           dual_ = resizeDouble(dual_, numberRows_,
    1273                                newNumberRows, 0.0, true);
    1274           rowObjective_ = resizeDouble(rowObjective_, numberRows_,
    1275                                        newNumberRows, 0.0, false);
    1276           rowLower_ = resizeDouble(rowLower_, numberRows_,
    1277                                    newNumberRows, -COIN_DBL_MAX, true);
    1278           rowUpper_ = resizeDouble(rowUpper_, numberRows_,
    1279                                    newNumberRows, COIN_DBL_MAX, true);
    1280      }
    1281      if (numberColumns2 > maximumColumns_) {
    1282           columnActivity_ = resizeDouble(columnActivity_, numberColumns_,
    1283                                          newNumberColumns, 0.0, true);
    1284           reducedCost_ = resizeDouble(reducedCost_, numberColumns_,
    1285                                       newNumberColumns, 0.0, true);
    1286      }
    1287      if (savedRowScale_ && numberRows2 > maximumInternalRows_) {
    1288           double * temp;
    1289           temp = new double [4*newNumberRows];
    1290           CoinFillN(temp, 4 * newNumberRows, 1.0);
    1291           CoinMemcpyN(savedRowScale_, numberRows_, temp);
    1292           CoinMemcpyN(savedRowScale_ + maximumInternalRows_, numberRows_, temp + newNumberRows);
    1293           CoinMemcpyN(savedRowScale_ + 2 * maximumInternalRows_, numberRows_, temp + 2 * newNumberRows);
    1294           CoinMemcpyN(savedRowScale_ + 3 * maximumInternalRows_, numberRows_, temp + 3 * newNumberRows);
    1295           delete [] savedRowScale_;
    1296           savedRowScale_ = temp;
    1297      }
    1298      if (savedColumnScale_ && numberColumns2 > maximumInternalColumns_) {
    1299           double * temp;
    1300           temp = new double [4*newNumberColumns];
    1301           CoinFillN(temp, 4 * newNumberColumns, 1.0);
    1302           CoinMemcpyN(savedColumnScale_, numberColumns_, temp);
    1303           CoinMemcpyN(savedColumnScale_ + maximumInternalColumns_, numberColumns_, temp + newNumberColumns);
    1304           CoinMemcpyN(savedColumnScale_ + 2 * maximumInternalColumns_, numberColumns_, temp + 2 * newNumberColumns);
    1305           CoinMemcpyN(savedColumnScale_ + 3 * maximumInternalColumns_, numberColumns_, temp + 3 * newNumberColumns);
    1306           delete [] savedColumnScale_;
    1307           savedColumnScale_ = temp;
    1308      }
    1309      if (objective_ && numberColumns2 > maximumColumns_)
    1310           objective_->resize(newNumberColumns);
    1311      else if (!objective_)
    1312           objective_ = new ClpLinearObjective(NULL, newNumberColumns);
    1313      if (numberColumns2 > maximumColumns_) {
    1314           columnLower_ = resizeDouble(columnLower_, numberColumns_,
    1315                                       newNumberColumns, 0.0, true);
    1316           columnUpper_ = resizeDouble(columnUpper_, numberColumns_,
    1317                                       newNumberColumns, COIN_DBL_MAX, true);
    1318      }
    1319      if (newNumberRows < numberRows_) {
    1320           int * which = new int[numberRows_-newNumberRows];
    1321           int i;
    1322           for (i = newNumberRows; i < numberRows_; i++)
    1323                which[i-newNumberRows] = i;
    1324           matrix_->deleteRows(numberRows_ - newNumberRows, which);
    1325           delete [] which;
    1326      }
    1327      if (numberRows_ != newNumberRows || numberColumns_ != newNumberColumns) {
    1328           // set state back to unknown
    1329           problemStatus_ = -1;
    1330           secondaryStatus_ = 0;
    1331           delete [] ray_;
    1332           ray_ = NULL;
    1333      }
    1334      setRowScale(NULL);
    1335      setColumnScale(NULL);
    1336      if (status_) {
    1337           if (newNumberColumns + newNumberRows) {
    1338                if (newNumberColumns + newNumberRows > maximumRows_ + maximumColumns_) {
    1339                     unsigned char * tempC = new unsigned char [newNumberColumns+newNumberRows];
    1340                     unsigned char * tempR = tempC + newNumberColumns;
    1341                     memset(tempC, 3, newNumberColumns * sizeof(unsigned char));
    1342                     memset(tempR, 1, newNumberRows * sizeof(unsigned char));
    1343                     CoinMemcpyN(status_, CoinMin(newNumberColumns, numberColumns_), tempC);
    1344                     CoinMemcpyN(status_ + numberColumns_, CoinMin(newNumberRows, numberRows_), tempR);
    1345                     delete [] status_;
    1346                     status_ = tempC;
    1347                } else if (newNumberColumns < numberColumns_) {
    1348                     memmove(status_ + newNumberColumns, status_ + numberColumns_,
    1349                             newNumberRows);
    1350                } else if (newNumberColumns > numberColumns_) {
    1351                     memset(status_ + numberColumns_, 3, newNumberColumns - numberColumns_);
    1352                     memmove(status_ + newNumberColumns, status_ + numberColumns_,
    1353                             newNumberRows);
    1354                }
    1355           } else {
    1356                // empty model - some systems don't like new [0]
    1357                delete [] status_;
    1358                status_ = NULL;
    1359           }
    1360      }
     1230void ClpModel::resize(int newNumberRows, int newNumberColumns)
     1231{
     1232  if (newNumberRows == numberRows_ && newNumberColumns == numberColumns_)
     1233    return; // nothing to do
     1234  whatsChanged_ = 0;
     1235  int numberRows2 = newNumberRows;
     1236  int numberColumns2 = newNumberColumns;
     1237  if (numberRows2 < maximumRows_)
     1238    numberRows2 = maximumRows_;
     1239  if (numberColumns2 < maximumColumns_)
     1240    numberColumns2 = maximumColumns_;
     1241  if (numberRows2 > maximumRows_) {
     1242    rowActivity_ = resizeDouble(rowActivity_, numberRows_,
     1243      newNumberRows, 0.0, true);
     1244    dual_ = resizeDouble(dual_, numberRows_,
     1245      newNumberRows, 0.0, true);
     1246    rowObjective_ = resizeDouble(rowObjective_, numberRows_,
     1247      newNumberRows, 0.0, false);
     1248    rowLower_ = resizeDouble(rowLower_, numberRows_,
     1249      newNumberRows, -COIN_DBL_MAX, true);
     1250    rowUpper_ = resizeDouble(rowUpper_, numberRows_,
     1251      newNumberRows, COIN_DBL_MAX, true);
     1252  }
     1253  if (numberColumns2 > maximumColumns_) {
     1254    columnActivity_ = resizeDouble(columnActivity_, numberColumns_,
     1255      newNumberColumns, 0.0, true);
     1256    reducedCost_ = resizeDouble(reducedCost_, numberColumns_,
     1257      newNumberColumns, 0.0, true);
     1258  }
     1259  if (savedRowScale_ && numberRows2 > maximumInternalRows_) {
     1260    double *temp;
     1261    temp = new double[4 * newNumberRows];
     1262    CoinFillN(temp, 4 * newNumberRows, 1.0);
     1263    CoinMemcpyN(savedRowScale_, numberRows_, temp);
     1264    CoinMemcpyN(savedRowScale_ + maximumInternalRows_, numberRows_, temp + newNumberRows);
     1265    CoinMemcpyN(savedRowScale_ + 2 * maximumInternalRows_, numberRows_, temp + 2 * newNumberRows);
     1266    CoinMemcpyN(savedRowScale_ + 3 * maximumInternalRows_, numberRows_, temp + 3 * newNumberRows);
     1267    delete[] savedRowScale_;
     1268    savedRowScale_ = temp;
     1269  }
     1270  if (savedColumnScale_ && numberColumns2 > maximumInternalColumns_) {
     1271    double *temp;
     1272    temp = new double[4 * newNumberColumns];
     1273    CoinFillN(temp, 4 * newNumberColumns, 1.0);
     1274    CoinMemcpyN(savedColumnScale_, numberColumns_, temp);
     1275    CoinMemcpyN(savedColumnScale_ + maximumInternalColumns_, numberColumns_, temp + newNumberColumns);
     1276    CoinMemcpyN(savedColumnScale_ + 2 * maximumInternalColumns_, numberColumns_, temp + 2 * newNumberColumns);
     1277    CoinMemcpyN(savedColumnScale_ + 3 * maximumInternalColumns_, numberColumns_, temp + 3 * newNumberColumns);
     1278    delete[] savedColumnScale_;
     1279    savedColumnScale_ = temp;
     1280  }
     1281  if (objective_ && numberColumns2 > maximumColumns_)
     1282    objective_->resize(newNumberColumns);
     1283  else if (!objective_)
     1284    objective_ = new ClpLinearObjective(NULL, newNumberColumns);
     1285  if (numberColumns2 > maximumColumns_) {
     1286    columnLower_ = resizeDouble(columnLower_, numberColumns_,
     1287      newNumberColumns, 0.0, true);
     1288    columnUpper_ = resizeDouble(columnUpper_, numberColumns_,
     1289      newNumberColumns, COIN_DBL_MAX, true);
     1290  }
     1291  if (newNumberRows < numberRows_) {
     1292    int *which = new int[numberRows_ - newNumberRows];
     1293    int i;
     1294    for (i = newNumberRows; i < numberRows_; i++)
     1295      which[i - newNumberRows] = i;
     1296    matrix_->deleteRows(numberRows_ - newNumberRows, which);
     1297    delete[] which;
     1298  }
     1299  if (numberRows_ != newNumberRows || numberColumns_ != newNumberColumns) {
     1300    // set state back to unknown
     1301    problemStatus_ = -1;
     1302    secondaryStatus_ = 0;
     1303    delete[] ray_;
     1304    ray_ = NULL;
     1305  }
     1306  setRowScale(NULL);
     1307  setColumnScale(NULL);
     1308  if (status_) {
     1309    if (newNumberColumns + newNumberRows) {
     1310      if (newNumberColumns + newNumberRows > maximumRows_ + maximumColumns_) {
     1311        unsigned char *tempC = new unsigned char[newNumberColumns + newNumberRows];
     1312        unsigned char *tempR = tempC + newNumberColumns;
     1313        memset(tempC, 3, newNumberColumns * sizeof(unsigned char));
     1314        memset(tempR, 1, newNumberRows * sizeof(unsigned char));
     1315        CoinMemcpyN(status_, CoinMin(newNumberColumns, numberColumns_), tempC);
     1316        CoinMemcpyN(status_ + numberColumns_, CoinMin(newNumberRows, numberRows_), tempR);
     1317        delete[] status_;
     1318        status_ = tempC;
     1319      } else if (newNumberColumns < numberColumns_) {
     1320        memmove(status_ + newNumberColumns, status_ + numberColumns_,
     1321          newNumberRows);
     1322      } else if (newNumberColumns > numberColumns_) {
     1323        memset(status_ + numberColumns_, 3, newNumberColumns - numberColumns_);
     1324        memmove(status_ + newNumberColumns, status_ + numberColumns_,
     1325          newNumberRows);
     1326      }
     1327    } else {
     1328      // empty model - some systems don't like new [0]
     1329      delete[] status_;
     1330      status_ = NULL;
     1331    }
     1332  }
    13611333#ifndef CLP_NO_STD
    1362      if (lengthNames_) {
    1363           // redo row and column names (make sure clean)
    1364           int numberRowNames =
    1365             CoinMin(static_cast<int>(rowNames_.size()),numberRows_);
    1366           if (numberRowNames < newNumberRows) {
    1367                rowNames_.resize(newNumberRows);
    1368                lengthNames_ = CoinMax(lengthNames_, 8);
    1369                char name[10];
    1370                for (unsigned int iRow = numberRowNames; iRow < newNumberRows; iRow++) {
    1371                     sprintf(name, "R%7.7d", iRow);
    1372                     rowNames_[iRow] = name;
    1373                }
    1374           }
    1375           int numberColumnNames =
    1376             CoinMin(static_cast<int>(columnNames_.size()),numberColumns_);
    1377           if (numberColumnNames < newNumberColumns) {
    1378                columnNames_.resize(newNumberColumns);
    1379                lengthNames_ = CoinMax(lengthNames_, 8);
    1380                char name[10];
    1381                for (unsigned int iColumn = numberColumnNames;
    1382                     iColumn < newNumberColumns; iColumn++) {
    1383                     sprintf(name, "C%7.7d", iColumn);
    1384                     columnNames_[iColumn] = name;
    1385                }
    1386           }
    1387      }
    1388 #endif
    1389      numberRows_ = newNumberRows;
    1390      if (newNumberColumns < numberColumns_ && matrix_->getNumCols()) {
    1391           int * which = new int[numberColumns_-newNumberColumns];
    1392           int i;
    1393           for (i = newNumberColumns; i < numberColumns_; i++)
    1394                which[i-newNumberColumns] = i;
    1395           matrix_->deleteCols(numberColumns_ - newNumberColumns, which);
    1396           delete [] which;
    1397      }
    1398      if (integerType_ && numberColumns2 > maximumColumns_) {
    1399           char * temp = new char [newNumberColumns];
    1400           CoinZeroN(temp, newNumberColumns);
    1401           CoinMemcpyN(integerType_,
    1402                       CoinMin(newNumberColumns, numberColumns_), temp);
    1403           delete [] integerType_;
    1404           integerType_ = temp;
    1405      }
    1406      numberColumns_ = newNumberColumns;
    1407      if ((specialOptions_ & 65536) != 0) {
    1408           // leave until next create rim to up numbers
    1409      }
    1410      if (maximumRows_ >= 0) {
    1411           if (numberRows_ > maximumRows_)
    1412                COIN_DETAIL_PRINT(printf("resize %d rows, %d old maximum rows\n",
    1413                                         numberRows_, maximumRows_));
    1414           maximumRows_ = CoinMax(maximumRows_, numberRows_);
    1415           maximumColumns_ = CoinMax(maximumColumns_, numberColumns_);
    1416      }
     1334  if (lengthNames_) {
     1335    // redo row and column names (make sure clean)
     1336    int numberRowNames = CoinMin(static_cast< int >(rowNames_.size()), numberRows_);
     1337    if (numberRowNames < newNumberRows) {
     1338      rowNames_.resize(newNumberRows);
     1339      lengthNames_ = CoinMax(lengthNames_, 8);
     1340      char name[10];
     1341      for (unsigned int iRow = numberRowNames; iRow < newNumberRows; iRow++) {
     1342        sprintf(name, "R%7.7d", iRow);
     1343        rowNames_[iRow] = name;
     1344      }
     1345    }
     1346    int numberColumnNames = CoinMin(static_cast< int >(columnNames_.size()), numberColumns_);
     1347    if (numberColumnNames < newNumberColumns) {
     1348      columnNames_.resize(newNumberColumns);
     1349      lengthNames_ = CoinMax(lengthNames_, 8);
     1350      char name[10];
     1351      for (unsigned int iColumn = numberColumnNames;
     1352           iColumn < newNumberColumns; iColumn++) {
     1353        sprintf(name, "C%7.7d", iColumn);
     1354        columnNames_[iColumn] = name;
     1355      }
     1356    }
     1357  }
     1358#endif
     1359  numberRows_ = newNumberRows;
     1360  if (newNumberColumns < numberColumns_ && matrix_->getNumCols()) {
     1361    int *which = new int[numberColumns_ - newNumberColumns];
     1362    int i;
     1363    for (i = newNumberColumns; i < numberColumns_; i++)
     1364      which[i - newNumberColumns] = i;
     1365    matrix_->deleteCols(numberColumns_ - newNumberColumns, which);
     1366    delete[] which;
     1367  }
     1368  if (integerType_ && numberColumns2 > maximumColumns_) {
     1369    char *temp = new char[newNumberColumns];
     1370    CoinZeroN(temp, newNumberColumns);
     1371    CoinMemcpyN(integerType_,
     1372      CoinMin(newNumberColumns, numberColumns_), temp);
     1373    delete[] integerType_;
     1374    integerType_ = temp;
     1375  }
     1376  numberColumns_ = newNumberColumns;
     1377  if ((specialOptions_ & 65536) != 0) {
     1378    // leave until next create rim to up numbers
     1379  }
     1380  if (maximumRows_ >= 0) {
     1381    if (numberRows_ > maximumRows_)
     1382      COIN_DETAIL_PRINT(printf("resize %d rows, %d old maximum rows\n",
     1383        numberRows_, maximumRows_));
     1384    maximumRows_ = CoinMax(maximumRows_, numberRows_);
     1385    maximumColumns_ = CoinMax(maximumColumns_, numberColumns_);
     1386  }
    14171387}
    14181388// Deletes rows
    1419 void
    1420 ClpModel::deleteRows(int number, const int * which)
    1421 {
    1422      if (!number)
    1423           return; // nothing to do
    1424      whatsChanged_ &= ~(1 + 2 + 4 + 8 + 16 + 32); // all except columns changed
    1425      int newSize = 0;
     1389void ClpModel::deleteRows(int number, const int *which)
     1390{
     1391  if (!number)
     1392    return; // nothing to do
     1393  whatsChanged_ &= ~(1 + 2 + 4 + 8 + 16 + 32); // all except columns changed
     1394  int newSize = 0;
    14261395#define CLP_TIDY_DELETE_ROWS
    14271396#ifdef CLP_TIDY_DELETE_ROWS
    1428      if (status_) {
    1429                     // try and get right number of basic
    1430                     int nChange=0;
    1431                     unsigned char * rowStatus = status_+numberColumns_;
    1432                     for (int i=0;i<number;i++) {
    1433                       int iRow = which[i];
    1434                       if ((rowStatus[iRow]&7) !=1)
    1435                         nChange++;
    1436                     }
    1437                     // take out slacks at bound
    1438                     for (int iRow=0;iRow<numberRows_;iRow++) {
    1439                         if (!nChange)
    1440                           break;
    1441                         if ((rowStatus[iRow]&7) ==1) {
    1442                           if (fabs(rowActivity_[iRow]-rowLower_[iRow])<1.0e-8) {
    1443                             rowStatus[iRow]=3;
    1444                             nChange--;
    1445                           } else if (fabs(rowActivity_[iRow]-rowUpper_[iRow])<1.0e-8) {
    1446                             rowStatus[iRow]=2;
    1447                             nChange--;
    1448                           }
    1449                         }
    1450                       }
    1451      }
    1452 #endif
    1453      if (maximumRows_ < 0) {
    1454           rowActivity_ = deleteDouble(rowActivity_, numberRows_,
    1455                                       number, which, newSize);
    1456           dual_ = deleteDouble(dual_, numberRows_,
    1457                                number, which, newSize);
    1458           rowObjective_ = deleteDouble(rowObjective_, numberRows_,
    1459                                        number, which, newSize);
    1460           rowLower_ = deleteDouble(rowLower_, numberRows_,
    1461                                    number, which, newSize);
    1462           rowUpper_ = deleteDouble(rowUpper_, numberRows_,
    1463                                    number, which, newSize);
    1464           if (matrix_->getNumRows())
    1465                matrix_->deleteRows(number, which);
    1466           //matrix_->removeGaps();
    1467           // status
    1468           if (status_) {
    1469                if (numberColumns_ + newSize) {
    1470                     unsigned char * tempR  = reinterpret_cast<unsigned char *>
    1471                                              (deleteChar(reinterpret_cast<char *>(status_) + numberColumns_,
    1472                                                          numberRows_,
    1473                                                          number, which, newSize, false));
    1474                     unsigned char * tempC = new unsigned char [numberColumns_+newSize];
    1475                     CoinMemcpyN(status_, numberColumns_, tempC);
    1476                     CoinMemcpyN(tempR, newSize, tempC + numberColumns_);
    1477                     delete [] tempR;
    1478                     delete [] status_;
    1479                     status_ = tempC;
    1480                } else {
    1481                     // empty model - some systems don't like new [0]
    1482                     delete [] status_;
    1483                     status_ = NULL;
    1484                }
    1485           }
    1486      } else {
    1487           char * deleted = new char [numberRows_];
    1488           int i;
    1489           int numberDeleted = 0;
    1490           CoinZeroN(deleted, numberRows_);
    1491           for (i = 0; i < number; i++) {
    1492                int j = which[i];
    1493                if (j >= 0 && j < numberRows_ && !deleted[j]) {
    1494                     numberDeleted++;
    1495                     deleted[j] = 1;
    1496                }
    1497           }
    1498           assert (!rowObjective_);
    1499           unsigned char * status2 = status_ + numberColumns_;
    1500           for (i = 0; i < numberRows_; i++) {
    1501                if (!deleted[i]) {
    1502                     rowActivity_[newSize] = rowActivity_[i];
    1503                     dual_[newSize] = dual_[i];
    1504                     rowLower_[newSize] = rowLower_[i];
    1505                     rowUpper_[newSize] = rowUpper_[i];
    1506                     status2[newSize] = status2[i];
    1507                     newSize++;
    1508                }
    1509           }
    1510           if (matrix_->getNumRows())
    1511                matrix_->deleteRows(number, which);
    1512           //matrix_->removeGaps();
    1513           delete [] deleted;
    1514      }
     1397  if (status_) {
     1398    // try and get right number of basic
     1399    int nChange = 0;
     1400    unsigned char *rowStatus = status_ + numberColumns_;
     1401    for (int i = 0; i < number; i++) {
     1402      int iRow = which[i];
     1403      if ((rowStatus[iRow] & 7) != 1)
     1404        nChange++;
     1405    }
     1406    // take out slacks at bound
     1407    for (int iRow = 0; iRow < numberRows_; iRow++) {
     1408      if (!nChange)
     1409        break;
     1410      if ((rowStatus[iRow] & 7) == 1) {
     1411        if (fabs(rowActivity_[iRow] - rowLower_[iRow]) < 1.0e-8) {
     1412          rowStatus[iRow] = 3;
     1413          nChange--;
     1414        } else if (fabs(rowActivity_[iRow] - rowUpper_[iRow]) < 1.0e-8) {
     1415          rowStatus[iRow] = 2;
     1416          nChange--;
     1417        }
     1418      }
     1419    }
     1420  }
     1421#endif
     1422  if (maximumRows_ < 0) {
     1423    rowActivity_ = deleteDouble(rowActivity_, numberRows_,
     1424      number, which, newSize);
     1425    dual_ = deleteDouble(dual_, numberRows_,
     1426      number, which, newSize);
     1427    rowObjective_ = deleteDouble(rowObjective_, numberRows_,
     1428      number, which, newSize);
     1429    rowLower_ = deleteDouble(rowLower_, numberRows_,
     1430      number, which, newSize);
     1431    rowUpper_ = deleteDouble(rowUpper_, numberRows_,
     1432      number, which, newSize);
     1433    if (matrix_->getNumRows())
     1434      matrix_->deleteRows(number, which);
     1435    //matrix_->removeGaps();
     1436    // status
     1437    if (status_) {
     1438      if (numberColumns_ + newSize) {
     1439        unsigned char *tempR = reinterpret_cast< unsigned char * >(deleteChar(reinterpret_cast< char * >(status_) + numberColumns_,
     1440          numberRows_,
     1441          number, which, newSize, false));
     1442        unsigned char *tempC = new unsigned char[numberColumns_ + newSize];
     1443        CoinMemcpyN(status_, numberColumns_, tempC);
     1444        CoinMemcpyN(tempR, newSize, tempC + numberColumns_);
     1445        delete[] tempR;
     1446        delete[] status_;
     1447        status_ = tempC;
     1448      } else {
     1449        // empty model - some systems don't like new [0]
     1450        delete[] status_;
     1451        status_ = NULL;
     1452      }
     1453    }
     1454  } else {
     1455    char *deleted = new char[numberRows_];
     1456    int i;
     1457    int numberDeleted = 0;
     1458    CoinZeroN(deleted, numberRows_);
     1459    for (i = 0; i < number; i++) {
     1460      int j = which[i];
     1461      if (j >= 0 && j < numberRows_ && !deleted[j]) {
     1462        numberDeleted++;
     1463        deleted[j] = 1;
     1464      }
     1465    }
     1466    assert(!rowObjective_);
     1467    unsigned char *status2 = status_ + numberColumns_;
     1468    for (i = 0; i < numberRows_; i++) {
     1469      if (!deleted[i]) {
     1470        rowActivity_[newSize] = rowActivity_[i];
     1471        dual_[newSize] = dual_[i];
     1472        rowLower_[newSize] = rowLower_[i];
     1473        rowUpper_[newSize] = rowUpper_[i];
     1474        status2[newSize] = status2[i];
     1475        newSize++;
     1476      }
     1477    }
     1478    if (matrix_->getNumRows())
     1479      matrix_->deleteRows(number, which);
     1480    //matrix_->removeGaps();
     1481    delete[] deleted;
     1482  }
    15151483#ifndef CLP_NO_STD
    1516      // Now works if which out of order
    1517      if (lengthNames_) {
    1518           char * mark = new char [numberRows_];
    1519           CoinZeroN(mark, numberRows_);
    1520           int i;
    1521           for (i = 0; i < number; i++)
    1522                mark[which[i]] = 1;
    1523           int k = 0;
    1524           for ( i = 0; i < numberRows_; ++i) {
    1525                if (!mark[i])
    1526                     rowNames_[k++] = rowNames_[i];
    1527           }
    1528           rowNames_.erase(rowNames_.begin() + k, rowNames_.end());
    1529           delete [] mark;
    1530      }
    1531 #endif
    1532      numberRows_ = newSize;
    1533      // set state back to unknown
    1534      problemStatus_ = -1;
    1535      secondaryStatus_ = 0;
    1536      delete [] ray_;
    1537      ray_ = NULL;
    1538      if (savedRowScale_ != rowScale_) {
    1539           delete [] rowScale_;
    1540           delete [] columnScale_;
    1541      }
    1542      rowScale_ = NULL;
    1543      columnScale_ = NULL;
    1544      delete scaledMatrix_;
    1545      scaledMatrix_ = NULL;
     1484  // Now works if which out of order
     1485  if (lengthNames_) {
     1486    char *mark = new char[numberRows_];
     1487    CoinZeroN(mark, numberRows_);
     1488    int i;
     1489    for (i = 0; i < number; i++)
     1490      mark[which[i]] = 1;
     1491    int k = 0;
     1492    for (i = 0; i < numberRows_; ++i) {
     1493      if (!mark[i])
     1494        rowNames_[k++] = rowNames_[i];
     1495    }
     1496    rowNames_.erase(rowNames_.begin() + k, rowNames_.end());
     1497    delete[] mark;
     1498  }
     1499#endif
     1500  numberRows_ = newSize;
     1501  // set state back to unknown
     1502  problemStatus_ = -1;
     1503  secondaryStatus_ = 0;
     1504  delete[] ray_;
     1505  ray_ = NULL;
     1506  if (savedRowScale_ != rowScale_) {
     1507    delete[] rowScale_;
     1508    delete[] columnScale_;
     1509  }
     1510  rowScale_ = NULL;
     1511  columnScale_ = NULL;
     1512  delete scaledMatrix_;
     1513  scaledMatrix_ = NULL;
    15461514}
    15471515// Deletes columns
    1548 void
    1549 ClpModel::deleteColumns(int number, const int * which)
    1550 {
    1551      if (!number)
    1552           return; // nothing to do
    1553      assert (maximumColumns_ < 0);
    1554      whatsChanged_ &= ~(1 + 2 + 4 + 8 + 64 + 128 + 256); // all except rows changed
    1555      int newSize = 0;
    1556      columnActivity_ = deleteDouble(columnActivity_, numberColumns_,
    1557                                     number, which, newSize);
    1558      reducedCost_ = deleteDouble(reducedCost_, numberColumns_,
    1559                                  number, which, newSize);
    1560      objective_->deleteSome(number, which);
    1561      columnLower_ = deleteDouble(columnLower_, numberColumns_,
    1562                                  number, which, newSize);
    1563      columnUpper_ = deleteDouble(columnUpper_, numberColumns_,
    1564                                  number, which, newSize);
    1565      // possible matrix is not full
    1566      if (matrix_->getNumCols() < numberColumns_) {
    1567           int * which2 = new int [number];
    1568           int n = 0;
    1569           int nMatrix = matrix_->getNumCols();
    1570           for (int i = 0; i < number; i++) {
    1571                if (which[i] < nMatrix)
    1572                     which2[n++] = which[i];
    1573           }
    1574           matrix_->deleteCols(n, which2);
    1575           delete [] which2;
    1576      } else {
    1577           matrix_->deleteCols(number, which);
    1578      }
    1579      //matrix_->removeGaps();
    1580      // status
    1581      if (status_) {
    1582           if (numberRows_ + newSize) {
    1583                unsigned char * tempC  = reinterpret_cast<unsigned char *>
    1584                                         (deleteChar(reinterpret_cast<char *>(status_),
    1585                                                     numberColumns_,
    1586                                                     number, which, newSize, false));
    1587                unsigned char * temp = new unsigned char [numberRows_+newSize];
    1588                CoinMemcpyN(tempC, newSize, temp);
    1589                CoinMemcpyN(status_ + numberColumns_,    numberRows_, temp + newSize);
    1590                delete [] tempC;
    1591                delete [] status_;
    1592                status_ = temp;
    1593           } else {
    1594                // empty model - some systems don't like new [0]
    1595                delete [] status_;
    1596                status_ = NULL;
    1597           }
    1598      }
    1599      integerType_ = deleteChar(integerType_, numberColumns_,
    1600                                number, which, newSize, true);
     1516void ClpModel::deleteColumns(int number, const int *which)
     1517{
     1518  if (!number)
     1519    return; // nothing to do
     1520  assert(maximumColumns_ < 0);
     1521  whatsChanged_ &= ~(1 + 2 + 4 + 8 + 64 + 128 + 256); // all except rows changed
     1522  int newSize = 0;
     1523  columnActivity_ = deleteDouble(columnActivity_, numberColumns_,
     1524    number, which, newSize);
     1525  reducedCost_ = deleteDouble(reducedCost_, numberColumns_,
     1526    number, which, newSize);
     1527  objective_->deleteSome(number, which);
     1528  columnLower_ = deleteDouble(columnLower_, numberColumns_,
     1529    number, which, newSize);
     1530  columnUpper_ = deleteDouble(columnUpper_, numberColumns_,
     1531    number, which, newSize);
     1532  // possible matrix is not full
     1533  if (matrix_->getNumCols() < numberColumns_) {
     1534    int *which2 = new int[number];
     1535    int n = 0;
     1536    int nMatrix = matrix_->getNumCols();
     1537    for (int i = 0; i < number; i++) {
     1538      if (which[i] < nMatrix)
     1539        which2[n++] = which[i];
     1540    }
     1541    matrix_->deleteCols(n, which2);
     1542    delete[] which2;
     1543  } else {
     1544    matrix_->deleteCols(number, which);
     1545  }
     1546  //matrix_->removeGaps();
     1547  // status
     1548  if (status_) {
     1549    if (numberRows_ + newSize) {
     1550      unsigned char *tempC = reinterpret_cast< unsigned char * >(deleteChar(reinterpret_cast< char * >(status_),
     1551        numberColumns_,
     1552        number, which, newSize, false));
     1553      unsigned char *temp = new unsigned char[numberRows_ + newSize];
     1554      CoinMemcpyN(tempC, newSize, temp);
     1555      CoinMemcpyN(status_ + numberColumns_, numberRows_, temp + newSize);
     1556      delete[] tempC;
     1557      delete[] status_;
     1558      status_ = temp;
     1559    } else {
     1560      // empty model - some systems don't like new [0]
     1561      delete[] status_;
     1562      status_ = NULL;
     1563    }
     1564  }
     1565  integerType_ = deleteChar(integerType_, numberColumns_,
     1566    number, which, newSize, true);
    16011567#ifndef CLP_NO_STD
    1602      // Now works if which out of order
    1603      if (lengthNames_) {
    1604           char * mark = new char [numberColumns_];
    1605           CoinZeroN(mark, numberColumns_);
    1606           int i;
    1607           for (i = 0; i < number; i++)
    1608                mark[which[i]] = 1;
    1609           int k = 0;
    1610           for ( i = 0; i < numberColumns_; ++i) {
    1611                if (!mark[i])
    1612                     columnNames_[k++] = columnNames_[i];
    1613           }
    1614           columnNames_.erase(columnNames_.begin() + k, columnNames_.end());
    1615           delete [] mark;
    1616      }
    1617 #endif
    1618      numberColumns_ = newSize;
    1619      // set state back to unknown
    1620      problemStatus_ = -1;
    1621      secondaryStatus_ = 0;
    1622      delete [] ray_;
    1623      ray_ = NULL;
    1624      setRowScale(NULL);
    1625      setColumnScale(NULL);
     1568  // Now works if which out of order
     1569  if (lengthNames_) {
     1570    char *mark = new char[numberColumns_];
     1571    CoinZeroN(mark, numberColumns_);
     1572    int i;
     1573    for (i = 0; i < number; i++)
     1574      mark[which[i]] = 1;
     1575    int k = 0;
     1576    for (i = 0; i < numberColumns_; ++i) {
     1577      if (!mark[i])
     1578        columnNames_[k++] = columnNames_[i];
     1579    }
     1580    columnNames_.erase(columnNames_.begin() + k, columnNames_.end());
     1581    delete[] mark;
     1582  }
     1583#endif
     1584  numberColumns_ = newSize;
     1585  // set state back to unknown
     1586  problemStatus_ = -1;
     1587  secondaryStatus_ = 0;
     1588  delete[] ray_;
     1589  ray_ = NULL;
     1590  setRowScale(NULL);
     1591  setColumnScale(NULL);
    16261592}
    16271593// Deletes rows AND columns (does not reallocate)
    1628 void
    1629 ClpModel::deleteRowsAndColumns(int numberRows, const int * whichRows,
    1630                                int numberColumns, const int * whichColumns)
     1594void ClpModel::deleteRowsAndColumns(int numberRows, const int *whichRows,
     1595  int numberColumns, const int *whichColumns)
    16311596{
    16321597  if (!numberColumns) {
    1633     deleteRows(numberRows,whichRows);
     1598    deleteRows(numberRows, whichRows);
    16341599  } else if (!numberRows) {
    1635     deleteColumns(numberColumns,whichColumns);
     1600    deleteColumns(numberColumns, whichColumns);
    16361601  } else {
    16371602    whatsChanged_ &= ~511; // all changed
    1638     bool doStatus = status_!=NULL;
    1639     int numberTotal=numberRows_+numberColumns_;
    1640     int * backRows = new int [numberTotal];
    1641     int * backColumns = backRows+numberRows_;
    1642     memset(backRows,0,numberTotal*sizeof(int));
    1643     int newNumberColumns=0;
    1644     for (int i=0;i<numberColumns;i++) {
    1645       int iColumn=whichColumns[i];
    1646       if (iColumn>=0&&iColumn<numberColumns_)
    1647         backColumns[iColumn]=-1;
    1648     }
    1649     assert (objective_->type()==1);
    1650     double * obj = objective();
    1651     for (int i=0;i<numberColumns_;i++) {
     1603    bool doStatus = status_ != NULL;
     1604    int numberTotal = numberRows_ + numberColumns_;
     1605    int *backRows = new int[numberTotal];
     1606    int *backColumns = backRows + numberRows_;
     1607    memset(backRows, 0, numberTotal * sizeof(int));
     1608    int newNumberColumns = 0;
     1609    for (int i = 0; i < numberColumns; i++) {
     1610      int iColumn = whichColumns[i];
     1611      if (iColumn >= 0 && iColumn < numberColumns_)
     1612        backColumns[iColumn] = -1;
     1613    }
     1614    assert(objective_->type() == 1);
     1615    double *obj = objective();
     1616    for (int i = 0; i < numberColumns_; i++) {
    16521617      if (!backColumns[i]) {
    1653         columnActivity_[newNumberColumns] = columnActivity_[i];
    1654         reducedCost_[newNumberColumns] = reducedCost_[i];
    1655         obj[newNumberColumns] = obj[i];
    1656         columnLower_[newNumberColumns] = columnLower_[i];
    1657         columnUpper_[newNumberColumns] = columnUpper_[i];
    1658         if (doStatus)
    1659           status_[newNumberColumns] = status_[i];
    1660         backColumns[i]=newNumberColumns++;
     1618        columnActivity_[newNumberColumns] = columnActivity_[i];
     1619        reducedCost_[newNumberColumns] = reducedCost_[i];
     1620        obj[newNumberColumns] = obj[i];
     1621        columnLower_[newNumberColumns] = columnLower_[i];
     1622        columnUpper_[newNumberColumns] = columnUpper_[i];
     1623        if (doStatus)
     1624          status_[newNumberColumns] = status_[i];
     1625        backColumns[i] = newNumberColumns++;
    16611626      }
    16621627    }
    16631628    integerType_ = deleteChar(integerType_, numberColumns_,
    1664                               numberColumns, whichColumns, newNumberColumns, true);
     1629      numberColumns, whichColumns, newNumberColumns, true);
    16651630#ifndef CLP_NO_STD
    16661631    // Now works if which out of order
    16671632    if (lengthNames_) {
    1668       for (int i=0;i<numberColumns_;i++) {
    1669         int iColumn=backColumns[i];
    1670         if (iColumn)
    1671           columnNames_[iColumn] = columnNames_[i];
     1633      for (int i = 0; i < numberColumns_; i++) {
     1634        int iColumn = backColumns[i];
     1635        if (iColumn)
     1636          columnNames_[iColumn] = columnNames_[i];
    16721637      }
    16731638      columnNames_.erase(columnNames_.begin() + newNumberColumns, columnNames_.end());
    16741639    }
    16751640#endif
    1676     int newNumberRows=0;
    1677     assert (!rowObjective_);
    1678     unsigned char * status2 = status_ + numberColumns_;
    1679     unsigned char * status2a = status_ + newNumberColumns;
    1680     for (int i=0;i<numberRows;i++) {
    1681       int iRow=whichRows[i];
    1682       if (iRow>=0&&iRow<numberRows_)
    1683         backRows[iRow]=-1;
    1684     }
    1685     for (int i=0;i<numberRows_;i++) {
     1641    int newNumberRows = 0;
     1642    assert(!rowObjective_);
     1643    unsigned char *status2 = status_ + numberColumns_;
     1644    unsigned char *status2a = status_ + newNumberColumns;
     1645    for (int i = 0; i < numberRows; i++) {
     1646      int iRow = whichRows[i];
     1647      if (iRow >= 0 && iRow < numberRows_)
     1648        backRows[iRow] = -1;
     1649    }
     1650    for (int i = 0; i < numberRows_; i++) {
    16861651      if (!backRows[i]) {
    1687         rowActivity_[newNumberRows] = rowActivity_[i];
    1688         dual_[newNumberRows] = dual_[i];
    1689         rowLower_[newNumberRows] = rowLower_[i];
    1690         rowUpper_[newNumberRows] = rowUpper_[i];
    1691         if (doStatus)
    1692           status2a[newNumberRows] = status2[i];
    1693         backRows[i]=newNumberRows++;
     1652        rowActivity_[newNumberRows] = rowActivity_[i];
     1653        dual_[newNumberRows] = dual_[i];
     1654        rowLower_[newNumberRows] = rowLower_[i];
     1655        rowUpper_[newNumberRows] = rowUpper_[i];
     1656        if (doStatus)
     1657          status2a[newNumberRows] = status2[i];
     1658        backRows[i] = newNumberRows++;
    16941659      }
    16951660    }
     
    16971662    // Now works if which out of order
    16981663    if (lengthNames_) {
    1699       for (int i=0;i<numberRows_;i++) {
    1700         int iRow=backRows[i];
    1701         if (iRow)
    1702           rowNames_[iRow] = rowNames_[i];
     1664      for (int i = 0; i < numberRows_; i++) {
     1665        int iRow = backRows[i];
     1666        if (iRow)
     1667          rowNames_[iRow] = rowNames_[i];
    17031668      }
    17041669      rowNames_.erase(rowNames_.begin() + newNumberRows, rowNames_.end());
     
    17061671#endif
    17071672    // possible matrix is not full
    1708     ClpPackedMatrix * clpMatrix = dynamic_cast<ClpPackedMatrix *>(matrix_);
    1709     CoinPackedMatrix * matrix = clpMatrix ? clpMatrix->matrix() : NULL;
     1673    ClpPackedMatrix *clpMatrix = dynamic_cast< ClpPackedMatrix * >(matrix_);
     1674    CoinPackedMatrix *matrix = clpMatrix ? clpMatrix->matrix() : NULL;
    17101675    if (matrix_->getNumCols() < numberColumns_) {
    1711       assert (matrix);
    1712       CoinBigIndex nel=matrix->getNumElements();
    1713       int n=matrix->getNumCols();
    1714       matrix->reserve(numberColumns_,nel);
    1715       CoinBigIndex * columnStart = matrix->getMutableVectorStarts();
    1716       int * columnLength = matrix->getMutableVectorLengths();
    1717       for (int i=n;i<numberColumns_;i++) {
    1718         columnStart[i]=nel;
    1719         columnLength[i]=0;
     1676      assert(matrix);
     1677      CoinBigIndex nel = matrix->getNumElements();
     1678      int n = matrix->getNumCols();
     1679      matrix->reserve(numberColumns_, nel);
     1680      CoinBigIndex *columnStart = matrix->getMutableVectorStarts();
     1681      int *columnLength = matrix->getMutableVectorLengths();
     1682      for (int i = n; i < numberColumns_; i++) {
     1683        columnStart[i] = nel;
     1684        columnLength[i] = 0;
    17201685      }
    17211686    }
     
    17251690      matrix->setExtraGap(0.0);
    17261691      matrix->setExtraMajor(0.0);
    1727       int * row = matrix->getMutableIndices();
    1728       CoinBigIndex * columnStart = matrix->getMutableVectorStarts();
    1729       int * columnLength = matrix->getMutableVectorLengths();
    1730       double * element = matrix->getMutableElements();
    1731       newNumberColumns=0;
    1732       CoinBigIndex n=0;
    1733       for (int iColumn=0;iColumn<numberColumns_;iColumn++) {
    1734         if (backColumns[iColumn]>=0) {
    1735           CoinBigIndex start = columnStart[iColumn];
    1736           CoinBigIndex nSave=n;
    1737           columnStart[newNumberColumns]=n;
    1738           for (CoinBigIndex j=start;j<start+columnLength[iColumn];j++) {
    1739             int iRow=row[j];
    1740             iRow = backRows[iRow];
    1741             if (iRow>=0) {
    1742               row[n]=iRow;
    1743               element[n++]=element[j];
    1744             }
    1745           }
    1746           columnLength[newNumberColumns++]=static_cast<int>(n-nSave);
    1747         }
    1748       }
    1749       columnStart[newNumberColumns]=n;
     1692      int *row = matrix->getMutableIndices();
     1693      CoinBigIndex *columnStart = matrix->getMutableVectorStarts();
     1694      int *columnLength = matrix->getMutableVectorLengths();
     1695      double *element = matrix->getMutableElements();
     1696      newNumberColumns = 0;
     1697      CoinBigIndex n = 0;
     1698      for (int iColumn = 0; iColumn < numberColumns_; iColumn++) {
     1699        if (backColumns[iColumn] >= 0) {
     1700          CoinBigIndex start = columnStart[iColumn];
     1701          CoinBigIndex nSave = n;
     1702          columnStart[newNumberColumns] = n;
     1703          for (CoinBigIndex j = start; j < start + columnLength[iColumn]; j++) {
     1704            int iRow = row[j];
     1705            iRow = backRows[iRow];
     1706            if (iRow >= 0) {
     1707              row[n] = iRow;
     1708              element[n++] = element[j];
     1709            }
     1710          }
     1711          columnLength[newNumberColumns++] = static_cast< int >(n - nSave);
     1712        }
     1713      }
     1714      columnStart[newNumberColumns] = n;
    17501715      matrix->setNumElements(n);
    17511716      matrix->setMajorDim(newNumberColumns);
     
    17621727    numberColumns_ = newNumberColumns;
    17631728    numberRows_ = newNumberRows;
    1764     delete [] backRows;
     1729    delete[] backRows;
    17651730    // set state back to unknown
    17661731    problemStatus_ = -1;
    17671732    secondaryStatus_ = 0;
    1768     delete [] ray_;
     1733    delete[] ray_;
    17691734    ray_ = NULL;
    17701735    if (savedRowScale_ != rowScale_) {
    1771       delete [] rowScale_;
    1772       delete [] columnScale_;
     1736      delete[] rowScale_;
     1737      delete[] columnScale_;
    17731738    }
    17741739    rowScale_ = NULL;
     
    17811746}
    17821747// Add one row
    1783 void
    1784 ClpModel::addRow(int numberInRow, const int * columns,
    1785                  const double * elements, double rowLower, double rowUpper)
    1786 {
    1787      CoinBigIndex starts[2];
    1788      starts[0] = 0;
    1789      starts[1] = numberInRow;
    1790      addRows(1, &rowLower, &rowUpper, starts, columns, elements);
     1748void ClpModel::addRow(int numberInRow, const int *columns,
     1749  const double *elements, double rowLower, double rowUpper)
     1750{
     1751  CoinBigIndex starts[2];
     1752  starts[0] = 0;
     1753  starts[1] = numberInRow;
     1754  addRows(1, &rowLower, &rowUpper, starts, columns, elements);
    17911755}
    17921756// Add rows
    1793 void
    1794 ClpModel::addRows(int number, const double * rowLower,
    1795                   const double * rowUpper,
    1796                   const CoinBigIndex * rowStarts, const int * columns,
    1797                   const double * elements)
    1798 {
    1799      if (number) {
    1800           whatsChanged_ &= ~(1 + 2 + 8 + 16 + 32); // all except columns changed
    1801           int numberRowsNow = numberRows_;
    1802           resize(numberRowsNow + number, numberColumns_);
    1803           double * lower = rowLower_ + numberRowsNow;
    1804           double * upper = rowUpper_ + numberRowsNow;
    1805           int iRow;
    1806           if (rowLower) {
    1807                for (iRow = 0; iRow < number; iRow++) {
    1808                     double value = rowLower[iRow];
    1809                     if (value < -1.0e20)
    1810                          value = -COIN_DBL_MAX;
    1811                     lower[iRow] = value;
    1812                }
    1813           } else {
    1814                for (iRow = 0; iRow < number; iRow++) {
    1815                     lower[iRow] = -COIN_DBL_MAX;
    1816                }
    1817           }
    1818           if (rowUpper) {
    1819                for (iRow = 0; iRow < number; iRow++) {
    1820                     double value = rowUpper[iRow];
    1821                     if (value > 1.0e20)
    1822                          value = COIN_DBL_MAX;
    1823                     upper[iRow] = value;
    1824                }
    1825           } else {
    1826                for (iRow = 0; iRow < number; iRow++) {
    1827                     upper[iRow] = COIN_DBL_MAX;
    1828                }
    1829           }
    1830           // Deal with matrix
    1831 
    1832           delete rowCopy_;
    1833           rowCopy_ = NULL;
    1834           delete scaledMatrix_;
    1835           scaledMatrix_ = NULL;
    1836           if (!matrix_)
    1837                createEmptyMatrix();
    1838           setRowScale(NULL);
    1839           setColumnScale(NULL);
     1757void ClpModel::addRows(int number, const double *rowLower,
     1758  const double *rowUpper,
     1759  const CoinBigIndex *rowStarts, const int *columns,
     1760  const double *elements)
     1761{
     1762  if (number) {
     1763    whatsChanged_ &= ~(1 + 2 + 8 + 16 + 32); // all except columns changed
     1764    int numberRowsNow = numberRows_;
     1765    resize(numberRowsNow + number, numberColumns_);
     1766    double *lower = rowLower_ + numberRowsNow;
     1767    double *upper = rowUpper_ + numberRowsNow;
     1768    int iRow;
     1769    if (rowLower) {
     1770      for (iRow = 0; iRow < number; iRow++) {
     1771        double value = rowLower[iRow];
     1772        if (value < -1.0e20)
     1773          value = -COIN_DBL_MAX;
     1774        lower[iRow] = value;
     1775      }
     1776    } else {
     1777      for (iRow = 0; iRow < number; iRow++) {
     1778        lower[iRow] = -COIN_DBL_MAX;
     1779      }
     1780    }
     1781    if (rowUpper) {
     1782      for (iRow = 0; iRow < number; iRow++) {
     1783        double value = rowUpper[iRow];
     1784        if (value > 1.0e20)
     1785          value = COIN_DBL_MAX;
     1786        upper[iRow] = value;
     1787      }
     1788    } else {
     1789      for (iRow = 0; iRow < number; iRow++) {
     1790        upper[iRow] = COIN_DBL_MAX;
     1791      }
     1792    }
     1793    // Deal with matrix
     1794
     1795    delete rowCopy_;
     1796    rowCopy_ = NULL;
     1797    delete scaledMatrix_;
     1798    scaledMatrix_ = NULL;
     1799    if (!matrix_)
     1800      createEmptyMatrix();
     1801    setRowScale(NULL);
     1802    setColumnScale(NULL);
    18401803#ifndef CLP_NO_STD
    1841           if (lengthNames_) {
    1842                rowNames_.resize(numberRows_);
    1843           }
    1844 #endif
    1845           if (rowStarts) {
    1846                // Make sure matrix has correct number of columns
    1847                matrix_->getPackedMatrix()->reserve(numberColumns_, 0, true);
    1848                matrix_->appendMatrix(number, 0, rowStarts, columns, elements);
    1849           }
    1850      }
     1804    if (lengthNames_) {
     1805      rowNames_.resize(numberRows_);
     1806    }
     1807#endif
     1808    if (rowStarts) {
     1809      // Make sure matrix has correct number of columns
     1810      matrix_->getPackedMatrix()->reserve(numberColumns_, 0, true);
     1811      matrix_->appendMatrix(number, 0, rowStarts, columns, elements);
     1812    }
     1813  }
    18511814}
    18521815// Add rows
    1853 void
    1854 ClpModel::addRows(int number, const double * rowLower,
    1855                   const double * rowUpper,
    1856                   const CoinBigIndex * rowStarts,
    1857                   const int * rowLengths, const int * columns,
    1858                   const double * elements)
    1859 {
    1860      if (number) {
    1861           CoinBigIndex numberElements = 0;
    1862           int iRow;
    1863           for (iRow = 0; iRow < number; iRow++)
    1864                numberElements += rowLengths[iRow];
    1865           CoinBigIndex * newStarts = new CoinBigIndex[number+1];
    1866           int * newIndex = new int[numberElements];
    1867           double * newElements = new double[numberElements];
    1868           numberElements = 0;
    1869           newStarts[0] = 0;
    1870           for (iRow = 0; iRow < number; iRow++) {
    1871                CoinBigIndex iStart = rowStarts[iRow];
    1872                int length = rowLengths[iRow];
    1873                CoinMemcpyN(columns + iStart, length, newIndex + numberElements);
    1874                CoinMemcpyN(elements + iStart, length, newElements + numberElements);
    1875                numberElements += length;
    1876                newStarts[iRow+1] = numberElements;
    1877           }
    1878           addRows(number, rowLower, rowUpper,
    1879                   newStarts, newIndex, newElements);
    1880           delete [] newStarts;
    1881           delete [] newIndex;
    1882           delete [] newElements;
    1883      }
     1816void ClpModel::addRows(int number, const double *rowLower,
     1817  const double *rowUpper,
     1818  const CoinBigIndex *rowStarts,
     1819  const int *rowLengths, const int *columns,
     1820  const double *elements)
     1821{
     1822  if (number) {
     1823    CoinBigIndex numberElements = 0;
     1824    int iRow;
     1825    for (iRow = 0; iRow < number; iRow++)
     1826      numberElements += rowLengths[iRow];
     1827    CoinBigIndex *newStarts = new CoinBigIndex[number + 1];
     1828    int *newIndex = new int[numberElements];
     1829    double *newElements = new double[numberElements];
     1830    numberElements = 0;
     1831    newStarts[0] = 0;
     1832    for (iRow = 0; iRow < number; iRow++) {
     1833      CoinBigIndex iStart = rowStarts[iRow];
     1834      int length = rowLengths[iRow];
     1835      CoinMemcpyN(columns + iStart, length, newIndex + numberElements);
     1836      CoinMemcpyN(elements + iStart, length, newElements + numberElements);
     1837      numberElements += length;
     1838      newStarts[iRow + 1] = numberElements;
     1839    }
     1840    addRows(number, rowLower, rowUpper,
     1841      newStarts, newIndex, newElements);
     1842    delete[] newStarts;
     1843    delete[] newIndex;
     1844    delete[] newElements;
     1845  }
    18841846}
    18851847#ifndef CLP_NO_VECTOR
    1886 void
    1887 ClpModel::addRows(int number, const double * rowLower,
    1888                   const double * rowUpper,
    1889                   const CoinPackedVectorBase * const * rows)
    1890 {
    1891      if (!number)
    1892           return;
    1893      whatsChanged_ &= ~(1 + 2 + 8 + 16 + 32); // all except columns changed
    1894      int numberRowsNow = numberRows_;
    1895      resize(numberRowsNow + number, numberColumns_);
    1896      double * lower = rowLower_ + numberRowsNow;
    1897      double * upper = rowUpper_ + numberRowsNow;
    1898      int iRow;
    1899      if (rowLower) {
    1900           for (iRow = 0; iRow < number; iRow++) {
    1901                double value = rowLower[iRow];
    1902                if (value < -1.0e20)
    1903                     value = -COIN_DBL_MAX;
    1904                lower[iRow] = value;
    1905           }
    1906      } else {
    1907           for (iRow = 0; iRow < number; iRow++) {
    1908                lower[iRow] = -COIN_DBL_MAX;
    1909           }
    1910      }
    1911      if (rowUpper) {
    1912           for (iRow = 0; iRow < number; iRow++) {
    1913                double value = rowUpper[iRow];
    1914                if (value > 1.0e20)
    1915                     value = COIN_DBL_MAX;
    1916                upper[iRow] = value;
    1917           }
    1918      } else {
    1919           for (iRow = 0; iRow < number; iRow++) {
    1920                upper[iRow] = COIN_DBL_MAX;
    1921           }
    1922      }
    1923      // Deal with matrix
    1924 
    1925      delete rowCopy_;
    1926      rowCopy_ = NULL;
    1927      delete scaledMatrix_;
    1928      scaledMatrix_ = NULL;
    1929      if (!matrix_)
    1930           createEmptyMatrix();
    1931      if (rows)
    1932           matrix_->appendRows(number, rows);
    1933      setRowScale(NULL);
    1934      setColumnScale(NULL);
    1935      if (lengthNames_) {
    1936           rowNames_.resize(numberRows_);
    1937      }
     1848void ClpModel::addRows(int number, const double *rowLower,
     1849  const double *rowUpper,
     1850  const CoinPackedVectorBase *const *rows)
     1851{
     1852  if (!number)
     1853    return;
     1854  whatsChanged_ &= ~(1 + 2 + 8 + 16 + 32); // all except columns changed
     1855  int numberRowsNow = numberRows_;
     1856  resize(numberRowsNow + number, numberColumns_);
     1857  double *lower = rowLower_ + numberRowsNow;
     1858  double *upper = rowUpper_ + numberRowsNow;
     1859  int iRow;
     1860  if (rowLower) {
     1861    for (iRow = 0; iRow < number; iRow++) {
     1862      double value = rowLower[iRow];
     1863      if (value < -1.0e20)
     1864        value = -COIN_DBL_MAX;
     1865      lower[iRow] = value;
     1866    }
     1867  } else {
     1868    for (iRow = 0; iRow < number; iRow++) {
     1869      lower[iRow] = -COIN_DBL_MAX;
     1870    }
     1871  }
     1872  if (rowUpper) {
     1873    for (iRow = 0; iRow < number; iRow++) {
     1874      double value = rowUpper[iRow];
     1875      if (value > 1.0e20)
     1876        value = COIN_DBL_MAX;
     1877      upper[iRow] = value;
     1878    }
     1879  } else {
     1880    for (iRow = 0; iRow < number; iRow++) {
     1881      upper[iRow] = COIN_DBL_MAX;
     1882    }
     1883  }
     1884  // Deal with matrix
     1885
     1886  delete rowCopy_;
     1887  rowCopy_ = NULL;
     1888  delete scaledMatrix_;
     1889  scaledMatrix_ = NULL;
     1890  if (!matrix_)
     1891    createEmptyMatrix();
     1892  if (rows)
     1893    matrix_->appendRows(number, rows);
     1894  setRowScale(NULL);
     1895  setColumnScale(NULL);
     1896  if (lengthNames_) {
     1897    rowNames_.resize(numberRows_);
     1898  }
    19381899}
    19391900#endif
    19401901#ifndef SLIM_CLP
    19411902// Add rows from a build object
    1942 int
    1943 ClpModel::addRows(const CoinBuild & buildObject, bool tryPlusMinusOne, bool checkDuplicates)
    1944 {
    1945      CoinAssertHint (buildObject.type() == 0, "Looks as if both addRows and addCols being used"); // check correct
    1946      int number = buildObject.numberRows();
    1947      int numberErrors = 0;
    1948      if (number) {
    1949           CoinBigIndex size = 0;
    1950           int iRow;
    1951           double * lower = new double [number];
    1952           double * upper = new double [number];
    1953           if ((!matrix_ || !matrix_->getNumElements()) && tryPlusMinusOne) {
    1954                // See if can be +-1
    1955                for (iRow = 0; iRow < number; iRow++) {
    1956                     const int * columns;
    1957                     const double * elements;
    1958                     int numberElements = buildObject.row(iRow, lower[iRow],
    1959                                                          upper[iRow],
    1960                                                          columns, elements);
    1961                     for (int i = 0; i < numberElements; i++) {
    1962                          // allow for zero elements
    1963                          if (elements[i]) {
    1964                               if (fabs(elements[i]) == 1.0) {
    1965                                    size++;
    1966                               } else {
    1967                                    // bad
    1968                                    tryPlusMinusOne = false;
    1969                               }
    1970                          }
    1971                     }
    1972                     if (!tryPlusMinusOne)
    1973                          break;
    1974                }
    1975           } else {
    1976                // Will add to whatever sort of matrix exists
    1977                tryPlusMinusOne = false;
     1903int ClpModel::addRows(const CoinBuild &buildObject, bool tryPlusMinusOne, bool checkDuplicates)
     1904{
     1905  CoinAssertHint(buildObject.type() == 0, "Looks as if both addRows and addCols being used"); // check correct
     1906  int number = buildObject.numberRows();
     1907  int numberErrors = 0;
     1908  if (number) {
     1909    CoinBigIndex size = 0;
     1910    int iRow;
     1911    double *lower = new double[number];
     1912    double *upper = new double[number];
     1913    if ((!matrix_ || !matrix_->getNumElements()) && tryPlusMinusOne) {
     1914      // See if can be +-1
     1915      for (iRow = 0; iRow < number; iRow++) {
     1916        const int *columns;
     1917        const double *elements;
     1918        int numberElements = buildObject.row(iRow, lower[iRow],
     1919          upper[iRow],
     1920          columns, elements);
     1921        for (int i = 0; i < numberElements; i++) {
     1922          // allow for zero elements
     1923          if (elements[i]) {
     1924            if (fabs(elements[i]) == 1.0) {
     1925              size++;
     1926            } else {
     1927              // bad
     1928              tryPlusMinusOne = false;
     1929            }
    19781930          }
    1979           if (!tryPlusMinusOne) {
    1980                CoinBigIndex numberElements = buildObject.numberElements();
    1981                CoinBigIndex * starts = new CoinBigIndex [number+1];
    1982                int * column = new int[numberElements];
    1983                double * element = new double[numberElements];
    1984                starts[0] = 0;
    1985                numberElements = 0;
    1986                for (iRow = 0; iRow < number; iRow++) {
    1987                     const int * columns;
    1988                     const double * elements;
    1989                     int numberElementsThis = buildObject.row(iRow, lower[iRow], upper[iRow],
    1990                                              columns, elements);
    1991                     CoinMemcpyN(columns, numberElementsThis, column + numberElements);
    1992                     CoinMemcpyN(elements, numberElementsThis, element + numberElements);
    1993                     numberElements += numberElementsThis;
    1994                     starts[iRow+1] = numberElements;
    1995                }
    1996                addRows(number, lower, upper, NULL);
    1997                // make sure matrix has enough columns
    1998                matrix_->setDimensions(-1, numberColumns_);
    1999                numberErrors = matrix_->appendMatrix(number, 0, starts, column, element,
    2000                                                     checkDuplicates ? numberColumns_ : -1);
    2001                delete [] starts;
    2002                delete [] column;
    2003                delete [] element;
    2004           } else {
    2005                char * which = NULL; // for duplicates
    2006                if (checkDuplicates) {
    2007                     which = new char[numberColumns_];
    2008                     CoinZeroN(which, numberColumns_);
    2009                }
    2010                // build +-1 matrix
    2011                // arrays already filled in
    2012                addRows(number, lower, upper, NULL);
    2013                CoinBigIndex * startPositive = new CoinBigIndex [numberColumns_+1];
    2014                CoinBigIndex * startNegative = new CoinBigIndex [numberColumns_];
    2015                int * indices = new int [size];
    2016                CoinZeroN(startPositive, numberColumns_);
    2017                CoinZeroN(startNegative, numberColumns_);
    2018                int maxColumn = -1;
    2019                // need two passes
    2020                for (iRow = 0; iRow < number; iRow++) {
    2021                     const int * columns;
    2022                     const double * elements;
    2023                     int numberElements = buildObject.row(iRow, lower[iRow],
    2024                                                          upper[iRow],
    2025                                                          columns, elements);
    2026                     for (int i = 0; i < numberElements; i++) {
    2027                          int iColumn = columns[i];
    2028                          if (checkDuplicates) {
    2029                               if (iColumn >= numberColumns_) {
    2030                                    if(which[iColumn])
    2031                                         numberErrors++;
    2032                                    else
    2033                                         which[iColumn] = 1;
    2034                               } else {
    2035                                    numberErrors++;
    2036                                    // and may as well switch off
    2037                                    checkDuplicates = false;
    2038                               }
    2039                          }
    2040                          maxColumn = CoinMax(maxColumn, iColumn);
    2041                          if (elements[i] == 1.0) {
    2042                               startPositive[iColumn]++;
    2043                          } else if (elements[i] == -1.0) {
    2044                               startNegative[iColumn]++;
    2045                          }
    2046                     }
    2047                     if (checkDuplicates) {
    2048                          for (int i = 0; i < numberElements; i++) {
    2049                               int iColumn = columns[i];
    2050                               which[iColumn] = 0;
    2051                          }
    2052                     }
    2053                }
    2054                // check size
    2055                int numberColumns = maxColumn + 1;
    2056                CoinAssertHint (numberColumns <= numberColumns_,
    2057                                "rows having column indices >= numberColumns_");
    2058                size = 0;
    2059                int iColumn;
    2060                for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
    2061                     CoinBigIndex n = startPositive[iColumn];
    2062                     startPositive[iColumn] = size;
    2063                     size += n;
    2064                     n = startNegative[iColumn];
    2065                     startNegative[iColumn] = size;
    2066                     size += n;
    2067                }
    2068                startPositive[numberColumns_] = size;
    2069                for (iRow = 0; iRow < number; iRow++) {
    2070                     const int * columns;
    2071                     const double * elements;
    2072                     int numberElements = buildObject.row(iRow, lower[iRow],
    2073                                                          upper[iRow],
    2074                                                          columns, elements);
    2075                     for (int i = 0; i < numberElements; i++) {
    2076                          int iColumn = columns[i];
    2077                          maxColumn = CoinMax(maxColumn, iColumn);
    2078                          if (elements[i] == 1.0) {
    2079                               CoinBigIndex position = startPositive[iColumn];
    2080                               indices[position] = iRow;
    2081                               startPositive[iColumn]++;
    2082                          } else if (elements[i] == -1.0) {
    2083                               CoinBigIndex position = startNegative[iColumn];
    2084                               indices[position] = iRow;
    2085                               startNegative[iColumn]++;
    2086                          }
    2087                     }
    2088                }
    2089                // and now redo starts
    2090                for (iColumn = numberColumns_ - 1; iColumn >= 0; iColumn--) {
    2091                     startPositive[iColumn+1] = startNegative[iColumn];
    2092                     startNegative[iColumn] = startPositive[iColumn];
    2093                }
    2094                startPositive[0] = 0;
    2095                for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
    2096                     CoinBigIndex start = startPositive[iColumn];
    2097                     CoinBigIndex end = startNegative[iColumn];
    2098                     std::sort(indices + start, indices + end);
    2099                     start = startNegative[iColumn];
    2100                     end = startPositive[iColumn+1];
    2101                     std::sort(indices + start, indices + end);
    2102                }
    2103                // Get good object
    2104                delete matrix_;
    2105                ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    2106                matrix->passInCopy(numberRows_, numberColumns,
    2107                                   true, indices, startPositive, startNegative);
    2108                matrix_ = matrix;
    2109                delete [] which;
     1931        }
     1932        if (!tryPlusMinusOne)
     1933          break;
     1934      }
     1935    } else {
     1936      // Will add to whatever sort of matrix exists
     1937      tryPlusMinusOne = false;
     1938    }
     1939    if (!tryPlusMinusOne) {
     1940      CoinBigIndex numberElements = buildObject.numberElements();
     1941      CoinBigIndex *starts = new CoinBigIndex[number + 1];
     1942      int *column = new int[numberElements];
     1943      double *element = new double[numberElements];
     1944      starts[0] = 0;
     1945      numberElements = 0;
     1946      for (iRow = 0; iRow < number; iRow++) {
     1947        const int *columns;
     1948        const double *elements;
     1949        int numberElementsThis = buildObject.row(iRow, lower[iRow], upper[iRow],
     1950          columns, elements);
     1951        CoinMemcpyN(columns, numberElementsThis, column + numberElements);
     1952        CoinMemcpyN(elements, numberElementsThis, element + numberElements);
     1953        numberElements += numberElementsThis;
     1954        starts[iRow + 1] = numberElements;
     1955      }
     1956      addRows(number, lower, upper, NULL);
     1957      // make sure matrix has enough columns
     1958      matrix_->setDimensions(-1, numberColumns_);
     1959      numberErrors = matrix_->appendMatrix(number, 0, starts, column, element,
     1960        checkDuplicates ? numberColumns_ : -1);
     1961      delete[] starts;
     1962      delete[] column;
     1963      delete[] element;
     1964    } else {
     1965      char *which = NULL; // for duplicates
     1966      if (checkDuplicates) {
     1967        which = new char[numberColumns_];
     1968        CoinZeroN(which, numberColumns_);
     1969      }
     1970      // build +-1 matrix
     1971      // arrays already filled in
     1972      addRows(number, lower, upper, NULL);
     1973      CoinBigIndex *startPositive = new CoinBigIndex[numberColumns_ + 1];
     1974      CoinBigIndex *startNegative = new CoinBigIndex[numberColumns_];
     1975      int *indices = new int[size];
     1976      CoinZeroN(startPositive, numberColumns_);
     1977      CoinZeroN(startNegative, numberColumns_);
     1978      int maxColumn = -1;
     1979      // need two passes
     1980      for (iRow = 0; iRow < number; iRow++) {
     1981        const int *columns;
     1982        const double *elements;
     1983        int numberElements = buildObject.row(iRow, lower[iRow],
     1984          upper[iRow],
     1985          columns, elements);
     1986        for (int i = 0; i < numberElements; i++) {
     1987          int iColumn = columns[i];
     1988          if (checkDuplicates) {
     1989            if (iColumn >= numberColumns_) {
     1990              if (which[iColumn])
     1991                numberErrors++;
     1992              else
     1993                which[iColumn] = 1;
     1994            } else {
     1995              numberErrors++;
     1996              // and may as well switch off
     1997              checkDuplicates = false;
     1998            }
    21101999          }
    2111           delete [] lower;
    2112           delete [] upper;
    2113           // make sure matrix correct size
    2114           matrix_->setDimensions(numberRows_, numberColumns_);
    2115      }
    2116      return numberErrors;
     2000          maxColumn = CoinMax(maxColumn, iColumn);
     2001          if (elements[i] == 1.0) {
     2002            startPositive[iColumn]++;
     2003          } else if (elements[i] == -1.0) {
     2004            startNegative[iColumn]++;
     2005          }
     2006        }
     2007        if (checkDuplicates) {
     2008          for (int i = 0; i < numberElements; i++) {
     2009            int iColumn = columns[i];
     2010            which[iColumn] = 0;
     2011          }
     2012        }
     2013      }
     2014      // check size
     2015      int numberColumns = maxColumn + 1;
     2016      CoinAssertHint(numberColumns <= numberColumns_,
     2017        "rows having column indices >= numberColumns_");
     2018      size = 0;
     2019      int iColumn;
     2020      for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2021        CoinBigIndex n = startPositive[iColumn];
     2022        startPositive[iColumn] = size;
     2023        size += n;
     2024        n = startNegative[iColumn];
     2025        startNegative[iColumn] = size;
     2026        size += n;
     2027      }
     2028      startPositive[numberColumns_] = size;
     2029      for (iRow = 0; iRow < number; iRow++) {
     2030        const int *columns;
     2031        const double *elements;
     2032        int numberElements = buildObject.row(iRow, lower[iRow],
     2033          upper[iRow],
     2034          columns, elements);
     2035        for (int i = 0; i < numberElements; i++) {
     2036          int iColumn = columns[i];
     2037          maxColumn = CoinMax(maxColumn, iColumn);
     2038          if (elements[i] == 1.0) {
     2039            CoinBigIndex position = startPositive[iColumn];
     2040            indices[position] = iRow;
     2041            startPositive[iColumn]++;
     2042          } else if (elements[i] == -1.0) {
     2043            CoinBigIndex position = startNegative[iColumn];
     2044            indices[position] = iRow;
     2045            startNegative[iColumn]++;
     2046          }
     2047        }
     2048      }
     2049      // and now redo starts
     2050      for (iColumn = numberColumns_ - 1; iColumn >= 0; iColumn--) {
     2051        startPositive[iColumn + 1] = startNegative[iColumn];
     2052        startNegative[iColumn] = startPositive[iColumn];
     2053      }
     2054      startPositive[0] = 0;
     2055      for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2056        CoinBigIndex start = startPositive[iColumn];
     2057        CoinBigIndex end = startNegative[iColumn];
     2058        std::sort(indices + start, indices + end);
     2059        start = startNegative[iColumn];
     2060        end = startPositive[iColumn + 1];
     2061        std::sort(indices + start, indices + end);
     2062      }
     2063      // Get good object
     2064      delete matrix_;
     2065      ClpPlusMinusOneMatrix *matrix = new ClpPlusMinusOneMatrix();
     2066      matrix->passInCopy(numberRows_, numberColumns,
     2067        true, indices, startPositive, startNegative);
     2068      matrix_ = matrix;
     2069      delete[] which;
     2070    }
     2071    delete[] lower;
     2072    delete[] upper;
     2073    // make sure matrix correct size
     2074    matrix_->setDimensions(numberRows_, numberColumns_);
     2075  }
     2076  return numberErrors;
    21172077}
    21182078#endif
    21192079#ifndef SLIM_NOIO
    21202080// Add rows from a model object
    2121 int
    2122 ClpModel::addRows( CoinModel & modelObject, bool tryPlusMinusOne, bool checkDuplicates)
    2123 {
    2124      if (modelObject.numberElements() == 0)
    2125           return 0;
    2126      bool goodState = true;
    2127      int numberErrors = 0;
    2128      if (modelObject.columnLowerArray()) {
    2129           // some column information exists
    2130           int numberColumns2 = modelObject.numberColumns();
    2131           const double * columnLower = modelObject.columnLowerArray();
    2132           const double * columnUpper = modelObject.columnUpperArray();
    2133           const double * objective = modelObject.objectiveArray();
    2134           const int * integerType = modelObject.integerTypeArray();
    2135           for (int i = 0; i < numberColumns2; i++) {
    2136                if (columnLower[i] != 0.0)
    2137                     goodState = false;
    2138                if (columnUpper[i] != COIN_DBL_MAX)
    2139                     goodState = false;
    2140                if (objective[i] != 0.0)
    2141                     goodState = false;
    2142                if (integerType[i] != 0)
    2143                     goodState = false;
    2144           }
    2145      }
    2146      if (goodState) {
    2147           // can do addRows
    2148           // Set arrays for normal use
    2149           double * rowLower = modelObject.rowLowerArray();
    2150           double * rowUpper = modelObject.rowUpperArray();
    2151           double * columnLower = modelObject.columnLowerArray();
    2152           double * columnUpper = modelObject.columnUpperArray();
    2153           double * objective = modelObject.objectiveArray();
    2154           int * integerType = modelObject.integerTypeArray();
    2155           double * associated = modelObject.associatedArray();
    2156           // If strings then do copies
    2157           if (modelObject.stringsExist()) {
    2158                numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
    2159                                                        objective, integerType, associated);
    2160           }
    2161           int numberRows = numberRows_; // save number of rows
    2162           int numberRows2 = modelObject.numberRows();
    2163           if (numberRows2 && !numberErrors) {
    2164                CoinBigIndex * startPositive = NULL;
    2165                CoinBigIndex * startNegative = NULL;
    2166                int numberColumns = modelObject.numberColumns();
    2167                if ((!matrix_ || !matrix_->getNumElements()) && !numberRows && tryPlusMinusOne) {
    2168                     startPositive = new CoinBigIndex[numberColumns+1];
    2169                     startNegative = new CoinBigIndex[numberColumns];
    2170                     modelObject.countPlusMinusOne(startPositive, startNegative, associated);
    2171                     if (startPositive[0] < 0) {
    2172                          // no good
    2173                          tryPlusMinusOne = false;
    2174                          delete [] startPositive;
    2175                          delete [] startNegative;
    2176                     }
    2177                } else {
    2178                     // Will add to whatever sort of matrix exists
    2179                     tryPlusMinusOne = false;
    2180                }
    2181                assert (rowLower);
    2182                addRows(numberRows2, rowLower, rowUpper, NULL, NULL, NULL);
     2081int ClpModel::addRows(CoinModel &modelObject, bool tryPlusMinusOne, bool checkDuplicates)
     2082{
     2083  if (modelObject.numberElements() == 0)
     2084    return 0;
     2085  bool goodState = true;
     2086  int numberErrors = 0;
     2087  if (modelObject.columnLowerArray()) {
     2088    // some column information exists
     2089    int numberColumns2 = modelObject.numberColumns();
     2090    const double *columnLower = modelObject.columnLowerArray();
     2091    const double *columnUpper = modelObject.columnUpperArray();
     2092    const double *objective = modelObject.objectiveArray();
     2093    const int *integerType = modelObject.integerTypeArray();
     2094    for (int i = 0; i < numberColumns2; i++) {
     2095      if (columnLower[i] != 0.0)
     2096        goodState = false;
     2097      if (columnUpper[i] != COIN_DBL_MAX)
     2098        goodState = false;
     2099      if (objective[i] != 0.0)
     2100        goodState = false;
     2101      if (integerType[i] != 0)
     2102        goodState = false;
     2103    }
     2104  }
     2105  if (goodState) {
     2106    // can do addRows
     2107    // Set arrays for normal use
     2108    double *rowLower = modelObject.rowLowerArray();
     2109    double *rowUpper = modelObject.rowUpperArray();
     2110    double *columnLower = modelObject.columnLowerArray();
     2111    double *columnUpper = modelObject.columnUpperArray();
     2112    double *objective = modelObject.objectiveArray();
     2113    int *integerType = modelObject.integerTypeArray();
     2114    double *associated = modelObject.associatedArray();
     2115    // If strings then do copies
     2116    if (modelObject.stringsExist()) {
     2117      numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
     2118        objective, integerType, associated);
     2119    }
     2120    int numberRows = numberRows_; // save number of rows
     2121    int numberRows2 = modelObject.numberRows();
     2122    if (numberRows2 && !numberErrors) {
     2123      CoinBigIndex *startPositive = NULL;
     2124      CoinBigIndex *startNegative = NULL;
     2125      int numberColumns = modelObject.numberColumns();
     2126      if ((!matrix_ || !matrix_->getNumElements()) && !numberRows && tryPlusMinusOne) {
     2127        startPositive = new CoinBigIndex[numberColumns + 1];
     2128        startNegative = new CoinBigIndex[numberColumns];
     2129        modelObject.countPlusMinusOne(startPositive, startNegative, associated);
     2130        if (startPositive[0] < 0) {
     2131          // no good
     2132          tryPlusMinusOne = false;
     2133          delete[] startPositive;
     2134          delete[] startNegative;
     2135        }
     2136      } else {
     2137        // Will add to whatever sort of matrix exists
     2138        tryPlusMinusOne = false;
     2139      }
     2140      assert(rowLower);
     2141      addRows(numberRows2, rowLower, rowUpper, NULL, NULL, NULL);
    21832142#ifndef SLIM_CLP
    2184                if (!tryPlusMinusOne) {
    2185 #endif
    2186                     CoinPackedMatrix matrix;
    2187                     modelObject.createPackedMatrix(matrix, associated);
    2188                     assert (!matrix.getExtraGap());
    2189                     if (matrix_->getNumRows()) {
    2190                          // matrix by rows
    2191                          matrix.reverseOrdering();
    2192                          assert (!matrix.getExtraGap());
    2193                          const int * column = matrix.getIndices();
    2194                          //const int * rowLength = matrix.getVectorLengths();
    2195                          const CoinBigIndex * rowStart = matrix.getVectorStarts();
    2196                          const double * element = matrix.getElements();
    2197                          // make sure matrix has enough columns
    2198                          matrix_->setDimensions(-1, numberColumns_);
    2199                          numberErrors += matrix_->appendMatrix(numberRows2, 0, rowStart, column, element,
    2200                                                                checkDuplicates ? numberColumns_ : -1);
    2201                     } else {
    2202                          delete matrix_;
    2203                          matrix_ = new ClpPackedMatrix(matrix);
    2204                     }
     2143      if (!tryPlusMinusOne) {
     2144#endif
     2145        CoinPackedMatrix matrix;
     2146        modelObject.createPackedMatrix(matrix, associated);
     2147        assert(!matrix.getExtraGap());
     2148        if (matrix_->getNumRows()) {
     2149          // matrix by rows
     2150          matrix.reverseOrdering();
     2151          assert(!matrix.getExtraGap());
     2152          const int *column = matrix.getIndices();
     2153          //const int * rowLength = matrix.getVectorLengths();
     2154          const CoinBigIndex *rowStart = matrix.getVectorStarts();
     2155          const double *element = matrix.getElements();
     2156          // make sure matrix has enough columns
     2157          matrix_->setDimensions(-1, numberColumns_);
     2158          numberErrors += matrix_->appendMatrix(numberRows2, 0, rowStart, column, element,
     2159            checkDuplicates ? numberColumns_ : -1);
     2160        } else {
     2161          delete matrix_;
     2162          matrix_ = new ClpPackedMatrix(matrix);
     2163        }
    22052164#ifndef SLIM_CLP
    2206                } else {
    2207                     // create +-1 matrix
    2208                     CoinBigIndex size = startPositive[numberColumns];
    2209                     int * indices = new int[size];
    2210                     modelObject.createPlusMinusOne(startPositive, startNegative, indices,
    2211                                                    associated);
    2212                     // Get good object
    2213                     ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    2214                     matrix->passInCopy(numberRows2, numberColumns,
    2215                                        true, indices, startPositive, startNegative);
    2216                     delete matrix_;
    2217                     matrix_ = matrix;
    2218                }
    2219                // Do names if wanted
    2220                if (modelObject.rowNames()->numberItems()) {
    2221                     const char *const * rowNames = modelObject.rowNames()->names();
    2222                     copyRowNames(rowNames, numberRows, numberRows_);
    2223                }
    2224 #endif
    2225           }
    2226           if (rowLower != modelObject.rowLowerArray()) {
    2227                delete [] rowLower;
    2228                delete [] rowUpper;
    2229                delete [] columnLower;
    2230                delete [] columnUpper;
    2231                delete [] objective;
    2232                delete [] integerType;
    2233                delete [] associated;
    2234                if (numberErrors)
    2235                     handler_->message(CLP_BAD_STRING_VALUES, messages_)
    2236                               << numberErrors
    2237                               << CoinMessageEol;
    2238           }
    2239           return numberErrors;
    2240      } else {
    2241           // not suitable for addRows
    2242           handler_->message(CLP_COMPLICATED_MODEL, messages_)
    2243                     << modelObject.numberRows()
    2244                     << modelObject.numberColumns()
    2245                     << CoinMessageEol;
    2246           return -1;
    2247      }
     2165      } else {
     2166        // create +-1 matrix
     2167        CoinBigIndex size = startPositive[numberColumns];
     2168        int *indices = new int[size];
     2169        modelObject.createPlusMinusOne(startPositive, startNegative, indices,
     2170          associated);
     2171        // Get good object
     2172        ClpPlusMinusOneMatrix *matrix = new ClpPlusMinusOneMatrix();
     2173        matrix->passInCopy(numberRows2, numberColumns,
     2174          true, indices, startPositive, startNegative);
     2175        delete matrix_;
     2176        matrix_ = matrix;
     2177      }
     2178      // Do names if wanted
     2179      if (modelObject.rowNames()->numberItems()) {
     2180        const char *const *rowNames = modelObject.rowNames()->names();
     2181        copyRowNames(rowNames, numberRows, numberRows_);
     2182      }
     2183#endif
     2184    }
     2185    if (rowLower != modelObject.rowLowerArray()) {
     2186      delete[] rowLower;
     2187      delete[] rowUpper;
     2188      delete[] columnLower;
     2189      delete[] columnUpper;
     2190      delete[] objective;
     2191      delete[] integerType;
     2192      delete[] associated;
     2193      if (numberErrors)
     2194        handler_->message(CLP_BAD_STRING_VALUES, messages_)
     2195          << numberErrors
     2196          << CoinMessageEol;
     2197    }
     2198    return numberErrors;
     2199  } else {
     2200    // not suitable for addRows
     2201    handler_->message(CLP_COMPLICATED_MODEL, messages_)
     2202      << modelObject.numberRows()
     2203      << modelObject.numberColumns()
     2204      << CoinMessageEol;
     2205    return -1;
     2206  }
    22482207}
    22492208#endif
    22502209// Add one column
    2251 void
    2252 ClpModel::addColumn(int numberInColumn,
    2253                     const int * rows,
    2254                     const double * elements,
    2255                     double columnLower,
    2256                     double  columnUpper,
    2257                     double  objective)
    2258 {
    2259      CoinBigIndex starts[2];
    2260      starts[0] = 0;
    2261      starts[1] = numberInColumn;
    2262      addColumns(1, &columnLower, &columnUpper, &objective, starts, rows, elements);
     2210void ClpModel::addColumn(int numberInColumn,
     2211  const int *rows,
     2212  const double *elements,
     2213  double columnLower,
     2214  double columnUpper,
     2215  double objective)
     2216{
     2217  CoinBigIndex starts[2];
     2218  starts[0] = 0;
     2219  starts[1] = numberInColumn;
     2220  addColumns(1, &columnLower, &columnUpper, &objective, starts, rows, elements);
    22632221}
    22642222// Add columns
    2265 void
    2266 ClpModel::addColumns(int number, const double * columnLower,
    2267                      const double * columnUpper,
    2268                      const double * objIn,
    2269                      const CoinBigIndex * columnStarts, const int * rows,
    2270                      const double * elements)
    2271 {
    2272      // Create a list of CoinPackedVectors
    2273      if (number) {
    2274           whatsChanged_ &= ~(1 + 2 + 4 + 64 + 128 + 256); // all except rows changed
    2275           int numberColumnsNow = numberColumns_;
    2276           resize(numberRows_, numberColumnsNow + number);
    2277           double * lower = columnLower_ + numberColumnsNow;
    2278           double * upper = columnUpper_ + numberColumnsNow;
    2279           double * obj = objective() + numberColumnsNow;
    2280           int iColumn;
    2281           if (columnLower) {
    2282                for (iColumn = 0; iColumn < number; iColumn++) {
    2283                     double value = columnLower[iColumn];
    2284                     if (value < -1.0e20)
    2285                          value = -COIN_DBL_MAX;
    2286                     lower[iColumn] = value;
    2287                }
    2288           } else {
    2289                for (iColumn = 0; iColumn < number; iColumn++) {
    2290                     lower[iColumn] = 0.0;
    2291                }
    2292           }
    2293           if (columnUpper) {
    2294                for (iColumn = 0; iColumn < number; iColumn++) {
    2295                     double value = columnUpper[iColumn];
    2296                     if (value > 1.0e20)
    2297                          value = COIN_DBL_MAX;
    2298                     upper[iColumn] = value;
    2299                }
    2300           } else {
    2301                for (iColumn = 0; iColumn < number; iColumn++) {
    2302                     upper[iColumn] = COIN_DBL_MAX;
    2303                }
    2304           }
    2305           if (objIn) {
    2306                for (iColumn = 0; iColumn < number; iColumn++) {
    2307                     obj[iColumn] = objIn[iColumn];
    2308                }
    2309           } else {
    2310                for (iColumn = 0; iColumn < number; iColumn++) {
    2311                     obj[iColumn] = 0.0;
    2312                }
    2313           }
    2314           // Deal with matrix
    2315 
    2316           delete rowCopy_;
    2317           rowCopy_ = NULL;
    2318           delete scaledMatrix_;
    2319           scaledMatrix_ = NULL;
    2320           if (!matrix_)
    2321                createEmptyMatrix();
    2322           setRowScale(NULL);
    2323           setColumnScale(NULL);
     2223void ClpModel::addColumns(int number, const double *columnLower,
     2224  const double *columnUpper,
     2225  const double *objIn,
     2226  const CoinBigIndex *columnStarts, const int *rows,
     2227  const double *elements)
     2228{
     2229  // Create a list of CoinPackedVectors
     2230  if (number) {
     2231    whatsChanged_ &= ~(1 + 2 + 4 + 64 + 128 + 256); // all except rows changed
     2232    int numberColumnsNow = numberColumns_;
     2233    resize(numberRows_, numberColumnsNow + number);
     2234    double *lower = columnLower_ + numberColumnsNow;
     2235    double *upper = columnUpper_ + numberColumnsNow;
     2236    double *obj = objective() + numberColumnsNow;
     2237    int iColumn;
     2238    if (columnLower) {
     2239      for (iColumn = 0; iColumn < number; iColumn++) {
     2240        double value = columnLower[iColumn];
     2241        if (value < -1.0e20)
     2242          value = -COIN_DBL_MAX;
     2243        lower[iColumn] = value;
     2244      }
     2245    } else {
     2246      for (iColumn = 0; iColumn < number; iColumn++) {
     2247        lower[iColumn] = 0.0;
     2248      }
     2249    }
     2250    if (columnUpper) {
     2251      for (iColumn = 0; iColumn < number; iColumn++) {
     2252        double value = columnUpper[iColumn];
     2253        if (value > 1.0e20)
     2254          value = COIN_DBL_MAX;
     2255        upper[iColumn] = value;
     2256      }
     2257    } else {
     2258      for (iColumn = 0; iColumn < number; iColumn++) {
     2259        upper[iColumn] = COIN_DBL_MAX;
     2260      }
     2261    }
     2262    if (objIn) {
     2263      for (iColumn = 0; iColumn < number; iColumn++) {
     2264        obj[iColumn] = objIn[iColumn];
     2265      }
     2266    } else {
     2267      for (iColumn = 0; iColumn < number; iColumn++) {
     2268        obj[iColumn] = 0.0;
     2269      }
     2270    }
     2271    // Deal with matrix
     2272
     2273    delete rowCopy_;
     2274    rowCopy_ = NULL;
     2275    delete scaledMatrix_;
     2276    scaledMatrix_ = NULL;
     2277    if (!matrix_)
     2278      createEmptyMatrix();
     2279    setRowScale(NULL);
     2280    setColumnScale(NULL);
    23242281#ifndef CLP_NO_STD
    2325           if (lengthNames_) {
    2326                columnNames_.resize(numberColumns_);
    2327           }
    2328 #endif
    2329           // Do even if elements NULL (to resize)
    2330           matrix_->appendMatrix(number, 1, columnStarts, rows, elements);
    2331      }
     2282    if (lengthNames_) {
     2283      columnNames_.resize(numberColumns_);
     2284    }
     2285#endif
     2286    // Do even if elements NULL (to resize)
     2287    matrix_->appendMatrix(number, 1, columnStarts, rows, elements);
     2288  }
    23322289}
    23332290// Add columns
    2334 void
    2335 ClpModel::addColumns(int number, const double * columnLower,
    2336                      const double * columnUpper,
    2337                      const double * objIn,
    2338                      const CoinBigIndex * columnStarts,
    2339                      const int * columnLengths, const int * rows,
    2340                      const double * elements)
    2341 {
    2342      if (number) {
    2343           CoinBigIndex numberElements = 0;
    2344           int iColumn;
    2345           for (iColumn = 0; iColumn < number; iColumn++)
    2346                numberElements += columnLengths[iColumn];
    2347           CoinBigIndex * newStarts = new CoinBigIndex[number+1];
    2348           int * newIndex = new int[numberElements];
    2349           double * newElements = new double[numberElements];
    2350           numberElements = 0;
    2351           newStarts[0] = 0;
    2352           for (iColumn = 0; iColumn < number; iColumn++) {
    2353                CoinBigIndex iStart = columnStarts[iColumn];
    2354                int length = columnLengths[iColumn];
    2355                CoinMemcpyN(rows + iStart, length, newIndex + numberElements);
    2356                CoinMemcpyN(elements + iStart, length, newElements + numberElements);
    2357                numberElements += length;
    2358                newStarts[iColumn+1] = numberElements;
    2359           }
    2360           addColumns(number, columnLower, columnUpper, objIn,
    2361                      newStarts, newIndex, newElements);
    2362           delete [] newStarts;
    2363           delete [] newIndex;
    2364           delete [] newElements;
    2365      }
     2291void ClpModel::addColumns(int number, const double *columnLower,
     2292  const double *columnUpper,
     2293  const double *objIn,
     2294  const CoinBigIndex *columnStarts,
     2295  const int *columnLengths, const int *rows,
     2296  const double *elements)
     2297{
     2298  if (number) {
     2299    CoinBigIndex numberElements = 0;
     2300    int iColumn;
     2301    for (iColumn = 0; iColumn < number; iColumn++)
     2302      numberElements += columnLengths[iColumn];
     2303    CoinBigIndex *newStarts = new CoinBigIndex[number + 1];
     2304    int *newIndex = new int[numberElements];
     2305    double *newElements = new double[numberElements];
     2306    numberElements = 0;
     2307    newStarts[0] = 0;
     2308    for (iColumn = 0; iColumn < number; iColumn++) {
     2309      CoinBigIndex iStart = columnStarts[iColumn];
     2310      int length = columnLengths[iColumn];
     2311      CoinMemcpyN(rows + iStart, length, newIndex + numberElements);
     2312      CoinMemcpyN(elements + iStart, length, newElements + numberElements);
     2313      numberElements += length;
     2314      newStarts[iColumn + 1] = numberElements;
     2315    }
     2316    addColumns(number, columnLower, columnUpper, objIn,
     2317      newStarts, newIndex, newElements);
     2318    delete[] newStarts;
     2319    delete[] newIndex;
     2320    delete[] newElements;
     2321  }
    23662322}
    23672323#ifndef CLP_NO_VECTOR
    2368 void
    2369 ClpModel::addColumns(int number, const double * columnLower,
    2370                      const double * columnUpper,
    2371                      const double * objIn,
    2372                      const CoinPackedVectorBase * const * columns)
    2373 {
    2374      if (!number)
    2375           return;
    2376      whatsChanged_ &= ~(1 + 2 + 4 + 64 + 128 + 256); // all except rows changed
    2377      int numberColumnsNow = numberColumns_;
    2378      resize(numberRows_, numberColumnsNow + number);
    2379      double * lower = columnLower_ + numberColumnsNow;
    2380      double * upper = columnUpper_ + numberColumnsNow;
    2381      double * obj = objective() + numberColumnsNow;
    2382      int iColumn;
    2383      if (columnLower) {
    2384           for (iColumn = 0; iColumn < number; iColumn++) {
    2385                double value = columnLower[iColumn];
    2386                if (value < -1.0e20)
    2387                     value = -COIN_DBL_MAX;
    2388                lower[iColumn] = value;
    2389           }
    2390      } else {
    2391           for (iColumn = 0; iColumn < number; iColumn++) {
    2392                lower[iColumn] = 0.0;
    2393           }
    2394      }
    2395      if (columnUpper) {
    2396           for (iColumn = 0; iColumn < number; iColumn++) {
    2397                double value = columnUpper[iColumn];
    2398                if (value > 1.0e20)
    2399                     value = COIN_DBL_MAX;
    2400                upper[iColumn] = value;
    2401           }
    2402      } else {
    2403           for (iColumn = 0; iColumn < number; iColumn++) {
    2404                upper[iColumn] = COIN_DBL_MAX;
    2405           }
    2406      }
    2407      if (objIn) {
    2408           for (iColumn = 0; iColumn < number; iColumn++) {
    2409                obj[iColumn] = objIn[iColumn];
    2410           }
    2411      } else {
    2412           for (iColumn = 0; iColumn < number; iColumn++) {
    2413                obj[iColumn] = 0.0;
    2414           }
    2415      }
    2416      // Deal with matrix
    2417 
    2418      delete rowCopy_;
    2419      rowCopy_ = NULL;
    2420      delete scaledMatrix_;
    2421      scaledMatrix_ = NULL;
    2422      if (!matrix_)
    2423           createEmptyMatrix();
    2424      if (columns)
    2425           matrix_->appendCols(number, columns);
    2426      setRowScale(NULL);
    2427      setColumnScale(NULL);
    2428      if (lengthNames_) {
    2429           columnNames_.resize(numberColumns_);
    2430      }
     2324void ClpModel::addColumns(int number, const double *columnLower,
     2325  const double *columnUpper,
     2326  const double *objIn,
     2327  const CoinPackedVectorBase *const *columns)
     2328{
     2329  if (!number)
     2330    return;
     2331  whatsChanged_ &= ~(1 + 2 + 4 + 64 + 128 + 256); // all except rows changed
     2332  int numberColumnsNow = numberColumns_;
     2333  resize(numberRows_, numberColumnsNow + number);
     2334  double *lower = columnLower_ + numberColumnsNow;
     2335  double *upper = columnUpper_ + numberColumnsNow;
     2336  double *obj = objective() + numberColumnsNow;
     2337  int iColumn;
     2338  if (columnLower) {
     2339    for (iColumn = 0; iColumn < number; iColumn++) {
     2340      double value = columnLower[iColumn];
     2341      if (value < -1.0e20)
     2342        value = -COIN_DBL_MAX;
     2343      lower[iColumn] = value;
     2344    }
     2345  } else {
     2346    for (iColumn = 0; iColumn < number; iColumn++) {
     2347      lower[iColumn] = 0.0;
     2348    }
     2349  }
     2350  if (columnUpper) {
     2351    for (iColumn = 0; iColumn < number; iColumn++) {
     2352      double value = columnUpper[iColumn];
     2353      if (value > 1.0e20)
     2354        value = COIN_DBL_MAX;
     2355      upper[iColumn] = value;
     2356    }
     2357  } else {
     2358    for (iColumn = 0; iColumn < number; iColumn++) {
     2359      upper[iColumn] = COIN_DBL_MAX;
     2360    }
     2361  }
     2362  if (objIn) {
     2363    for (iColumn = 0; iColumn < number; iColumn++) {
     2364      obj[iColumn] = objIn[iColumn];
     2365    }
     2366  } else {
     2367    for (iColumn = 0; iColumn < number; iColumn++) {
     2368      obj[iColumn] = 0.0;
     2369    }
     2370  }
     2371  // Deal with matrix
     2372
     2373  delete rowCopy_;
     2374  rowCopy_ = NULL;
     2375  delete scaledMatrix_;
     2376  scaledMatrix_ = NULL;
     2377  if (!matrix_)
     2378    createEmptyMatrix();
     2379  if (columns)
     2380    matrix_->appendCols(number, columns);
     2381  setRowScale(NULL);
     2382  setColumnScale(NULL);
     2383  if (lengthNames_) {
     2384    columnNames_.resize(numberColumns_);
     2385  }
    24312386}
    24322387#endif
    24332388#ifndef SLIM_CLP
    24342389// Add columns from a build object
    2435 int
    2436 ClpModel::addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne, bool checkDuplicates)
    2437 {
    2438      CoinAssertHint (buildObject.type() == 1, "Looks as if both addRows and addCols being used"); // check correct
    2439      int number = buildObject.numberColumns();
    2440      int numberErrors = 0;
    2441      if (number) {
    2442           CoinBigIndex size = 0;
    2443           int maximumLength = 0;
    2444           double * lower = new double [number];
    2445           double * upper = new double [number];
    2446           int iColumn;
    2447           double * objective = new double [number];
    2448           if ((!matrix_ || !matrix_->getNumElements()) && tryPlusMinusOne) {
    2449                // See if can be +-1
    2450                for (iColumn = 0; iColumn < number; iColumn++) {
    2451                     const int * rows;
    2452                     const double * elements;
    2453                     int numberElements = buildObject.column(iColumn, lower[iColumn],
    2454                                                             upper[iColumn], objective[iColumn],
    2455                                                             rows, elements);
    2456                     maximumLength = CoinMax(maximumLength, numberElements);
    2457                     for (int i = 0; i < numberElements; i++) {
    2458                          // allow for zero elements
    2459                          if (elements[i]) {
    2460                               if (fabs(elements[i]) == 1.0) {
    2461                                    size++;
    2462                               } else {
    2463                                    // bad
    2464                                    tryPlusMinusOne = false;
    2465                               }
    2466                          }
    2467                     }
    2468                     if (!tryPlusMinusOne)
    2469                          break;
    2470                }
    2471           } else {
    2472                // Will add to whatever sort of matrix exists
    2473                tryPlusMinusOne = false;
     2390int ClpModel::addColumns(const CoinBuild &buildObject, bool tryPlusMinusOne, bool checkDuplicates)
     2391{
     2392  CoinAssertHint(buildObject.type() == 1, "Looks as if both addRows and addCols being used"); // check correct
     2393  int number = buildObject.numberColumns();
     2394  int numberErrors = 0;
     2395  if (number) {
     2396    CoinBigIndex size = 0;
     2397    int maximumLength = 0;
     2398    double *lower = new double[number];
     2399    double *upper = new double[number];
     2400    int iColumn;
     2401    double *objective = new double[number];
     2402    if ((!matrix_ || !matrix_->getNumElements()) && tryPlusMinusOne) {
     2403      // See if can be +-1
     2404      for (iColumn = 0; iColumn < number; iColumn++) {
     2405        const int *rows;
     2406        const double *elements;
     2407        int numberElements = buildObject.column(iColumn, lower[iColumn],
     2408          upper[iColumn], objective[iColumn],
     2409          rows, elements);
     2410        maximumLength = CoinMax(maximumLength, numberElements);
     2411        for (int i = 0; i < numberElements; i++) {
     2412          // allow for zero elements
     2413          if (elements[i]) {
     2414            if (fabs(elements[i]) == 1.0) {
     2415              size++;
     2416            } else {
     2417              // bad
     2418              tryPlusMinusOne = false;
     2419            }
    24742420          }
    2475           if (!tryPlusMinusOne) {
    2476                CoinBigIndex numberElements = buildObject.numberElements();
    2477                CoinBigIndex * starts = new CoinBigIndex [number+1];
    2478                int * row = new int[numberElements];
    2479                double * element = new double[numberElements];
    2480                starts[0] = 0;
    2481                numberElements = 0;
    2482                for (iColumn = 0; iColumn < number; iColumn++) {
    2483                     const int * rows;
    2484                     const double * elements;
    2485                     int numberElementsThis = buildObject.column(iColumn, lower[iColumn], upper[iColumn],
    2486                                              objective[iColumn], rows, elements);
    2487                     CoinMemcpyN(rows, numberElementsThis, row + numberElements);
    2488                     CoinMemcpyN(elements, numberElementsThis, element + numberElements);
    2489                     numberElements += numberElementsThis;
    2490                     starts[iColumn+1] = numberElements;
    2491                }
    2492                addColumns(number, lower, upper, objective, NULL);
    2493                // make sure matrix has enough rows
    2494                matrix_->setDimensions(numberRows_, -1);
    2495                numberErrors = matrix_->appendMatrix(number, 1, starts, row, element,
    2496                                                     checkDuplicates ? numberRows_ : -1);
    2497                delete [] starts;
    2498                delete [] row;
    2499                delete [] element;
    2500           } else {
    2501                // arrays already filled in
    2502                addColumns(number, lower, upper, objective, NULL);
    2503                char * which = NULL; // for duplicates
    2504                if (checkDuplicates) {
    2505                     which = new char[numberRows_];
    2506                     CoinZeroN(which, numberRows_);
    2507                }
    2508                // build +-1 matrix
    2509                CoinBigIndex * startPositive = new CoinBigIndex [number+1];
    2510                CoinBigIndex * startNegative = new CoinBigIndex [number];
    2511                int * indices = new int [size];
    2512                int * neg = new int[maximumLength];
    2513                startPositive[0] = 0;
    2514                size = 0;
    2515                int maxRow = -1;
    2516                for (iColumn = 0; iColumn < number; iColumn++) {
    2517                     const int * rows;
    2518                     const double * elements;
    2519                     int numberElements = buildObject.column(iColumn, lower[iColumn],
    2520                                                             upper[iColumn], objective[iColumn],
    2521                                                             rows, elements);
    2522                     int nNeg = 0;
    2523                     CoinBigIndex start = size;
    2524                     for (int i = 0; i < numberElements; i++) {
    2525                          int iRow = rows[i];
    2526                          if (checkDuplicates) {
    2527                               if (iRow < numberRows_) {
    2528                                    if(which[iRow])
    2529                                         numberErrors++;
    2530                                    else
    2531                                         which[iRow] = 1;
    2532                               } else {
    2533                                    numberErrors++;
    2534                                    // and may as well switch off
    2535                                    checkDuplicates = false;
    2536                               }
    2537                          }
    2538                          maxRow = CoinMax(maxRow, iRow);
    2539                          if (elements[i] == 1.0) {
    2540                               indices[size++] = iRow;
    2541                          } else if (elements[i] == -1.0) {
    2542                               neg[nNeg++] = iRow;
    2543                          }
    2544                     }
    2545                     std::sort(indices + start, indices + size);
    2546                     std::sort(neg, neg + nNeg);
    2547                     startNegative[iColumn] = size;
    2548                     CoinMemcpyN(neg, nNeg, indices + size);
    2549                     size += nNeg;
    2550                     startPositive[iColumn+1] = size;
    2551                }
    2552                delete [] neg;
    2553                // check size
    2554                assert (maxRow + 1 <= numberRows_);
    2555                // Get good object
    2556                delete matrix_;
    2557                ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    2558                matrix->passInCopy(numberRows_, number, true, indices, startPositive, startNegative);
    2559                matrix_ = matrix;
    2560                delete [] which;
     2421        }
     2422        if (!tryPlusMinusOne)
     2423          break;
     2424      }
     2425    } else {
     2426      // Will add to whatever sort of matrix exists
     2427      tryPlusMinusOne = false;
     2428    }
     2429    if (!tryPlusMinusOne) {
     2430      CoinBigIndex numberElements = buildObject.numberElements();
     2431      CoinBigIndex *starts = new CoinBigIndex[number + 1];
     2432      int *row = new int[numberElements];
     2433      double *element = new double[numberElements];
     2434      starts[0] = 0;
     2435      numberElements = 0;
     2436      for (iColumn = 0; iColumn < number; iColumn++) {
     2437        const int *rows;
     2438        const double *elements;
     2439        int numberElementsThis = buildObject.column(iColumn, lower[iColumn], upper[iColumn],
     2440          objective[iColumn], rows, elements);
     2441        CoinMemcpyN(rows, numberElementsThis, row + numberElements);
     2442        CoinMemcpyN(elements, numberElementsThis, element + numberElements);
     2443        numberElements += numberElementsThis;
     2444        starts[iColumn + 1] = numberElements;
     2445      }
     2446      addColumns(number, lower, upper, objective, NULL);
     2447      // make sure matrix has enough rows
     2448      matrix_->setDimensions(numberRows_, -1);
     2449      numberErrors = matrix_->appendMatrix(number, 1, starts, row, element,
     2450        checkDuplicates ? numberRows_ : -1);
     2451      delete[] starts;
     2452      delete[] row;
     2453      delete[] element;
     2454    } else {
     2455      // arrays already filled in
     2456      addColumns(number, lower, upper, objective, NULL);
     2457      char *which = NULL; // for duplicates
     2458      if (checkDuplicates) {
     2459        which = new char[numberRows_];
     2460        CoinZeroN(which, numberRows_);
     2461      }
     2462      // build +-1 matrix
     2463      CoinBigIndex *startPositive = new CoinBigIndex[number + 1];
     2464      CoinBigIndex *startNegative = new CoinBigIndex[number];
     2465      int *indices = new int[size];
     2466      int *neg = new int[maximumLength];
     2467      startPositive[0] = 0;
     2468      size = 0;
     2469      int maxRow = -1;
     2470      for (iColumn = 0; iColumn < number; iColumn++) {
     2471        const int *rows;
     2472        const double *elements;
     2473        int numberElements = buildObject.column(iColumn, lower[iColumn],
     2474          upper[iColumn], objective[iColumn],
     2475          rows, elements);
     2476        int nNeg = 0;
     2477        CoinBigIndex start = size;
     2478        for (int i = 0; i < numberElements; i++) {
     2479          int iRow = rows[i];
     2480          if (checkDuplicates) {
     2481            if (iRow < numberRows_) {
     2482              if (which[iRow])
     2483                numberErrors++;
     2484              else
     2485                which[iRow] = 1;
     2486            } else {
     2487              numberErrors++;
     2488              // and may as well switch off
     2489              checkDuplicates = false;
     2490            }
    25612491          }
    2562           delete [] objective;
    2563           delete [] lower;
    2564           delete [] upper;
    2565      }
    2566      return 0;
     2492          maxRow = CoinMax(maxRow, iRow);
     2493          if (elements[i] == 1.0) {
     2494            indices[size++] = iRow;
     2495          } else if (elements[i] == -1.0) {
     2496            neg[nNeg++] = iRow;
     2497          }
     2498        }
     2499        std::sort(indices + start, indices + size);
     2500        std::sort(neg, neg + nNeg);
     2501        startNegative[iColumn] = size;
     2502        CoinMemcpyN(neg, nNeg, indices + size);
     2503        size += nNeg;
     2504        startPositive[iColumn + 1] = size;
     2505      }
     2506      delete[] neg;
     2507      // check size
     2508      assert(maxRow + 1 <= numberRows_);
     2509      // Get good object
     2510      delete matrix_;
     2511      ClpPlusMinusOneMatrix *matrix = new ClpPlusMinusOneMatrix();
     2512      matrix->passInCopy(numberRows_, number, true, indices, startPositive, startNegative);
     2513      matrix_ = matrix;
     2514      delete[] which;
     2515    }
     2516    delete[] objective;
     2517    delete[] lower;
     2518    delete[] upper;
     2519  }
     2520  return 0;
    25672521}
    25682522#endif
    25692523#ifndef SLIM_NOIO
    25702524// Add columns from a model object
    2571 int
    2572 ClpModel::addColumns( CoinModel & modelObject, bool tryPlusMinusOne, bool checkDuplicates)
    2573 {
    2574      if (modelObject.numberElements() == 0)
    2575           return 0;
    2576      bool goodState = true;
    2577      if (modelObject.rowLowerArray()) {
    2578           // some row information exists
    2579           int numberRows2 = modelObject.numberRows();
    2580           const double * rowLower = modelObject.rowLowerArray();
    2581           const double * rowUpper = modelObject.rowUpperArray();
    2582           for (int i = 0; i < numberRows2; i++) {
    2583                if (rowLower[i] != -COIN_DBL_MAX)
    2584                     goodState = false;
    2585                if (rowUpper[i] != COIN_DBL_MAX)
    2586                     goodState = false;
    2587           }
    2588      }
    2589      if (goodState) {
    2590           // can do addColumns
    2591           int numberErrors = 0;
    2592           // Set arrays for normal use
    2593           double * rowLower = modelObject.rowLowerArray();
    2594           double * rowUpper = modelObject.rowUpperArray();
    2595           double * columnLower = modelObject.columnLowerArray();
    2596           double * columnUpper = modelObject.columnUpperArray();
    2597           double * objective = modelObject.objectiveArray();
    2598           int * integerType = modelObject.integerTypeArray();
    2599           double * associated = modelObject.associatedArray();
    2600           // If strings then do copies
    2601           if (modelObject.stringsExist()) {
    2602                numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
    2603                                                        objective, integerType, associated);
    2604           }
    2605           int numberColumns = numberColumns_; // save number of columns
    2606           int numberColumns2 = modelObject.numberColumns();
    2607           if (numberColumns2 && !numberErrors) {
    2608                CoinBigIndex * startPositive = NULL;
    2609                CoinBigIndex * startNegative = NULL;
    2610                if ((!matrix_ || !matrix_->getNumElements()) && !numberColumns && tryPlusMinusOne) {
    2611                     startPositive = new CoinBigIndex[numberColumns2+1];
    2612                     startNegative = new CoinBigIndex[numberColumns2];
    2613                     modelObject.countPlusMinusOne(startPositive, startNegative, associated);
    2614                     if (startPositive[0] < 0) {
    2615                          // no good
    2616                          tryPlusMinusOne = false;
    2617                          delete [] startPositive;
    2618                          delete [] startNegative;
    2619                     }
    2620                } else {
    2621                     // Will add to whatever sort of matrix exists
    2622                     tryPlusMinusOne = false;
    2623                }
    2624                assert (columnLower);
     2525int ClpModel::addColumns(CoinModel &modelObject, bool tryPlusMinusOne, bool checkDuplicates)
     2526{
     2527  if (modelObject.numberElements() == 0)
     2528    return 0;
     2529  bool goodState = true;
     2530  if (modelObject.rowLowerArray()) {
     2531    // some row information exists
     2532    int numberRows2 = modelObject.numberRows();
     2533    const double *rowLower = modelObject.rowLowerArray();
     2534    const double *rowUpper = modelObject.rowUpperArray();
     2535    for (int i = 0; i < numberRows2; i++) {
     2536      if (rowLower[i] != -COIN_DBL_MAX)
     2537        goodState = false;
     2538      if (rowUpper[i] != COIN_DBL_MAX)
     2539        goodState = false;
     2540    }
     2541  }
     2542  if (goodState) {
     2543    // can do addColumns
     2544    int numberErrors = 0;
     2545    // Set arrays for normal use
     2546    double *rowLower = modelObject.rowLowerArray();
     2547    double *rowUpper = modelObject.rowUpperArray();
     2548    double *columnLower = modelObject.columnLowerArray();
     2549    double *columnUpper = modelObject.columnUpperArray();
     2550    double *objective = modelObject.objectiveArray();
     2551    int *integerType = modelObject.integerTypeArray();
     2552    double *associated = modelObject.associatedArray();
     2553    // If strings then do copies
     2554    if (modelObject.stringsExist()) {
     2555      numberErrors = modelObject.createArrays(rowLower, rowUpper, columnLower, columnUpper,
     2556        objective, integerType, associated);
     2557    }
     2558    int numberColumns = numberColumns_; // save number of columns
     2559    int numberColumns2 = modelObject.numberColumns();
     2560    if (numberColumns2 && !numberErrors) {
     2561      CoinBigIndex *startPositive = NULL;
     2562      CoinBigIndex *startNegative = NULL;
     2563      if ((!matrix_ || !matrix_->getNumElements()) && !numberColumns && tryPlusMinusOne) {
     2564        startPositive = new CoinBigIndex[numberColumns2 + 1];
     2565        startNegative = new CoinBigIndex[numberColumns2];
     2566        modelObject.countPlusMinusOne(startPositive, startNegative, associated);
     2567        if (startPositive[0] < 0) {
     2568          // no good
     2569          tryPlusMinusOne = false;
     2570          delete[] startPositive;
     2571          delete[] startNegative;
     2572        }
     2573      } else {
     2574        // Will add to whatever sort of matrix exists
     2575        tryPlusMinusOne = false;
     2576      }
     2577      assert(columnLower);
    26252578#ifndef SLIM_CLP
    2626                if (!tryPlusMinusOne) {
    2627 #endif
    2628                     CoinPackedMatrix matrix;
    2629                     modelObject.createPackedMatrix(matrix, associated);
    2630                     assert (!matrix.getExtraGap());
    2631                     const int * row = matrix.getIndices();
    2632                     //const int * columnLength = matrix.getVectorLengths();
    2633                     const CoinBigIndex * columnStart = matrix.getVectorStarts();
    2634                     const double * element = matrix.getElements();
    2635                     // make sure matrix has enough rows
    2636                     matrix_->setDimensions(numberRows_, -1);
    2637                     addColumns(numberColumns2, columnLower, columnUpper,
    2638                                objective, columnStart, row, element);
     2579      if (!tryPlusMinusOne) {
     2580#endif
     2581        CoinPackedMatrix matrix;
     2582        modelObject.createPackedMatrix(matrix, associated);
     2583        assert(!matrix.getExtraGap());
     2584        const int *row = matrix.getIndices();
     2585        //const int * columnLength = matrix.getVectorLengths();
     2586        const CoinBigIndex *columnStart = matrix.getVectorStarts();
     2587        const double *element = matrix.getElements();
     2588        // make sure matrix has enough rows
     2589        matrix_->setDimensions(numberRows_, -1);
     2590        addColumns(numberColumns2, columnLower, columnUpper,
     2591          objective, columnStart, row, element);
    26392592#ifndef SLIM_CLP
    2640                } else {
    2641                     addColumns(numberColumns2, columnLower, columnUpper, objective, NULL, NULL, NULL);
    2642                     // create +-1 matrix
    2643                     CoinBigIndex size = startPositive[numberColumns2];
    2644                     int * indices = new int[size];
    2645                     modelObject.createPlusMinusOne(startPositive, startNegative, indices,
    2646                                                    associated);
    2647                     // Get good object
    2648                     ClpPlusMinusOneMatrix * matrix = new ClpPlusMinusOneMatrix();
    2649                     matrix->passInCopy(numberRows_, numberColumns2,
    2650                                        true, indices, startPositive, startNegative);
    2651                     delete matrix_;
    2652                     matrix_ = matrix;
    2653                }
     2593      } else {
     2594        addColumns(numberColumns2, columnLower, columnUpper, objective, NULL, NULL, NULL);
     2595        // create +-1 matrix
     2596        CoinBigIndex size = startPositive[numberColumns2];
     2597        int *indices = new int[size];
     2598        modelObject.createPlusMinusOne(startPositive, startNegative, indices,
     2599          associated);
     2600        // Get good object
     2601        ClpPlusMinusOneMatrix *matrix = new ClpPlusMinusOneMatrix();
     2602        matrix->passInCopy(numberRows_, numberColumns2,
     2603          true, indices, startPositive, startNegative);
     2604        delete matrix_;
     2605        matrix_ = matrix;
     2606      }
    26542607#endif
    26552608#ifndef CLP_NO_STD
    2656                // Do names if wanted
    2657                if (modelObject.columnNames()->numberItems()) {
    2658                     const char *const * columnNames = modelObject.columnNames()->names();
    2659                     copyColumnNames(columnNames, numberColumns, numberColumns_);
    2660                }
    2661 #endif
    2662                // Do integers if wanted
    2663                assert(integerType);
    2664                for (int iColumn = 0; iColumn < numberColumns2; iColumn++) {
    2665                     if (integerType[iColumn])
    2666                          setInteger(iColumn + numberColumns);
    2667                }
    2668           }
    2669           if (columnLower != modelObject.columnLowerArray()) {
    2670                delete [] rowLower;
    2671                delete [] rowUpper;
    2672                delete [] columnLower;
    2673                delete [] columnUpper;
    2674                delete [] objective;
    2675                delete [] integerType;
    2676                delete [] associated;
    2677                if (numberErrors)
    2678                     handler_->message(CLP_BAD_STRING_VALUES, messages_)
    2679                               << numberErrors
    2680                               << CoinMessageEol;
    2681           }
    2682           return numberErrors;
    2683      } else {
    2684           // not suitable for addColumns
    2685           handler_->message(CLP_COMPLICATED_MODEL, messages_)
    2686                     << modelObject.numberRows()
    2687                     << modelObject.numberColumns()
    2688                     << CoinMessageEol;
    2689           return -1;
    2690      }
     2609      // Do names if wanted
     2610      if (modelObject.columnNames()->numberItems()) {
     2611        const char *const *columnNames = modelObject.columnNames()->names();
     2612        copyColumnNames(columnNames, numberColumns, numberColumns_);
     2613      }
     2614#endif
     2615      // Do integers if wanted
     2616      assert(integerType);
     2617      for (int iColumn = 0; iColumn < numberColumns2; iColumn++) {
     2618        if (integerType[iColumn])
     2619          setInteger(iColumn + numberColumns);
     2620      }
     2621    }
     2622    if (columnLower != modelObject.columnLowerArray()) {
     2623      delete[] rowLower;
     2624      delete[] rowUpper;
     2625      delete[] columnLower;
     2626      delete[] columnUpper;
     2627      delete[] objective;
     2628      delete[] integerType;
     2629      delete[] associated;
     2630      if (numberErrors)
     2631        handler_->message(CLP_BAD_STRING_VALUES, messages_)
     2632          << numberErrors
     2633          << CoinMessageEol;
     2634    }
     2635    return numberErrors;
     2636  } else {
     2637    // not suitable for addColumns
     2638    handler_->message(CLP_COMPLICATED_MODEL, messages_)
     2639      << modelObject.numberRows()
     2640      << modelObject.numberColumns()
     2641      << CoinMessageEol;
     2642    return -1;
     2643  }
    26912644}
    26922645#endif
    26932646// chgRowLower
    2694 void
    2695 ClpModel::chgRowLower(const double * rowLower)
    2696 {
    2697      int numberRows = numberRows_;
    2698      int iRow;
    2699      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2700      if (rowLower) {
    2701           for (iRow = 0; iRow < numberRows; iRow++) {
    2702                double value = rowLower[iRow];
    2703                if (value < -1.0e20)
    2704                     value = -COIN_DBL_MAX;
    2705                rowLower_[iRow] = value;
    2706           }
    2707      } else {
    2708           for (iRow = 0; iRow < numberRows; iRow++) {
    2709                rowLower_[iRow] = -COIN_DBL_MAX;
    2710           }
    2711      }
     2647void ClpModel::chgRowLower(const double *rowLower)
     2648{
     2649  int numberRows = numberRows_;
     2650  int iRow;
     2651  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2652  if (rowLower) {
     2653    for (iRow = 0; iRow < numberRows; iRow++) {
     2654      double value = rowLower[iRow];
     2655      if (value < -1.0e20)
     2656        value = -COIN_DBL_MAX;
     2657      rowLower_[iRow] = value;
     2658    }
     2659  } else {
     2660    for (iRow = 0; iRow < numberRows; iRow++) {
     2661      rowLower_[iRow] = -COIN_DBL_MAX;
     2662    }
     2663  }
    27122664}
    27132665// chgRowUpper
    2714 void
    2715 ClpModel::chgRowUpper(const double * rowUpper)
    2716 {
    2717      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2718      int numberRows = numberRows_;
    2719      int iRow;
    2720      if (rowUpper) {
    2721           for (iRow = 0; iRow < numberRows; iRow++) {
    2722                double value = rowUpper[iRow];
    2723                if (value > 1.0e20)
    2724                     value = COIN_DBL_MAX;
    2725                rowUpper_[iRow] = value;
    2726           }
    2727      } else {
    2728           for (iRow = 0; iRow < numberRows; iRow++) {
    2729                rowUpper_[iRow] = COIN_DBL_MAX;;
    2730           }
    2731      }
     2666void ClpModel::chgRowUpper(const double *rowUpper)
     2667{
     2668  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2669  int numberRows = numberRows_;
     2670  int iRow;
     2671  if (rowUpper) {
     2672    for (iRow = 0; iRow < numberRows; iRow++) {
     2673      double value = rowUpper[iRow];
     2674      if (value > 1.0e20)
     2675        value = COIN_DBL_MAX;
     2676      rowUpper_[iRow] = value;
     2677    }
     2678  } else {
     2679    for (iRow = 0; iRow < numberRows; iRow++) {
     2680      rowUpper_[iRow] = COIN_DBL_MAX;
     2681      ;
     2682    }
     2683  }
    27322684}
    27332685// chgColumnLower
    2734 void
    2735 ClpModel::chgColumnLower(const double * columnLower)
    2736 {
    2737      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2738      int numberColumns = numberColumns_;
    2739      int iColumn;
    2740      if (columnLower) {
    2741           for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2742                double value = columnLower[iColumn];
    2743                if (value < -1.0e20)
    2744                     value = -COIN_DBL_MAX;
    2745                columnLower_[iColumn] = value;
    2746           }
    2747      } else {
    2748           for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2749                columnLower_[iColumn] = 0.0;
    2750           }
    2751      }
     2686void ClpModel::chgColumnLower(const double *columnLower)
     2687{
     2688  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2689  int numberColumns = numberColumns_;
     2690  int iColumn;
     2691  if (columnLower) {
     2692    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2693      double value = columnLower[iColumn];
     2694      if (value < -1.0e20)
     2695        value = -COIN_DBL_MAX;
     2696      columnLower_[iColumn] = value;
     2697    }
     2698  } else {
     2699    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2700      columnLower_[iColumn] = 0.0;
     2701    }
     2702  }
    27522703}
    27532704// chgColumnUpper
    2754 void
    2755 ClpModel::chgColumnUpper(const double * columnUpper)
    2756 {
    2757      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2758      int numberColumns = numberColumns_;
    2759      int iColumn;
    2760      if (columnUpper) {
    2761           for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2762                double value = columnUpper[iColumn];
    2763                if (value > 1.0e20)
    2764                     value = COIN_DBL_MAX;
    2765                columnUpper_[iColumn] = value;
    2766           }
    2767      } else {
    2768           for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2769                columnUpper_[iColumn] = COIN_DBL_MAX;;
    2770           }
    2771      }
     2705void ClpModel::chgColumnUpper(const double *columnUpper)
     2706{
     2707  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2708  int numberColumns = numberColumns_;
     2709  int iColumn;
     2710  if (columnUpper) {
     2711    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2712      double value = columnUpper[iColumn];
     2713      if (value > 1.0e20)
     2714        value = COIN_DBL_MAX;
     2715      columnUpper_[iColumn] = value;
     2716    }
     2717  } else {
     2718    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2719      columnUpper_[iColumn] = COIN_DBL_MAX;
     2720      ;
     2721    }
     2722  }
    27722723}
    27732724// chgObjCoefficients
    2774 void
    2775 ClpModel::chgObjCoefficients(const double * objIn)
    2776 {
    2777      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    2778      double * obj = objective();
    2779      int numberColumns = numberColumns_;
    2780      int iColumn;
    2781      if (objIn) {
    2782           for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2783                obj[iColumn] = objIn[iColumn];
    2784           }
    2785      } else {
    2786           for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    2787                obj[iColumn] = 0.0;
    2788           }
    2789      }
     2725void ClpModel::chgObjCoefficients(const double *objIn)
     2726{
     2727  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     2728  double *obj = objective();
     2729  int numberColumns = numberColumns_;
     2730  int iColumn;
     2731  if (objIn) {
     2732    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2733      obj[iColumn] = objIn[iColumn];
     2734    }
     2735  } else {
     2736    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2737      obj[iColumn] = 0.0;
     2738    }
     2739  }
    27902740}
    27912741// Infeasibility/unbounded ray (NULL returned if none/wrong)
     
    27932743ClpModel::infeasibilityRay(bool fullRay) const
    27942744{
    2795      double * array = NULL;
    2796      if (problemStatus_ == 1 && ray_) {
    2797        if (!fullRay) {
    2798         array = ClpCopyOfArray(ray_, numberRows_);
    2799        } else {
    2800          array = new double [numberRows_+numberColumns_];
    2801          memcpy(array,ray_,numberRows_*sizeof(double));
    2802          memset(array+numberRows_,0,numberColumns_*sizeof(double));
    2803          transposeTimes(-1.0,array,array+numberRows_);
    2804        }
    2805      }
    2806      return array;
     2745  double *array = NULL;
     2746  if (problemStatus_ == 1 && ray_) {
     2747    if (!fullRay) {
     2748      array = ClpCopyOfArray(ray_, numberRows_);
     2749    } else {
     2750      array = new double[numberRows_ + numberColumns_];
     2751      memcpy(array, ray_, numberRows_ * sizeof(double));
     2752      memset(array + numberRows_, 0, numberColumns_ * sizeof(double));
     2753      transposeTimes(-1.0, array, array + numberRows_);
     2754    }
     2755  }
     2756  return array;
    28072757}
    28082758double *
    28092759ClpModel::unboundedRay() const
    28102760{
    2811      double * array = NULL;
    2812      if (problemStatus_ == 2)
    2813           array = ClpCopyOfArray(ray_, numberColumns_);
    2814      return array;
    2815 }
    2816 void
    2817 ClpModel::setMaximumIterations(int value)
    2818 {
    2819      if(value >= 0)
    2820           intParam_[ClpMaxNumIteration] = value;
    2821 }
    2822 void
    2823 ClpModel::setMaximumSeconds(double value)
    2824 {
    2825      if(value >= 0)
    2826           dblParam_[ClpMaxSeconds] = value + CoinCpuTime();
    2827      else
    2828           dblParam_[ClpMaxSeconds] = -1.0;
    2829 }
    2830 void
    2831 ClpModel::setMaximumWallSeconds(double value)
    2832 {
    2833      if(value >= 0)
    2834           dblParam_[ClpMaxWallSeconds] = value + CoinWallclockTime();
    2835      else
    2836           dblParam_[ClpMaxWallSeconds] = -1.0;
     2761  double *array = NULL;
     2762  if (problemStatus_ == 2)
     2763    array = ClpCopyOfArray(ray_, numberColumns_);
     2764  return array;
     2765}
     2766void ClpModel::setMaximumIterations(int value)
     2767{
     2768  if (value >= 0)
     2769    intParam_[ClpMaxNumIteration] = value;
     2770}
     2771void ClpModel::setMaximumSeconds(double value)
     2772{
     2773  if (value >= 0)
     2774    dblParam_[ClpMaxSeconds] = value + CoinCpuTime();
     2775  else
     2776    dblParam_[ClpMaxSeconds] = -1.0;
     2777}
     2778void ClpModel::setMaximumWallSeconds(double value)
     2779{
     2780  if (value >= 0)
     2781    dblParam_[ClpMaxWallSeconds] = value + CoinWallclockTime();
     2782  else
     2783    dblParam_[ClpMaxWallSeconds] = -1.0;
    28372784}
    28382785// Returns true if hit maximum iterations (or time)
    2839 bool
    2840 ClpModel::hitMaximumIterations() const
    2841 {
    2842      // replaced - compiler error? bool hitMax= (numberIterations_>=maximumIterations());
    2843      bool hitMax = (numberIterations_ >= intParam_[ClpMaxNumIteration]);
    2844      if (dblParam_[ClpMaxSeconds] >= 0.0 && !hitMax) {
    2845           hitMax = (CoinCpuTime() >= dblParam_[ClpMaxSeconds]);
    2846      }
    2847      if (dblParam_[ClpMaxWallSeconds] >= 0.0 && !hitMax) {
    2848           hitMax = (CoinWallclockTime() >= dblParam_[ClpMaxWallSeconds]);
    2849      }
    2850      return hitMax;
     2786bool ClpModel::hitMaximumIterations() const
     2787{
     2788  // replaced - compiler error? bool hitMax= (numberIterations_>=maximumIterations());
     2789  bool hitMax = (numberIterations_ >= intParam_[ClpMaxNumIteration]);
     2790  if (dblParam_[ClpMaxSeconds] >= 0.0 && !hitMax) {
     2791    hitMax = (CoinCpuTime() >= dblParam_[ClpMaxSeconds]);
     2792  }
     2793  if (dblParam_[ClpMaxWallSeconds] >= 0.0 && !hitMax) {
     2794    hitMax = (CoinWallclockTime() >= dblParam_[ClpMaxWallSeconds]);
     2795  }
     2796  return hitMax;
    28512797}
    28522798// On stopped - sets secondary status
    2853 void
    2854 ClpModel::onStopped()
    2855 {
    2856      if (problemStatus_ == 3) {
    2857           secondaryStatus_ = 0;
    2858           if ((CoinCpuTime() >= dblParam_[ClpMaxSeconds] && dblParam_[ClpMaxSeconds] >= 0.0) ||
    2859               (CoinWallclockTime() >= dblParam_[ClpMaxWallSeconds] && dblParam_[ClpMaxWallSeconds] >= 0.0))
    2860                secondaryStatus_ = 9;
    2861      }
     2799void ClpModel::onStopped()
     2800{
     2801  if (problemStatus_ == 3) {
     2802    secondaryStatus_ = 0;
     2803    if ((CoinCpuTime() >= dblParam_[ClpMaxSeconds] && dblParam_[ClpMaxSeconds] >= 0.0) || (CoinWallclockTime() >= dblParam_[ClpMaxWallSeconds] && dblParam_[ClpMaxWallSeconds] >= 0.0))
     2804      secondaryStatus_ = 9;
     2805  }
    28622806}
    28632807// Pass in Message handler (not deleted at end)
    2864 void
    2865 ClpModel::passInMessageHandler(CoinMessageHandler * handler)
    2866 {
    2867      if (defaultHandler_)
    2868           delete handler_;
    2869      defaultHandler_ = false;
    2870      handler_ = handler;
     2808void ClpModel::passInMessageHandler(CoinMessageHandler *handler)
     2809{
     2810  if (defaultHandler_)
     2811    delete handler_;
     2812  defaultHandler_ = false;
     2813  handler_ = handler;
    28712814}
    28722815// Pass in Message handler (not deleted at end) and return current
    28732816CoinMessageHandler *
    2874 ClpModel::pushMessageHandler(CoinMessageHandler * handler,
    2875                              bool & oldDefault)
    2876 {
    2877      CoinMessageHandler * returnValue = handler_;
    2878      oldDefault = defaultHandler_;
    2879      defaultHandler_ = false;
    2880      handler_ = handler;
    2881      return returnValue;
     2817ClpModel::pushMessageHandler(CoinMessageHandler *handler,
     2818  bool &oldDefault)
     2819{
     2820  CoinMessageHandler *returnValue = handler_;
     2821  oldDefault = defaultHandler_;
     2822  defaultHandler_ = false;
     2823  handler_ = handler;
     2824  return returnValue;
    28822825}
    28832826// back to previous message handler
    2884 void
    2885 ClpModel::popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault)
    2886 {
    2887      if (defaultHandler_)
    2888           delete handler_;
    2889      defaultHandler_ = oldDefault;
    2890      handler_ = oldHandler;
     2827void ClpModel::popMessageHandler(CoinMessageHandler *oldHandler, bool oldDefault)
     2828{
     2829  if (defaultHandler_)
     2830    delete handler_;
     2831  defaultHandler_ = oldDefault;
     2832  handler_ = oldHandler;
    28912833}
    28922834// Overrides message handler with a default one
    2893 void
    2894 ClpModel::setDefaultMessageHandler()
    2895 {
    2896      int logLevel = handler_->logLevel();
    2897      if (defaultHandler_)
    2898           delete handler_;
    2899      defaultHandler_ = true;
    2900      handler_ = new CoinMessageHandler();
    2901      handler_->setLogLevel(logLevel);
     2835void ClpModel::setDefaultMessageHandler()
     2836{
     2837  int logLevel = handler_->logLevel();
     2838  if (defaultHandler_)
     2839    delete handler_;
     2840  defaultHandler_ = true;
     2841  handler_ = new CoinMessageHandler();
     2842  handler_->setLogLevel(logLevel);
    29022843}
    29032844// Set language
    2904 void
    2905 ClpModel::newLanguage(CoinMessages::Language language)
    2906 {
    2907      messages_ = ClpMessage(language);
     2845void ClpModel::newLanguage(CoinMessages::Language language)
     2846{
     2847  messages_ = ClpMessage(language);
    29082848}
    29092849#ifndef SLIM_NOIO
    29102850// Read an mps file from the given filename
    2911 int
    2912 ClpModel::readMps(const char *fileName,
    2913                   bool keepNames,
    2914                   bool ignoreErrors)
    2915 {
    2916      if (!strcmp(fileName, "-") || !strcmp(fileName, "stdin")) {
    2917           // stdin
    2918      } else {
    2919           std::string name = fileName;
    2920           bool readable = fileCoinReadable(name);
    2921           if (!readable) {
    2922                handler_->message(CLP_UNABLE_OPEN, messages_)
    2923                          << fileName << CoinMessageEol;
    2924                return -1;
    2925           }
    2926      }
    2927      CoinMpsIO m;
    2928      m.passInMessageHandler(handler_);
    2929      *m.messagesPointer() = coinMessages();
    2930      bool savePrefix = m.messageHandler()->prefix();
    2931      m.messageHandler()->setPrefix(handler_->prefix());
    2932      m.setSmallElementValue(CoinMax(smallElement_, m.getSmallElementValue()));
    2933      double time1 = CoinCpuTime(), time2;
    2934      int status = 0;
    2935      try {
    2936           status = m.readMps(fileName, "");
    2937      } catch (CoinError e) {
    2938           e.print();
    2939           status = -1;
    2940      }
    2941      m.messageHandler()->setPrefix(savePrefix);
    2942      if (!status || (ignoreErrors && (status > 0 && status < 100000))) {
    2943           loadProblem(*m.getMatrixByCol(),
    2944                       m.getColLower(), m.getColUpper(),
    2945                       m.getObjCoefficients(),
    2946                       m.getRowLower(), m.getRowUpper());
    2947           if (m.integerColumns()) {
    2948                integerType_ = new char[numberColumns_];
    2949                CoinMemcpyN(m.integerColumns(), numberColumns_, integerType_);
    2950           } else {
    2951                integerType_ = NULL;
    2952           }
     2851int ClpModel::readMps(const char *fileName,
     2852  bool keepNames,
     2853  bool ignoreErrors)
     2854{
     2855  if (!strcmp(fileName, "-") || !strcmp(fileName, "stdin")) {
     2856    // stdin
     2857  } else {
     2858    std::string name = fileName;
     2859    bool readable = fileCoinReadable(name);
     2860    if (!readable) {
     2861      handler_->message(CLP_UNABLE_OPEN, messages_)
     2862        << fileName << CoinMessageEol;
     2863      return -1;
     2864    }
     2865  }
     2866  CoinMpsIO m;
     2867  m.passInMessageHandler(handler_);
     2868  *m.messagesPointer() = coinMessages();
     2869  bool savePrefix = m.messageHandler()->prefix();
     2870  m.messageHandler()->setPrefix(handler_->prefix());
     2871  m.setSmallElementValue(CoinMax(smallElement_, m.getSmallElementValue()));
     2872  double time1 = CoinCpuTime(), time2;
     2873  int status = 0;
     2874  try {
     2875    status = m.readMps(fileName, "");
     2876  } catch (CoinError e) {
     2877    e.print();
     2878    status = -1;
     2879  }
     2880  m.messageHandler()->setPrefix(savePrefix);
     2881  if (!status || (ignoreErrors && (status > 0 && status < 100000))) {
     2882    loadProblem(*m.getMatrixByCol(),
     2883      m.getColLower(), m.getColUpper(),
     2884      m.getObjCoefficients(),
     2885      m.getRowLower(), m.getRowUpper());
     2886    if (m.integerColumns()) {
     2887      integerType_ = new char[numberColumns_];
     2888      CoinMemcpyN(m.integerColumns(), numberColumns_, integerType_);
     2889    } else {
     2890      integerType_ = NULL;
     2891    }
    29532892#ifndef SLIM_CLP
    2954           // get quadratic part
    2955           if (m.reader()->whichSection (  ) == COIN_QUAD_SECTION ) {
    2956                CoinBigIndex * start = NULL;
    2957                int * column = NULL;
    2958                double * element = NULL;
    2959                status = m.readQuadraticMps(NULL, start, column, element, 2);
    2960                if (!status || ignoreErrors)
    2961                     loadQuadraticObjective(numberColumns_, start, column, element);
    2962                delete [] start;
    2963                delete [] column;
    2964                delete [] element;
    2965           }
     2893    // get quadratic part
     2894    if (m.reader()->whichSection() == COIN_QUAD_SECTION) {
     2895      CoinBigIndex *start = NULL;
     2896      int *column = NULL;
     2897      double *element = NULL;
     2898      status = m.readQuadraticMps(NULL, start, column, element, 2);
     2899      if (!status || ignoreErrors)
     2900        loadQuadraticObjective(numberColumns_, start, column, element);
     2901      delete[] start;
     2902      delete[] column;
     2903      delete[] element;
     2904    }
    29662905#endif
    29672906#ifndef CLP_NO_STD
    2968           // set problem name
    2969           setStrParam(ClpProbName, m.getProblemName());
    2970           // do names
    2971           if (keepNames) {
    2972                unsigned int maxLength = 0;
    2973                int iRow;
    2974                rowNames_ = std::vector<std::string> ();
    2975                columnNames_ = std::vector<std::string> ();
    2976                rowNames_.reserve(numberRows_);
    2977                for (iRow = 0; iRow < numberRows_; iRow++) {
    2978                     const char * name = m.rowName(iRow);
    2979                     maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
    2980                     rowNames_.push_back(name);
    2981                }
    2982 
    2983                int iColumn;
    2984                columnNames_.reserve(numberColumns_);
    2985                for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
    2986                     const char * name = m.columnName(iColumn);
    2987                     maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
    2988                     columnNames_.push_back(name);
    2989                }
    2990                lengthNames_ = static_cast<int> (maxLength);
    2991           } else {
    2992                lengthNames_ = 0;
    2993           }
    2994 #endif
    2995           setDblParam(ClpObjOffset, m.objectiveOffset());
    2996           time2 = CoinCpuTime();
    2997           handler_->message(CLP_IMPORT_RESULT, messages_)
    2998                     << fileName
    2999                     << time2 - time1 << CoinMessageEol;
    3000      } else {
    3001           // errors
    3002           handler_->message(CLP_IMPORT_ERRORS, messages_)
    3003                     << status << fileName << CoinMessageEol;
    3004      }
    3005 
    3006      return status;
     2907    // set problem name
     2908    setStrParam(ClpProbName, m.getProblemName());
     2909    // do names
     2910    if (keepNames) {
     2911      unsigned int maxLength = 0;
     2912      int iRow;
     2913      rowNames_ = std::vector< std::string >();
     2914      columnNames_ = std::vector< std::string >();
     2915      rowNames_.reserve(numberRows_);
     2916      for (iRow = 0; iRow < numberRows_; iRow++) {
     2917        const char *name = m.rowName(iRow);
     2918        maxLength = CoinMax(maxLength, static_cast< unsigned int >(strlen(name)));
     2919        rowNames_.push_back(name);
     2920      }
     2921
     2922      int iColumn;
     2923      columnNames_.reserve(numberColumns_);
     2924      for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     2925        const char *name = m.columnName(iColumn);
     2926        maxLength = CoinMax(maxLength, static_cast< unsigned int >(strlen(name)));
     2927        columnNames_.push_back(name);
     2928      }
     2929      lengthNames_ = static_cast< int >(maxLength);
     2930    } else {
     2931      lengthNames_ = 0;
     2932    }
     2933#endif
     2934    setDblParam(ClpObjOffset, m.objectiveOffset());
     2935    time2 = CoinCpuTime();
     2936    handler_->message(CLP_IMPORT_RESULT, messages_)
     2937      << fileName
     2938      << time2 - time1 << CoinMessageEol;
     2939  } else {
     2940    // errors
     2941    handler_->message(CLP_IMPORT_ERRORS, messages_)
     2942      << status << fileName << CoinMessageEol;
     2943  }
     2944
     2945  return status;
    30072946}
    30082947// Read GMPL files from the given filenames
    3009 int
    3010 ClpModel::readGMPL(const char *fileName, const char * dataName,
    3011                    bool keepNames)
    3012 {
    3013      FILE *fp = fopen(fileName, "r");
    3014      if (fp) {
    3015           // can open - lets go for it
    3016           fclose(fp);
    3017           if (dataName) {
    3018                fp = fopen(dataName, "r");
    3019                if (fp) {
    3020                     fclose(fp);
    3021                } else {
    3022                     handler_->message(CLP_UNABLE_OPEN, messages_)
    3023                               << dataName << CoinMessageEol;
    3024                     return -1;
    3025                }
    3026           }
    3027      } else {
    3028           handler_->message(CLP_UNABLE_OPEN, messages_)
    3029                     << fileName << CoinMessageEol;
    3030           return -1;
    3031      }
    3032      CoinMpsIO m;
    3033      m.passInMessageHandler(handler_);
    3034      *m.messagesPointer() = coinMessages();
    3035      bool savePrefix = m.messageHandler()->prefix();
    3036      m.messageHandler()->setPrefix(handler_->prefix());
    3037      double time1 = CoinCpuTime(), time2;
    3038      int status = m.readGMPL(fileName, dataName, keepNames);
    3039      m.messageHandler()->setPrefix(savePrefix);
    3040      if (!status) {
    3041           loadProblem(*m.getMatrixByCol(),
    3042                       m.getColLower(), m.getColUpper(),
    3043                       m.getObjCoefficients(),
    3044                       m.getRowLower(), m.getRowUpper());
    3045           if (m.integerColumns()) {
    3046                integerType_ = new char[numberColumns_];
    3047                CoinMemcpyN(m.integerColumns(), numberColumns_, integerType_);
    3048           } else {
    3049                integerType_ = NULL;
    3050           }
     2948int ClpModel::readGMPL(const char *fileName, const char *dataName,
     2949  bool keepNames)
     2950{
     2951  FILE *fp = fopen(fileName, "r");
     2952  if (fp) {
     2953    // can open - lets go for it
     2954    fclose(fp);
     2955    if (dataName) {
     2956      fp = fopen(dataName, "r");
     2957      if (fp) {
     2958        fclose(fp);
     2959      } else {
     2960        handler_->message(CLP_UNABLE_OPEN, messages_)
     2961          << dataName << CoinMessageEol;
     2962        return -1;
     2963      }
     2964    }
     2965  } else {
     2966    handler_->message(CLP_UNABLE_OPEN, messages_)
     2967      << fileName << CoinMessageEol;
     2968    return -1;
     2969  }
     2970  CoinMpsIO m;
     2971  m.passInMessageHandler(handler_);
     2972  *m.messagesPointer() = coinMessages();
     2973  bool savePrefix = m.messageHandler()->prefix();
     2974  m.messageHandler()->setPrefix(handler_->prefix());
     2975  double time1 = CoinCpuTime(), time2;
     2976  int status = m.readGMPL(fileName, dataName, keepNames);
     2977  m.messageHandler()->setPrefix(savePrefix);
     2978  if (!status) {
     2979    loadProblem(*m.getMatrixByCol(),
     2980      m.getColLower(), m.getColUpper(),
     2981      m.getObjCoefficients(),
     2982      m.getRowLower(), m.getRowUpper());
     2983    if (m.integerColumns()) {
     2984      integerType_ = new char[numberColumns_];
     2985      CoinMemcpyN(m.integerColumns(), numberColumns_, integerType_);
     2986    } else {
     2987      integerType_ = NULL;
     2988    }
    30512989#ifndef CLP_NO_STD
    3052           // set problem name
    3053           setStrParam(ClpProbName, m.getProblemName());
    3054           // do names
    3055           if (keepNames) {
    3056                unsigned int maxLength = 0;
    3057                int iRow;
    3058                rowNames_ = std::vector<std::string> ();
    3059                columnNames_ = std::vector<std::string> ();
    3060                rowNames_.reserve(numberRows_);
    3061                for (iRow = 0; iRow < numberRows_; iRow++) {
    3062                     const char * name = m.rowName(iRow);
    3063                     maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
    3064                     rowNames_.push_back(name);
    3065                }
    3066 
    3067                int iColumn;
    3068                columnNames_.reserve(numberColumns_);
    3069                for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
    3070                     const char * name = m.columnName(iColumn);
    3071                     maxLength = CoinMax(maxLength, static_cast<unsigned int> (strlen(name)));
    3072                     columnNames_.push_back(name);
    3073                }
    3074                lengthNames_ = static_cast<int> (maxLength);
    3075           } else {
    3076                lengthNames_ = 0;
    3077           }
    3078 #endif
    3079           setDblParam(ClpObjOffset, m.objectiveOffset());
    3080           time2 = CoinCpuTime();
    3081           handler_->message(CLP_IMPORT_RESULT, messages_)
    3082                     << fileName
    3083                     << time2 - time1 << CoinMessageEol;
    3084      } else {
    3085           // errors
    3086           handler_->message(CLP_IMPORT_ERRORS, messages_)
    3087                     << status << fileName << CoinMessageEol;
    3088      }
    3089      return status;
     2990    // set problem name
     2991    setStrParam(ClpProbName, m.getProblemName());
     2992    // do names
     2993    if (keepNames) {
     2994      unsigned int maxLength = 0;
     2995      int iRow;
     2996      rowNames_ = std::vector< std::string >();
     2997      columnNames_ = std::vector< std::string >();
     2998      rowNames_.reserve(numberRows_);
     2999      for (iRow = 0; iRow < numberRows_; iRow++) {
     3000        const char *name = m.rowName(iRow);
     3001        maxLength = CoinMax(maxLength, static_cast< unsigned int >(strlen(name)));
     3002        rowNames_.push_back(name);
     3003      }
     3004
     3005      int iColumn;
     3006      columnNames_.reserve(numberColumns_);
     3007      for (iColumn = 0; iColumn < numberColumns_; iColumn++) {
     3008        const char *name = m.columnName(iColumn);
     3009        maxLength = CoinMax(maxLength, static_cast< unsigned int >(strlen(name)));
     3010        columnNames_.push_back(name);
     3011      }
     3012      lengthNames_ = static_cast< int >(maxLength);
     3013    } else {
     3014      lengthNames_ = 0;
     3015    }
     3016#endif
     3017    setDblParam(ClpObjOffset, m.objectiveOffset());
     3018    time2 = CoinCpuTime();
     3019    handler_->message(CLP_IMPORT_RESULT, messages_)
     3020      << fileName
     3021      << time2 - time1 << CoinMessageEol;
     3022  } else {
     3023    // errors
     3024    handler_->message(CLP_IMPORT_ERRORS, messages_)
     3025      << status << fileName << CoinMessageEol;
     3026  }
     3027  return status;
    30903028}
    30913029#endif
    30923030bool ClpModel::isPrimalObjectiveLimitReached() const
    30933031{
    3094      double limit = 0.0;
    3095      getDblParam(ClpPrimalObjectiveLimit, limit);
    3096      if (limit > 1e30) {
    3097           // was not ever set
    3098           return false;
    3099      }
    3100 
    3101      const double obj = objectiveValue();
    3102      const double maxmin = optimizationDirection();
    3103 
    3104      if (problemStatus_ == 0) // optimal
    3105           return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
    3106      else if (problemStatus_ == 2)
    3107           return true;
    3108      else
    3109           return false;
     3032  double limit = 0.0;
     3033  getDblParam(ClpPrimalObjectiveLimit, limit);
     3034  if (limit > 1e30) {
     3035    // was not ever set
     3036    return false;
     3037  }
     3038
     3039  const double obj = objectiveValue();
     3040  const double maxmin = optimizationDirection();
     3041
     3042  if (problemStatus_ == 0) // optimal
     3043    return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
     3044  else if (problemStatus_ == 2)
     3045    return true;
     3046  else
     3047    return false;
    31103048}
    31113049
     
    31133051{
    31143052
    3115      double limit = 0.0;
    3116      getDblParam(ClpDualObjectiveLimit, limit);
    3117      if (limit > 1e30) {
    3118           // was not ever set
    3119           return false;
    3120      }
    3121 
    3122      const double obj = objectiveValue();
    3123      const double maxmin = optimizationDirection();
    3124 
    3125      if (problemStatus_ == 0) // optimal
    3126           return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
    3127      else if (problemStatus_ == 1)
    3128           return true;
    3129      else
    3130           return false;
    3131 
    3132 }
    3133 void
    3134 ClpModel::copyInIntegerInformation(const char * information)
    3135 {
    3136      delete [] integerType_;
    3137      if (information) {
    3138           integerType_ = new char[numberColumns_];
    3139           CoinMemcpyN(information, numberColumns_, integerType_);
    3140      } else {
    3141           integerType_ = NULL;
    3142      }
    3143 }
    3144 void
    3145 ClpModel::setContinuous(int index)
    3146 {
    3147 
    3148      if (integerType_) {
     3053  double limit = 0.0;
     3054  getDblParam(ClpDualObjectiveLimit, limit);
     3055  if (limit > 1e30) {
     3056    // was not ever set
     3057    return false;
     3058  }
     3059
     3060  const double obj = objectiveValue();
     3061  const double maxmin = optimizationDirection();
     3062
     3063  if (problemStatus_ == 0) // optimal
     3064    return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
     3065  else if (problemStatus_ == 1)
     3066    return true;
     3067  else
     3068    return false;
     3069}
     3070void ClpModel::copyInIntegerInformation(const char *information)
     3071{
     3072  delete[] integerType_;
     3073  if (information) {
     3074    integerType_ = new char[numberColumns_];
     3075    CoinMemcpyN(information, numberColumns_, integerType_);
     3076  } else {
     3077    integerType_ = NULL;
     3078  }
     3079}
     3080void ClpModel::setContinuous(int index)
     3081{
     3082
     3083  if (integerType_) {
    31493084#ifndef NDEBUG
    3150           if (index < 0 || index >= numberColumns_) {
    3151                indexError(index, "setContinuous");
    3152           }
    3153 #endif
    3154           integerType_[index] = 0;
    3155      }
     3085    if (index < 0 || index >= numberColumns_) {
     3086      indexError(index, "setContinuous");
     3087    }
     3088#endif
     3089    integerType_[index] = 0;
     3090  }
    31563091}
    31573092//-----------------------------------------------------------------------------
    3158 void
    3159 ClpModel::setInteger(int index)
    3160 {
    3161      if (!integerType_) {
    3162           integerType_ = new char[numberColumns_];
    3163           CoinZeroN ( integerType_, numberColumns_);
    3164      }
     3093void ClpModel::setInteger(int index)
     3094{
     3095  if (!integerType_) {
     3096    integerType_ = new char[numberColumns_];
     3097    CoinZeroN(integerType_, numberColumns_);
     3098  }
    31653099#ifndef NDEBUG
    3166      if (index < 0 || index >= numberColumns_) {
    3167           indexError(index, "setInteger");
    3168      }
    3169 #endif
    3170      integerType_[index] = 1;
     3100  if (index < 0 || index >= numberColumns_) {
     3101    indexError(index, "setInteger");
     3102  }
     3103#endif
     3104  integerType_[index] = 1;
    31713105}
    31723106/* Return true if the index-th variable is an integer variable */
    3173 bool
    3174 ClpModel::isInteger(int index) const
    3175 {
    3176      if (!integerType_) {
    3177           return false;
    3178      } else {
     3107bool ClpModel::isInteger(int index) const
     3108{
     3109  if (!integerType_) {
     3110    return false;
     3111  } else {
    31793112#ifndef NDEBUG
    3180           if (index < 0 || index >= numberColumns_) {
    3181                indexError(index, "isInteger");
    3182           }
    3183 #endif
    3184           return (integerType_[index] != 0);
    3185      }
     3113    if (index < 0 || index >= numberColumns_) {
     3114      indexError(index, "isInteger");
     3115    }
     3116#endif
     3117    return (integerType_[index] != 0);
     3118  }
    31863119}
    31873120#ifndef CLP_NO_STD
    31883121// Drops names - makes lengthnames 0 and names empty
    3189 void
    3190 ClpModel::dropNames()
    3191 {
    3192      lengthNames_ = 0;
    3193      rowNames_ = std::vector<std::string> ();
    3194      columnNames_ = std::vector<std::string> ();
     3122void ClpModel::dropNames()
     3123{
     3124  lengthNames_ = 0;
     3125  rowNames_ = std::vector< std::string >();
     3126  columnNames_ = std::vector< std::string >();
    31953127}
    31963128#endif
    31973129// Drop integer informations
    3198 void
    3199 ClpModel::deleteIntegerInformation()
    3200 {
    3201      delete [] integerType_;
    3202      integerType_ = NULL;
     3130void ClpModel::deleteIntegerInformation()
     3131{
     3132  delete[] integerType_;
     3133  integerType_ = NULL;
    32033134}
    32043135/* Return copy of status array (char[numberRows+numberColumns]),
     
    32073138ClpModel::statusCopy() const
    32083139{
    3209      return ClpCopyOfArray(status_, numberRows_ + numberColumns_);
     3140  return ClpCopyOfArray(status_, numberRows_ + numberColumns_);
    32103141}
    32113142// Copy in status vector
    3212 void
    3213 ClpModel::copyinStatus(const unsigned char * statusArray)
    3214 {
    3215      delete [] status_;
    3216      if (statusArray) {
    3217           status_ = new unsigned char [numberRows_+numberColumns_];
    3218           CoinMemcpyN(statusArray, (numberRows_ + numberColumns_), status_);
    3219      } else {
    3220           status_ = NULL;
    3221      }
     3143void ClpModel::copyinStatus(const unsigned char *statusArray)
     3144{
     3145  delete[] status_;
     3146  if (statusArray) {
     3147    status_ = new unsigned char[numberRows_ + numberColumns_];
     3148    CoinMemcpyN(statusArray, (numberRows_ + numberColumns_), status_);
     3149  } else {
     3150    status_ = NULL;
     3151  }
    32223152}
    32233153#ifndef SLIM_CLP
    32243154// Load up quadratic objective
    3225 void
    3226 ClpModel::loadQuadraticObjective(const int numberColumns, const CoinBigIndex * start,
    3227                                  const int * column, const double * element)
    3228 {
    3229      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3230      CoinAssert (numberColumns == numberColumns_);
    3231      assert ((dynamic_cast< ClpLinearObjective*>(objective_)));
    3232      double offset;
    3233      ClpObjective * obj = new ClpQuadraticObjective(objective_->gradient(NULL, NULL, offset, false),
    3234                numberColumns,
    3235                start, column, element);
    3236      delete objective_;
    3237      objective_ = obj;
    3238 
    3239 }
    3240 void
    3241 ClpModel::loadQuadraticObjective (  const CoinPackedMatrix& matrix)
    3242 {
    3243      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3244      CoinAssert (matrix.getNumCols() == numberColumns_);
    3245      assert ((dynamic_cast< ClpLinearObjective*>(objective_)));
    3246      double offset;
    3247      ClpQuadraticObjective * obj =
    3248           new ClpQuadraticObjective(objective_->gradient(NULL, NULL, offset, false),
    3249                                     numberColumns_,
    3250                                     NULL, NULL, NULL);
    3251      delete objective_;
    3252      objective_ = obj;
    3253      obj->loadQuadraticObjective(matrix);
     3155void ClpModel::loadQuadraticObjective(const int numberColumns, const CoinBigIndex *start,
     3156  const int *column, const double *element)
     3157{
     3158  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3159  CoinAssert(numberColumns == numberColumns_);
     3160  assert((dynamic_cast< ClpLinearObjective * >(objective_)));
     3161  double offset;
     3162  ClpObjective *obj = new ClpQuadraticObjective(objective_->gradient(NULL, NULL, offset, false),
     3163    numberColumns,
     3164    start, column, element);
     3165  delete objective_;
     3166  objective_ = obj;
     3167}
     3168void ClpModel::loadQuadraticObjective(const CoinPackedMatrix &matrix)
     3169{
     3170  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3171  CoinAssert(matrix.getNumCols() == numberColumns_);
     3172  assert((dynamic_cast< ClpLinearObjective * >(objective_)));
     3173  double offset;
     3174  ClpQuadraticObjective *obj = new ClpQuadraticObjective(objective_->gradient(NULL, NULL, offset, false),
     3175    numberColumns_,
     3176    NULL, NULL, NULL);
     3177  delete objective_;
     3178  objective_ = obj;
     3179  obj->loadQuadraticObjective(matrix);
    32543180}
    32553181// Get rid of quadratic objective
    3256 void
    3257 ClpModel::deleteQuadraticObjective()
    3258 {
    3259      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3260      ClpQuadraticObjective * obj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
    3261      if (obj)
    3262           obj->deleteQuadraticObjective();
    3263 }
    3264 #endif
    3265 void
    3266 ClpModel::setObjective(ClpObjective * objective)
    3267 {
    3268      whatsChanged_ = 0; // Use ClpSimplex stuff to keep
    3269      delete objective_;
    3270      objective_ = objective->clone();
     3182void ClpModel::deleteQuadraticObjective()
     3183{
     3184  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3185  ClpQuadraticObjective *obj = (dynamic_cast< ClpQuadraticObjective * >(objective_));
     3186  if (obj)
     3187    obj->deleteQuadraticObjective();
     3188}
     3189#endif
     3190void ClpModel::setObjective(ClpObjective *objective)
     3191{
     3192  whatsChanged_ = 0; // Use ClpSimplex stuff to keep
     3193  delete objective_;
     3194  objective_ = objective->clone();
    32713195}