Ignore:
Timestamp:
Jan 6, 2019 6:17:46 PM (9 months ago)
Author:
unxusr
Message:

formatting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/examples/CbcSolver2.cpp

    r1574 r2469  
    1818#include "CoinModel.hpp"
    1919
    20 static int timesBad_=0;
    21 static int iterationsBad_=0;
     20static int timesBad_ = 0;
     21static int iterationsBad_ = 0;
    2222//#############################################################################
    2323// Solve methods
     
    2626{
    2727  modelPtr_->scaling(0);
    28   setBasis(basis_,modelPtr_);
     28  setBasis(basis_, modelPtr_);
    2929  // Do long thin by sprint
    3030  ClpSolve options;
    3131  options.setSolveType(ClpSolve::usePrimalorSprint);
    3232  options.setPresolveType(ClpSolve::presolveOff);
    33   options.setSpecialOption(1,3,30);
     33  options.setSpecialOption(1, 3, 30);
    3434  modelPtr_->initialSolve(options);
    3535  basis_ = getBasis(modelPtr_);
     
    4141{
    4242  int numberColumns = modelPtr_->numberColumns();
    43   if ((count_<10&&algorithm_==2)||!algorithm_) {
     43  if ((count_ < 10 && algorithm_ == 2) || !algorithm_) {
    4444    OsiClpSolverInterface::resolve();
    45     if (modelPtr_->status()==0) {
     45    if (modelPtr_->status() == 0) {
    4646      count_++;
    47       double * solution = modelPtr_->primalColumnSolution();
     47      double *solution = modelPtr_->primalColumnSolution();
    4848      int i;
    49       for (i=0;i<numberColumns;i++) {
    50         if (solution[i]>1.0e-6||modelPtr_->getStatus(i)==ClpSimplex::basic) {
    51           node_[i]=CoinMax(count_,node_[i]);
    52           howMany_[i]++;
    53         }
     49      for (i = 0; i < numberColumns; i++) {
     50        if (solution[i] > 1.0e-6 || modelPtr_->getStatus(i) == ClpSimplex::basic) {
     51          node_[i] = CoinMax(count_, node_[i]);
     52          howMany_[i]++;
     53        }
    5454      }
    5555    } else {
    56       if (!algorithm_==2)
    57         printf("infeasible early on\n");
     56      if (!algorithm_ == 2)
     57        printf("infeasible early on\n");
    5858    }
    5959  } else {
    6060    // use counts
    61     int numberRows=modelPtr_->numberRows();
    62     int * whichRow = new int[numberRows];
    63     int * whichColumn = new int [numberColumns];
     61    int numberRows = modelPtr_->numberRows();
     62    int *whichRow = new int[numberRows];
     63    int *whichColumn = new int[numberColumns];
    6464    int i;
    65     const double * lower = modelPtr_->columnLower();
    66     const double * upper = modelPtr_->columnUpper();
    67     const double * rowUpper = modelPtr_->rowUpper();
    68     bool equality=false;
    69     for (i=0;i<numberRows;i++) {
    70       if (rowUpper[i]==1.0) {
    71         equality=true;
     65    const double *lower = modelPtr_->columnLower();
     66    const double *upper = modelPtr_->columnUpper();
     67    const double *rowUpper = modelPtr_->rowUpper();
     68    bool equality = false;
     69    for (i = 0; i < numberRows; i++) {
     70      if (rowUpper[i] == 1.0) {
     71        equality = true;
    7272        break;
    7373      }
    7474    }
    75     setBasis(basis_,modelPtr_);
    76     int nNewCol=0;
     75    setBasis(basis_, modelPtr_);
     76    int nNewCol = 0;
    7777    // Column copy
    7878    //const double * element = modelPtr_->matrix()->getElements();
    79     const int * row = modelPtr_->matrix()->getIndices();
    80     const CoinBigIndex * columnStart = modelPtr_->matrix()->getVectorStarts();
    81     const int * columnLength = modelPtr_->matrix()->getVectorLengths();
    82    
    83     int * rowActivity = new int[numberRows];
    84     memset(rowActivity,0,numberRows*sizeof(int));
    85     int * rowActivity2 = new int[numberRows];
    86     memset(rowActivity2,0,numberRows*sizeof(int));
    87     char * mark = new char[numberColumns];
    88     memset(mark,0,numberColumns);
     79    const int *row = modelPtr_->matrix()->getIndices();
     80    const CoinBigIndex *columnStart = modelPtr_->matrix()->getVectorStarts();
     81    const int *columnLength = modelPtr_->matrix()->getVectorLengths();
     82
     83    int *rowActivity = new int[numberRows];
     84    memset(rowActivity, 0, numberRows * sizeof(int));
     85    int *rowActivity2 = new int[numberRows];
     86    memset(rowActivity2, 0, numberRows * sizeof(int));
     87    char *mark = new char[numberColumns];
     88    memset(mark, 0, numberColumns);
    8989    // Get rows which are satisfied
    90     for (i=0;i<numberColumns;i++) {
    91       if (lower[i]>0.0) {
     90    for (i = 0; i < numberColumns; i++) {
     91      if (lower[i] > 0.0) {
    9292        CoinBigIndex j;
    93         for (j=columnStart[i];
    94              j<columnStart[i]+columnLength[i];j++) {
    95           int iRow=row[j];
    96           rowActivity2[iRow] ++;
     93        for (j = columnStart[i];
     94             j < columnStart[i] + columnLength[i]; j++) {
     95          int iRow = row[j];
     96          rowActivity2[iRow]++;
    9797        }
    9898      } else if (!upper[i]) {
    99         mark[i]=2; // no good
     99        mark[i] = 2; // no good
    100100      }
    101101    }
    102102    // If equality - check not infeasible
    103103    if (equality) {
    104       bool feasible=true;
    105       for (i=0;i<numberRows;i++) {
    106         if (rowActivity2[i]>1) {
    107           feasible=false;
     104      bool feasible = true;
     105      for (i = 0; i < numberRows; i++) {
     106        if (rowActivity2[i] > 1) {
     107          feasible = false;
    108108          break;
    109109        }
    110110      }
    111111      if (!feasible) {
    112         delete [] rowActivity;
    113         delete [] rowActivity2;
     112        delete[] rowActivity;
     113        delete[] rowActivity2;
    114114        modelPtr_->setProblemStatus(1);
    115         delete [] whichRow;
    116         delete [] whichColumn;
    117         delete [] mark;
     115        delete[] whichRow;
     116        delete[] whichColumn;
     117        delete[] mark;
    118118        printf("infeasible by inspection (over)\n");
    119119        return;
    120120      }
    121121    }
    122     int nNoGood=0;
    123     for (i=0;i<numberColumns;i++) {
    124       if (mark[i]==2) {
     122    int nNoGood = 0;
     123    for (i = 0; i < numberColumns; i++) {
     124      if (mark[i] == 2) {
    125125        nNoGood++;
    126126        continue;
    127127      }
    128128      bool choose;
    129       if (algorithm_==1)
     129      if (algorithm_ == 1)
    130130        choose = true;
    131131      else
    132         choose = (node_[i]>count_-memory_&&node_[i]>0);
     132        choose = (node_[i] > count_ - memory_ && node_[i] > 0);
    133133      bool any;
    134134      if (equality) {
    135135        // See if forced to be zero
    136136        CoinBigIndex j;
    137         any=true;
    138         for (j=columnStart[i];
    139              j<columnStart[i]+columnLength[i];j++) {
    140           int iRow=row[j];
     137        any = true;
     138        for (j = columnStart[i];
     139             j < columnStart[i] + columnLength[i]; j++) {
     140          int iRow = row[j];
    141141          if (rowActivity2[iRow])
    142             any=false; // can't be in
     142            any = false; // can't be in
    143143        }
    144144      } else {
    145145        // See if not useful
    146146        CoinBigIndex j;
    147         any=false;
    148         for (j=columnStart[i];
    149              j<columnStart[i]+columnLength[i];j++) {
    150           int iRow=row[j];
     147        any = false;
     148        for (j = columnStart[i];
     149             j < columnStart[i] + columnLength[i]; j++) {
     150          int iRow = row[j];
    151151          if (!rowActivity2[iRow])
    152             any=true; // useful
    153         }
    154       }
    155       if (!any&&!lower[i]) {
    156         choose=false;
     152            any = true; // useful
     153        }
     154      }
     155      if (!any && !lower[i]) {
     156        choose = false;
    157157        // and say can't be useful
    158         mark[i]=2;
     158        mark[i] = 2;
    159159        nNoGood++;
    160160      }
    161       if (strategy_&&modelPtr_->getColumnStatus(i)==ClpSimplex::basic)
    162         choose=true;
    163       if (choose||lower[i]>0.0) {
    164         mark[i]=1;
    165         whichColumn[nNewCol++]=i;
     161      if (strategy_ && modelPtr_->getColumnStatus(i) == ClpSimplex::basic)
     162        choose = true;
     163      if (choose || lower[i] > 0.0) {
     164        mark[i] = 1;
     165        whichColumn[nNewCol++] = i;
    166166        CoinBigIndex j;
    167167        double value = upper[i];
    168168        if (value) {
    169           for (j=columnStart[i];
    170                j<columnStart[i]+columnLength[i];j++) {
    171             int iRow=row[j];
    172             rowActivity[iRow] ++;
     169          for (j = columnStart[i];
     170               j < columnStart[i] + columnLength[i]; j++) {
     171            int iRow = row[j];
     172            rowActivity[iRow]++;
    173173          }
    174174        }
     
    178178    CoinModel build;
    179179    if (equality) {
    180       int row=0;
    181       for (i=0;i<numberRows;i++) {
     180      int row = 0;
     181      for (i = 0; i < numberRows; i++) {
    182182        // put in all rows if wanted
    183         if(strategy_)
    184           rowActivity2[i]=0;
     183        if (strategy_)
     184          rowActivity2[i] = 0;
    185185        if (!rowActivity2[i]) {
    186           double element=1.0;
    187           build.addColumn(1,&row,&element,0.0,1.0,1.0e8); // large cost
     186          double element = 1.0;
     187          build.addColumn(1, &row, &element, 0.0, 1.0, 1.0e8); // large cost
    188188          row++;
    189189        }
    190190      }
    191191    }
    192     int nOK=0;
    193     int nNewRow=0;
    194     for (i=0;i<numberRows;i++) {
     192    int nOK = 0;
     193    int nNewRow = 0;
     194    for (i = 0; i < numberRows; i++) {
    195195      if (rowActivity[i])
    196196        nOK++;
    197197      if (!rowActivity2[i])
    198         whichRow[nNewRow++]=i; // not satisfied
     198        whichRow[nNewRow++] = i; // not satisfied
    199199      else
    200         modelPtr_->setRowStatus(i,ClpSimplex::basic); // make slack basic
    201     }
    202     if (nOK<numberRows) {
    203       for (i=0;i<numberColumns;i++) {
     200        modelPtr_->setRowStatus(i, ClpSimplex::basic); // make slack basic
     201    }
     202    if (nOK < numberRows) {
     203      for (i = 0; i < numberColumns; i++) {
    204204        if (!mark[i]) {
    205205          CoinBigIndex j;
    206           int good=0;
    207           for (j=columnStart[i];
    208                j<columnStart[i]+columnLength[i];j++) {
    209             int iRow=row[j];
     206          int good = 0;
     207          for (j = columnStart[i];
     208               j < columnStart[i] + columnLength[i]; j++) {
     209            int iRow = row[j];
    210210            if (!rowActivity[iRow]) {
    211               rowActivity[iRow] ++;
     211              rowActivity[iRow]++;
    212212              good++;
    213213            }
    214214          }
    215215          if (good) {
    216             nOK+=good;
    217             whichColumn[nNewCol++]=i;
     216            nOK += good;
     217            whichColumn[nNewCol++] = i;
    218218          }
    219219        }
    220220      }
    221221    }
    222     delete [] rowActivity;
    223     delete [] rowActivity2;
    224     if (nOK<numberRows) {
     222    delete[] rowActivity;
     223    delete[] rowActivity2;
     224    if (nOK < numberRows) {
    225225      modelPtr_->setProblemStatus(1);
    226       delete [] whichRow;
    227       delete [] whichColumn;
    228       delete [] mark;
     226      delete[] whichRow;
     227      delete[] whichColumn;
     228      delete[] mark;
    229229      printf("infeasible by inspection\n");
    230230      return;
    231231    }
    232     bool allIn=false;
    233     if (nNewCol+nNoGood+numberRows>numberColumns) {
     232    bool allIn = false;
     233    if (nNewCol + nNoGood + numberRows > numberColumns) {
    234234      // add in all
    235       allIn=true;
    236       for (i=0;i<numberColumns;i++) {
     235      allIn = true;
     236      for (i = 0; i < numberColumns; i++) {
    237237        if (!mark[i]) {
    238           whichColumn[nNewCol++]=i;
    239         }
    240       }
    241     }
    242     ClpSimplex *  temp = new ClpSimplex(modelPtr_,nNewRow,whichRow,nNewCol,whichColumn);
     238          whichColumn[nNewCol++] = i;
     239        }
     240      }
     241    }
     242    ClpSimplex *temp = new ClpSimplex(modelPtr_, nNewRow, whichRow, nNewCol, whichColumn);
    243243    if (equality)
    244244      temp->addColumns(build);
    245245    temp->setLogLevel(1);
    246246    printf("small has %d rows and %d columns (%d impossible to help) %s\n",
    247            nNewRow,nNewCol,nNoGood,allIn ? "all in" : "");
    248     temp->setSpecialOptions(128+512);
     247      nNewRow, nNewCol, nNoGood, allIn ? "all in" : "");
     248    temp->setSpecialOptions(128 + 512);
    249249    temp->setDualObjectiveLimit(1.0e50);
    250250    temp->dual();
    251     assert (!temp->status());
    252     double * solution = modelPtr_->primalColumnSolution();
    253     const double * solution2 = temp->primalColumnSolution();
    254     memset(solution,0,numberColumns*sizeof(double));
    255     for (i=0;i<nNewCol;i++) {
     251    assert(!temp->status());
     252    double *solution = modelPtr_->primalColumnSolution();
     253    const double *solution2 = temp->primalColumnSolution();
     254    memset(solution, 0, numberColumns * sizeof(double));
     255    for (i = 0; i < nNewCol; i++) {
    256256      int iColumn = whichColumn[i];
    257       solution[iColumn]=solution2[i];
    258       modelPtr_->setStatus(iColumn,temp->getStatus(i));
    259     }
    260     double * rowSolution = modelPtr_->primalRowSolution();
    261     const double * rowSolution2 = temp->primalRowSolution();
    262     double * dual = modelPtr_->dualRowSolution();
    263     const double * dual2 = temp->dualRowSolution();
    264     memset(dual,0,numberRows*sizeof(double));
    265     for (i=0;i<nNewRow;i++) {
    266       int iRow=whichRow[i];
    267       modelPtr_->setRowStatus(iRow,temp->getRowStatus(i));
    268       rowSolution[iRow]=rowSolution2[i];
    269       dual[iRow]=dual2[i];
     257      solution[iColumn] = solution2[i];
     258      modelPtr_->setStatus(iColumn, temp->getStatus(i));
     259    }
     260    double *rowSolution = modelPtr_->primalRowSolution();
     261    const double *rowSolution2 = temp->primalRowSolution();
     262    double *dual = modelPtr_->dualRowSolution();
     263    const double *dual2 = temp->dualRowSolution();
     264    memset(dual, 0, numberRows * sizeof(double));
     265    for (i = 0; i < nNewRow; i++) {
     266      int iRow = whichRow[i];
     267      modelPtr_->setRowStatus(iRow, temp->getRowStatus(i));
     268      rowSolution[iRow] = rowSolution2[i];
     269      dual[iRow] = dual2[i];
    270270    }
    271271    // See if optimal
    272     double * dj = modelPtr_->dualColumnSolution();
     272    double *dj = modelPtr_->dualColumnSolution();
    273273    // get reduced cost for large problem
    274274    // this assumes minimization
    275     memcpy(dj,modelPtr_->objective(),numberColumns*sizeof(double));
    276     modelPtr_->transposeTimes(-1.0,dual,dj);
     275    memcpy(dj, modelPtr_->objective(), numberColumns * sizeof(double));
     276    modelPtr_->transposeTimes(-1.0, dual, dj);
    277277    modelPtr_->setObjectiveValue(temp->objectiveValue());
    278278    modelPtr_->setProblemStatus(0);
    279     int nBad=0;
    280     for (i=0;i<numberColumns;i++) {
    281       if (modelPtr_->getStatus(i)==ClpSimplex::atLowerBound
    282           &&upper[i]>lower[i]&&dj[i]<-1.0e-5)
     279    int nBad = 0;
     280    for (i = 0; i < numberColumns; i++) {
     281      if (modelPtr_->getStatus(i) == ClpSimplex::atLowerBound
     282        && upper[i] > lower[i] && dj[i] < -1.0e-5)
    283283        nBad++;
    284284    }
     
    286286    //temp->writeMps("badb.mps");
    287287    delete temp;
    288     if (nBad&&!allIn) {
    289       assert (algorithm_==2);
     288    if (nBad && !allIn) {
     289      assert(algorithm_ == 2);
    290290      //printf("%d bad\n",nBad);
    291291      timesBad_++;
    292292      // just non mark==2
    293       int nAdded=0;
    294       for (i=0;i<numberColumns;i++) {
     293      int nAdded = 0;
     294      for (i = 0; i < numberColumns; i++) {
    295295        if (!mark[i]) {
    296           whichColumn[nNewCol++]=i;
     296          whichColumn[nNewCol++] = i;
    297297          nAdded++;
    298298        }
    299299      }
    300       assert (nAdded);
     300      assert(nAdded);
    301301      {
    302         temp = new ClpSimplex(modelPtr_,nNewRow,whichRow,nNewCol,whichColumn);
     302        temp = new ClpSimplex(modelPtr_, nNewRow, whichRow, nNewCol, whichColumn);
    303303        if (equality)
    304304          temp->addColumns(build);
    305305        temp->setLogLevel(2);
    306         temp->setSpecialOptions(128+512);
     306        temp->setSpecialOptions(128 + 512);
    307307        temp->setDualObjectiveLimit(1.0e50);
    308308        temp->primal(1);
    309         assert (!temp->status());
    310         double * solution = modelPtr_->primalColumnSolution();
    311         const double * solution2 = temp->primalColumnSolution();
    312         memset(solution,0,numberColumns*sizeof(double));
    313         for (i=0;i<nNewCol;i++) {
     309        assert(!temp->status());
     310        double *solution = modelPtr_->primalColumnSolution();
     311        const double *solution2 = temp->primalColumnSolution();
     312        memset(solution, 0, numberColumns * sizeof(double));
     313        for (i = 0; i < nNewCol; i++) {
    314314          int iColumn = whichColumn[i];
    315           solution[iColumn]=solution2[i];
    316           modelPtr_->setStatus(iColumn,temp->getStatus(i));
    317         }
    318         double * rowSolution = modelPtr_->primalRowSolution();
    319         const double * rowSolution2 = temp->primalRowSolution();
    320         double * dual = modelPtr_->dualRowSolution();
    321         const double * dual2 = temp->dualRowSolution();
    322         memset(dual,0,numberRows*sizeof(double));
    323         for (i=0;i<nNewRow;i++) {
    324           int iRow=whichRow[i];
    325           modelPtr_->setRowStatus(iRow,temp->getRowStatus(i));
    326           rowSolution[iRow]=rowSolution2[i];
    327           dual[iRow]=dual2[i];
     315          solution[iColumn] = solution2[i];
     316          modelPtr_->setStatus(iColumn, temp->getStatus(i));
     317        }
     318        double *rowSolution = modelPtr_->primalRowSolution();
     319        const double *rowSolution2 = temp->primalRowSolution();
     320        double *dual = modelPtr_->dualRowSolution();
     321        const double *dual2 = temp->dualRowSolution();
     322        memset(dual, 0, numberRows * sizeof(double));
     323        for (i = 0; i < nNewRow; i++) {
     324          int iRow = whichRow[i];
     325          modelPtr_->setRowStatus(iRow, temp->getRowStatus(i));
     326          rowSolution[iRow] = rowSolution2[i];
     327          dual[iRow] = dual2[i];
    328328        }
    329329        modelPtr_->setObjectiveValue(temp->objectiveValue());
    330330        modelPtr_->setProblemStatus(0);
    331331        iterationsBad_ += temp->numberIterations();
    332         printf("clean %d\n",temp->numberIterations());
     332        printf("clean %d\n", temp->numberIterations());
    333333        delete temp;
    334334      }
    335335    }
    336     delete [] mark;
    337     delete [] whichRow;
    338     delete [] whichColumn;
     336    delete[] mark;
     337    delete[] whichRow;
     338    delete[] whichColumn;
    339339    basis_ = getBasis(modelPtr_);
    340340    modelPtr_->setSpecialOptions(0);
    341341    count_++;
    342     if ((count_%100)==0&&algorithm_==2)
    343       printf("count %d, bad %d - iterations %d\n",count_,timesBad_,iterationsBad_);
    344     for (i=0;i<numberColumns;i++) {
    345       if (solution[i]>1.0e-6||modelPtr_->getStatus(i)==ClpSimplex::basic) {
    346         node_[i]=CoinMax(count_,node_[i]);
    347         howMany_[i]++;
    348       }
    349     }
    350     if (modelPtr_->objectiveValue()>=modelPtr_->dualObjectiveLimit())
     342    if ((count_ % 100) == 0 && algorithm_ == 2)
     343      printf("count %d, bad %d - iterations %d\n", count_, timesBad_, iterationsBad_);
     344    for (i = 0; i < numberColumns; i++) {
     345      if (solution[i] > 1.0e-6 || modelPtr_->getStatus(i) == ClpSimplex::basic) {
     346        node_[i] = CoinMax(count_, node_[i]);
     347        howMany_[i]++;
     348      }
     349    }
     350    if (modelPtr_->objectiveValue() >= modelPtr_->dualObjectiveLimit())
    351351      modelPtr_->setProblemStatus(1);
    352352  }
     
    358358
    359359//-------------------------------------------------------------------
    360 // Default Constructor 
    361 //-------------------------------------------------------------------
    362 CbcSolver2::CbcSolver2 ()
     360// Default Constructor
     361//-------------------------------------------------------------------
     362CbcSolver2::CbcSolver2()
    363363  : OsiClpSolverInterface()
    364364{
    365   node_=NULL;
    366   howMany_=NULL;
    367   count_=0;
     365  node_ = NULL;
     366  howMany_ = NULL;
     367  count_ = 0;
    368368  model_ = NULL;
    369   memory_=300;
    370   algorithm_=0;
    371   strategy_=0;
     369  memory_ = 300;
     370  algorithm_ = 0;
     371  strategy_ = 0;
    372372}
    373373
     
    375375// Clone
    376376//-------------------------------------------------------------------
    377 OsiSolverInterface * 
     377OsiSolverInterface *
    378378CbcSolver2::clone(bool CopyData) const
    379379{
     
    386386}
    387387
    388 
    389 //-------------------------------------------------------------------
    390 // Copy constructor
    391 //-------------------------------------------------------------------
    392 CbcSolver2::CbcSolver2 (
    393                   const CbcSolver2 & rhs)
     388//-------------------------------------------------------------------
     389// Copy constructor
     390//-------------------------------------------------------------------
     391CbcSolver2::CbcSolver2(
     392  const CbcSolver2 &rhs)
    394393  : OsiClpSolverInterface(rhs)
    395394{
    396395  model_ = rhs.model_;
    397396  int numberColumns = modelPtr_->numberColumns();
    398   node_=CoinCopyOfArray(rhs.node_,numberColumns);
    399   howMany_=CoinCopyOfArray(rhs.howMany_,numberColumns);
    400   count_=rhs.count_;
    401   memory_=rhs.memory_;
    402   algorithm_=rhs.algorithm_;
    403   strategy_=rhs.strategy_;
    404 }
    405 
    406 //-------------------------------------------------------------------
    407 // Destructor 
    408 //-------------------------------------------------------------------
    409 CbcSolver2::~CbcSolver2 ()
    410 {
    411   delete [] node_;
    412   delete [] howMany_;
    413 }
    414 
    415 //-------------------------------------------------------------------
    416 // Assignment operator 
     397  node_ = CoinCopyOfArray(rhs.node_, numberColumns);
     398  howMany_ = CoinCopyOfArray(rhs.howMany_, numberColumns);
     399  count_ = rhs.count_;
     400  memory_ = rhs.memory_;
     401  algorithm_ = rhs.algorithm_;
     402  strategy_ = rhs.strategy_;
     403}
     404
     405//-------------------------------------------------------------------
     406// Destructor
     407//-------------------------------------------------------------------
     408CbcSolver2::~CbcSolver2()
     409{
     410  delete[] node_;
     411  delete[] howMany_;
     412}
     413
     414//-------------------------------------------------------------------
     415// Assignment operator
    417416//-------------------------------------------------------------------
    418417CbcSolver2 &
    419 CbcSolver2::operator=(const CbcSolver2& rhs)
    420 {
    421   if (this != &rhs) { 
     418CbcSolver2::operator=(const CbcSolver2 &rhs)
     419{
     420  if (this != &rhs) {
    422421    OsiClpSolverInterface::operator=(rhs);
    423     delete [] node_;
    424     delete [] howMany_;
     422    delete[] node_;
     423    delete[] howMany_;
    425424    model_ = rhs.model_;
    426425    int numberColumns = modelPtr_->numberColumns();
    427     node_=CoinCopyOfArray(rhs.node_,numberColumns);
    428     howMany_=CoinCopyOfArray(rhs.howMany_,numberColumns);
    429     count_=rhs.count_;
    430     memory_=rhs.memory_;
    431     algorithm_=rhs.algorithm_;
    432     strategy_=rhs.strategy_;
     426    node_ = CoinCopyOfArray(rhs.node_, numberColumns);
     427    howMany_ = CoinCopyOfArray(rhs.howMany_, numberColumns);
     428    count_ = rhs.count_;
     429    memory_ = rhs.memory_;
     430    algorithm_ = rhs.algorithm_;
     431    strategy_ = rhs.strategy_;
    433432  }
    434433  return *this;
     
    437436// Real initializer
    438437//-------------------------------------------------------------------
    439 void
    440 CbcSolver2::initialize (CbcModel * model, const char * keep)
    441 {
    442   model_=model;
     438void CbcSolver2::initialize(CbcModel *model, const char *keep)
     439{
     440  model_ = model;
    443441  int numberColumns = modelPtr_->numberColumns();
    444442  if (numberColumns) {
    445443    node_ = new int[numberColumns];
    446444    howMany_ = new int[numberColumns];
    447     for (int i=0;i<numberColumns;i++) {
    448       if (keep&&keep[i])
    449         node_[i]=COIN_INT_MAX;
     445    for (int i = 0; i < numberColumns; i++) {
     446      if (keep && keep[i])
     447        node_[i] = COIN_INT_MAX;
    450448      else
    451         node_[i]=0;
    452       howMany_[i]=0;
     449        node_[i] = 0;
     450      howMany_[i] = 0;
    453451    }
    454452  } else {
    455     node_=NULL;
    456     howMany_=NULL;
     453    node_ = NULL;
     454    howMany_ = NULL;
    457455  }
    458456}
Note: See TracChangeset for help on using the changeset viewer.