Changeset 2386


Ignore:
Timestamp:
Jan 6, 2019 6:03:50 PM (3 months ago)
Author:
unxusr
Message:

formatting

Location:
trunk/Clp/src/OsiClp
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r2370 r2386  
    1010extern int osi_dual;
    1111extern int osi_hot;
    12 #endif 
     12#endif
    1313#include "CoinTime.hpp"
    1414#include "CoinHelperFunctions.hpp"
     
    3838//#define PRINT_TIME
    3939#ifdef PRINT_TIME
    40 static double totalTime=0.0;
     40static double totalTime = 0.0;
    4141#endif
    4242//#define SAVE_MODEL 1
    4343#ifdef SAVE_MODEL
    44 static int resolveTry=0;
    45 static int loResolveTry=0;
    46 static int hiResolveTry=9999999;
     44static int resolveTry = 0;
     45static int loResolveTry = 0;
     46static int hiResolveTry = 9999999;
    4747#endif
    4848//#############################################################################
     
    5454#ifdef KEEP_SMALL
    5555  if (smallModel_) {
    56     delete [] spareArrays_;
     56    delete[] spareArrays_;
    5757    spareArrays_ = NULL;
    5858    delete smallModel_;
    59     smallModel_=NULL;
    60   }
    61 #endif
    62   if ((specialOptions_&2097152)!=0||(specialOptions_&4194304)!=0) {
     59    smallModel_ = NULL;
     60  }
     61#endif
     62  if ((specialOptions_ & 2097152) != 0 || (specialOptions_ & 4194304) != 0) {
    6363    bool takeHint;
    6464    OsiHintStrength strength;
    6565    int algorithm = 0;
    66     getHintParam(OsiDoDualInInitial,takeHint,strength);
    67     if (strength!=OsiHintIgnore)
     66    getHintParam(OsiDoDualInInitial, takeHint, strength);
     67    if (strength != OsiHintIgnore)
    6868      algorithm = takeHint ? -1 : 1;
    69     if (algorithm>0||(specialOptions_&4194304)!=0) {
     69    if (algorithm > 0 || (specialOptions_ & 4194304) != 0) {
    7070      // Gub
    71       resolveGub((9*modelPtr_->numberRows())/10);
     71      resolveGub((9 * modelPtr_->numberRows()) / 10);
    7272      return;
    7373    }
    7474  }
    7575  bool deleteSolver;
    76   ClpSimplex * solver;
     76  ClpSimplex *solver;
    7777#ifdef PRINT_TIME
    7878  double time1 = CoinCpuTime();
    7979#endif
    8080  int userFactorizationFrequency = modelPtr_->factorization()->maximumPivots();
    81   int totalIterations=0;
    82   bool abortSearch=false;
    83   ClpObjective * savedObjective=NULL;
    84   double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
     81  int totalIterations = 0;
     82  bool abortSearch = false;
     83  ClpObjective *savedObjective = NULL;
     84  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
    8585  if (fakeObjective_) {
    8686    // Clear (no objective, 0-1 and in B&B)
    87     modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~128));
     87    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() & (~128));
    8888    // See if all with costs fixed
    8989    int numberColumns = modelPtr_->numberColumns_;
    90     const double * obj = modelPtr_->objective();
    91     const double * lower = modelPtr_->columnLower();
    92     const double * upper = modelPtr_->columnUpper();
     90    const double *obj = modelPtr_->objective();
     91    const double *lower = modelPtr_->columnLower();
     92    const double *upper = modelPtr_->columnUpper();
    9393    int i;
    94     for (i=0;i<numberColumns;i++) {
     94    for (i = 0; i < numberColumns; i++) {
    9595      double objValue = obj[i];
    9696      if (objValue) {
    97         if (lower[i]!=upper[i])
    98           break;
    99       }
    100     }
    101     if (i==numberColumns) {
     97        if (lower[i] != upper[i])
     98          break;
     99      }
     100    }
     101    if (i == numberColumns) {
    102102      // Check (Clp fast dual)
    103       if ((specialOptions_&524288)==0) {
    104         // Set fake
    105         savedObjective=modelPtr_->objective_;
    106         modelPtr_->objective_=fakeObjective_;
    107         modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
     103      if ((specialOptions_ & 524288) == 0) {
     104        // Set fake
     105        savedObjective = modelPtr_->objective_;
     106        modelPtr_->objective_ = fakeObjective_;
     107        modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
    108108      } else {
    109         // Set (no objective, 0-1 and in B&B)
    110         modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()|128);
     109        // Set (no objective, 0-1 and in B&B)
     110        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() | 128);
    111111      }
    112112    }
    113113  }
    114114  // Check (in branch and bound)
    115   if ((specialOptions_&1024)==0) {
     115  if ((specialOptions_ & 1024) == 0) {
    116116    solver = new ClpSimplex(true);
    117     deleteSolver=true;
     117    deleteSolver = true;
    118118    solver->borrowModel(*modelPtr_);
    119119    // See if user set factorization frequency
     
    122122  } else {
    123123    solver = modelPtr_;
    124     deleteSolver=false;
     124    deleteSolver = false;
    125125  }
    126126  // Treat as if user simplex not enabled
    127   int saveSolveType=solver->solveType();
    128   bool doingPrimal = solver->algorithm()>0;
    129   if (saveSolveType==2) {
     127  int saveSolveType = solver->solveType();
     128  bool doingPrimal = solver->algorithm() > 0;
     129  if (saveSolveType == 2) {
    130130    disableSimplexInterface();
    131131    solver->setSolveType(1);
    132132  }
    133133  int saveOptions = solver->specialOptions();
    134   solver->setSpecialOptions(saveOptions|64|32768); // go as far as possible
     134  solver->setSpecialOptions(saveOptions | 64 | 32768); // go as far as possible
    135135  // get original log levels
    136   int saveMessageLevel=modelPtr_->logLevel();
    137   int messageLevel=messageHandler()->logLevel();
     136  int saveMessageLevel = modelPtr_->logLevel();
     137  int messageLevel = messageHandler()->logLevel();
    138138  int saveMessageLevel2 = messageLevel;
    139139  // Set message handler
     
    146146  OsiHintStrength strength;
    147147  // Switch off printing if asked to
    148   bool gotHint = (getHintParam(OsiDoReducePrint,takeHint,strength));
    149   assert (gotHint);
    150   if (strength!=OsiHintIgnore&&takeHint) {
    151     if (messageLevel>0)
     148  bool gotHint = (getHintParam(OsiDoReducePrint, takeHint, strength));
     149  assert(gotHint);
     150  if (strength != OsiHintIgnore && takeHint) {
     151    if (messageLevel > 0)
    152152      messageLevel--;
    153153  }
    154   if (messageLevel<saveMessageLevel)
     154  if (messageLevel < saveMessageLevel)
    155155    solver->messageHandler()->setLogLevel(messageLevel);
    156156  // Allow for specialOptions_==1+8 forcing saving factorization
    157   int startFinishOptions=0;
    158   if ((specialOptions_&9)==(1+8)) {
    159     startFinishOptions =1+2+4; // allow re-use of factorization
    160   }
    161   bool defaultHints=true;
     157  int startFinishOptions = 0;
     158  if ((specialOptions_ & 9) == (1 + 8)) {
     159    startFinishOptions = 1 + 2 + 4; // allow re-use of factorization
     160  }
     161  bool defaultHints = true;
    162162  {
    163163    int hint;
    164     for (hint=OsiDoPresolveInInitial;hint<OsiLastHintParam;hint++) {
    165       if (hint!=OsiDoReducePrint&&
    166           hint!=OsiDoInBranchAndCut) {
     164    for (hint = OsiDoPresolveInInitial; hint < OsiLastHintParam; hint++) {
     165      if (hint != OsiDoReducePrint && hint != OsiDoInBranchAndCut) {
    167166        bool yesNo;
    168167        OsiHintStrength strength;
    169         getHintParam(static_cast<OsiHintParam> (hint),yesNo,strength);
     168        getHintParam(static_cast< OsiHintParam >(hint), yesNo, strength);
    170169        if (yesNo) {
    171           defaultHints=false;
     170          defaultHints = false;
    172171          break;
    173172        }
    174173        if (strength != OsiHintIgnore) {
    175           defaultHints=false;
     174          defaultHints = false;
    176175          break;
    177176        }
     
    179178    }
    180179  }
    181   ClpPresolve * pinfo = NULL;
     180  ClpPresolve *pinfo = NULL;
    182181  /*
    183182    If basis then do primal (as user could do dual with resolve)
    184183    If not then see if dual feasible (and allow for gubs etc?)
    185184  */
    186   bool doPrimal = (basis_.numberBasicStructurals()>0);
    187   setBasis(basis_,solver);
    188   bool inCbcOrOther = (modelPtr_->specialOptions()&0x03000000)!=0;
    189   if ((!defaultHints||doPrimal)&&!solveOptions_.getSpecialOption(6)) {
     185  bool doPrimal = (basis_.numberBasicStructurals() > 0);
     186  setBasis(basis_, solver);
     187  bool inCbcOrOther = (modelPtr_->specialOptions() & 0x03000000) != 0;
     188  if ((!defaultHints || doPrimal) && !solveOptions_.getSpecialOption(6)) {
    190189    // scaling
    191190    // save initial state
    192     const double * rowScale1 = solver->rowScale();
    193     if (modelPtr_->solveType()==1) {
    194       gotHint = (getHintParam(OsiDoScale,takeHint,strength));
    195       assert (gotHint);
    196       if (strength==OsiHintIgnore||takeHint) {
     191    const double *rowScale1 = solver->rowScale();
     192    if (modelPtr_->solveType() == 1) {
     193      gotHint = (getHintParam(OsiDoScale, takeHint, strength));
     194      assert(gotHint);
     195      if (strength == OsiHintIgnore || takeHint) {
    197196        if (!solver->scalingFlag())
    198197          solver->scaling(3);
     
    205204    //solver->setDualBound(1.0e6);
    206205    //solver->setDualTolerance(1.0e-7);
    207    
     206
    208207    //ClpDualRowSteepest steep;
    209208    //solver->setDualRowPivotAlgorithm(steep);
     
    211210    //ClpPrimalColumnSteepest steepP;
    212211    //solver->setPrimalColumnPivotAlgorithm(steepP);
    213    
     212
    214213    // sort out hints;
    215214    // algorithm 0 whatever, -1 force dual, +1 force primal
    216     int algorithm = 0; 
    217     gotHint = (getHintParam(OsiDoDualInInitial,takeHint,strength));
    218     assert (gotHint);
    219     if (strength!=OsiHintIgnore)
     215    int algorithm = 0;
     216    gotHint = (getHintParam(OsiDoDualInInitial, takeHint, strength));
     217    assert(gotHint);
     218    if (strength != OsiHintIgnore)
    220219      algorithm = takeHint ? -1 : 1;
    221220    // crash 0 do lightweight if all slack, 1 do, -1 don't
    222     int doCrash=0;
    223     gotHint = (getHintParam(OsiDoCrash,takeHint,strength));
    224     assert (gotHint);
    225     if (strength!=OsiHintIgnore)
     221    int doCrash = 0;
     222    gotHint = (getHintParam(OsiDoCrash, takeHint, strength));
     223    assert(gotHint);
     224    if (strength != OsiHintIgnore)
    226225      doCrash = takeHint ? 1 : -1;
    227226    // doPrimal set true if any structurals in basis so switch off crash
    228227    if (doPrimal)
    229228      doCrash = -1;
    230    
     229
    231230    // presolve
    232     gotHint = (getHintParam(OsiDoPresolveInInitial,takeHint,strength));
    233     assert (gotHint);
    234     if (strength!=OsiHintIgnore&&takeHint) {
     231    gotHint = (getHintParam(OsiDoPresolveInInitial, takeHint, strength));
     232    assert(gotHint);
     233    if (strength != OsiHintIgnore && takeHint) {
    235234      pinfo = new ClpPresolve();
    236       ClpSimplex * model2 = pinfo->presolvedModel(*solver,1.0e-8);
     235      ClpSimplex *model2 = pinfo->presolvedModel(*solver, 1.0e-8);
    237236      if (!model2) {
    238237        // problem found to be infeasible - whats best?
    239238        model2 = solver;
    240         delete pinfo;
    241         pinfo = NULL;
     239        delete pinfo;
     240        pinfo = NULL;
    242241      } else {
    243         model2->setSpecialOptions(solver->specialOptions());
    244       }
    245      
     242        model2->setSpecialOptions(solver->specialOptions());
     243      }
     244
    246245      // change from 200 (unless changed)
    247       if (modelPtr_->factorization()->maximumPivots()==200)
    248         model2->factorization()->maximumPivots(100+model2->numberRows()/50);
     246      if (modelPtr_->factorization()->maximumPivots() == 200)
     247        model2->factorization()->maximumPivots(100 + model2->numberRows() / 50);
    249248      else
    250249        model2->factorization()->maximumPivots(userFactorizationFrequency);
    251250      int savePerturbation = model2->perturbation();
    252       if (savePerturbation==100)
     251      if (savePerturbation == 100)
    253252        model2->setPerturbation(50);
    254253      if (!doPrimal) {
     
    257256        model2->tightenPrimalBounds();
    258257        // look further
    259         bool crashResult=false;
    260         if (doCrash>0)
    261           crashResult =  (solver->crash(1000.0,1)>0);
    262         else if (doCrash==0&&algorithm>0)
    263           crashResult =  (solver->crash(1000.0,1)>0);
    264         doPrimal=crashResult;
    265       }
    266       if (algorithm<0)
    267         doPrimal=false;
    268       else if (algorithm>0)
    269         doPrimal=true;
     258        bool crashResult = false;
     259        if (doCrash > 0)
     260          crashResult = (solver->crash(1000.0, 1) > 0);
     261        else if (doCrash == 0 && algorithm > 0)
     262          crashResult = (solver->crash(1000.0, 1) > 0);
     263        doPrimal = crashResult;
     264      }
     265      if (algorithm < 0)
     266        doPrimal = false;
     267      else if (algorithm > 0)
     268        doPrimal = true;
    270269      if (!doPrimal) {
    271270        //if (numberInfeasibilities)
     
    274273        // up dual bound for safety
    275274        //model2->setDualBound(1.0e11);
    276         disasterHandler_->setOsiModel(this);
    277         if (inCbcOrOther) {
    278           disasterHandler_->setSimplex(model2);
    279           disasterHandler_->setWhereFrom(4);
    280           model2->setDisasterHandler(disasterHandler_);
    281         }
     275        disasterHandler_->setOsiModel(this);
     276        if (inCbcOrOther) {
     277          disasterHandler_->setSimplex(model2);
     278          disasterHandler_->setWhereFrom(4);
     279          model2->setDisasterHandler(disasterHandler_);
     280        }
    282281        model2->dual(0);
    283         totalIterations += model2->numberIterations();
    284         if (inCbcOrOther) {
    285           if(disasterHandler_->inTrouble()) {
     282        totalIterations += model2->numberIterations();
     283        if (inCbcOrOther) {
     284          if (disasterHandler_->inTrouble()) {
    286285#ifdef COIN_DEVELOP
    287             printf("dual trouble a\n");
    288 #endif
    289             if (disasterHandler_->typeOfDisaster()) {
    290               // We want to abort
    291               abortSearch=true;
    292               goto disaster;
    293             }
    294             // try just going back in
    295             disasterHandler_->setPhase(1);
    296             model2->dual();
    297             totalIterations += model2->numberIterations();
    298             if (disasterHandler_->inTrouble()) {
     286            printf("dual trouble a\n");
     287#endif
     288            if (disasterHandler_->typeOfDisaster()) {
     289              // We want to abort
     290              abortSearch = true;
     291              goto disaster;
     292            }
     293            // try just going back in
     294            disasterHandler_->setPhase(1);
     295            model2->dual();
     296            totalIterations += model2->numberIterations();
     297            if (disasterHandler_->inTrouble()) {
    299298#ifdef COIN_DEVELOP
    300               printf("dual trouble b\n");
    301 #endif
    302               if (disasterHandler_->typeOfDisaster()) {
    303                 // We want to abort
    304                 abortSearch=true;
    305                 goto disaster;
    306               }
    307               // try primal with original basis
    308               disasterHandler_->setPhase(2);
    309               setBasis(basis_,model2);
    310               model2->primal();
    311               totalIterations += model2->numberIterations();
    312             }
    313             if(disasterHandler_->inTrouble()) {
     299              printf("dual trouble b\n");
     300#endif
     301              if (disasterHandler_->typeOfDisaster()) {
     302                // We want to abort
     303                abortSearch = true;
     304                goto disaster;
     305              }
     306              // try primal with original basis
     307              disasterHandler_->setPhase(2);
     308              setBasis(basis_, model2);
     309              model2->primal();
     310              totalIterations += model2->numberIterations();
     311            }
     312            if (disasterHandler_->inTrouble()) {
    314313#ifdef COIN_DEVELOP
    315               printf("disaster - treat as infeasible\n");
    316 #endif
    317               if (disasterHandler_->typeOfDisaster()) {
    318                 // We want to abort
    319                 abortSearch=true;
    320                 goto disaster;
    321               }
    322               model2->setProblemStatus(1);
    323             }
    324           }
    325           // reset
    326           model2->setDisasterHandler(NULL);
    327         }
     314              printf("disaster - treat as infeasible\n");
     315#endif
     316              if (disasterHandler_->typeOfDisaster()) {
     317                // We want to abort
     318                abortSearch = true;
     319                goto disaster;
     320              }
     321              model2->setProblemStatus(1);
     322            }
     323          }
     324          // reset
     325          model2->setDisasterHandler(NULL);
     326        }
    328327        // check if clp thought it was in a loop
    329         if (model2->status()==3&&!model2->hitMaximumIterations()) {
     328        if (model2->status() == 3 && !model2->hitMaximumIterations()) {
    330329          // switch algorithm
    331           disasterHandler_->setOsiModel(this);
    332           if (inCbcOrOther) {
    333             disasterHandler_->setSimplex(model2);
    334             disasterHandler_->setWhereFrom(6);
    335             model2->setDisasterHandler(disasterHandler_);
    336           }
     330          disasterHandler_->setOsiModel(this);
     331          if (inCbcOrOther) {
     332            disasterHandler_->setSimplex(model2);
     333            disasterHandler_->setWhereFrom(6);
     334            model2->setDisasterHandler(disasterHandler_);
     335          }
    337336          model2->primal();
    338           totalIterations += model2->numberIterations();
    339           if (inCbcOrOther) {
    340             if(disasterHandler_->inTrouble()) {
     337          totalIterations += model2->numberIterations();
     338          if (inCbcOrOther) {
     339            if (disasterHandler_->inTrouble()) {
    341340#ifdef COIN_DEVELOP
    342               printf("primal trouble a\n");
    343 #endif
    344               if (disasterHandler_->typeOfDisaster()) {
    345                 // We want to abort
    346                 abortSearch=true;
    347                 goto disaster;
    348               }
    349               // try just going back in (but with dual)
    350               disasterHandler_->setPhase(1);
    351               model2->dual();
    352               totalIterations += model2->numberIterations();
    353               if (disasterHandler_->inTrouble()) {
     341              printf("primal trouble a\n");
     342#endif
     343              if (disasterHandler_->typeOfDisaster()) {
     344                // We want to abort
     345                abortSearch = true;
     346                goto disaster;
     347              }
     348              // try just going back in (but with dual)
     349              disasterHandler_->setPhase(1);
     350              model2->dual();
     351              totalIterations += model2->numberIterations();
     352              if (disasterHandler_->inTrouble()) {
    354353#ifdef COIN_DEVELOP
    355                 printf("primal trouble b\n");
    356 #endif
    357                 if (disasterHandler_->typeOfDisaster()) {
    358                   // We want to abort
    359                   abortSearch=true;
    360                   goto disaster;
    361                 }
    362                 // try primal with original basis
    363                 disasterHandler_->setPhase(2);
    364                 setBasis(basis_,model2);
    365                 model2->dual();
    366                 totalIterations += model2->numberIterations();
    367               }
    368               if(disasterHandler_->inTrouble()) {
     354                printf("primal trouble b\n");
     355#endif
     356                if (disasterHandler_->typeOfDisaster()) {
     357                  // We want to abort
     358                  abortSearch = true;
     359                  goto disaster;
     360                }
     361                // try primal with original basis
     362                disasterHandler_->setPhase(2);
     363                setBasis(basis_, model2);
     364                model2->dual();
     365                totalIterations += model2->numberIterations();
     366              }
     367              if (disasterHandler_->inTrouble()) {
    369368#ifdef COIN_DEVELOP
    370                 printf("disaster - treat as infeasible\n");
    371 #endif
    372                 if (disasterHandler_->typeOfDisaster()) {
    373                   // We want to abort
    374                   abortSearch=true;
    375                   goto disaster;
    376                 }
    377                 model2->setProblemStatus(1);
    378               }
    379             }
    380             // reset
    381             model2->setDisasterHandler(NULL);
    382           }
     369                printf("disaster - treat as infeasible\n");
     370#endif
     371                if (disasterHandler_->typeOfDisaster()) {
     372                  // We want to abort
     373                  abortSearch = true;
     374                  goto disaster;
     375                }
     376                model2->setProblemStatus(1);
     377              }
     378            }
     379            // reset
     380            model2->setDisasterHandler(NULL);
     381          }
    383382        }
    384383      } else {
    385384        // up infeasibility cost for safety
    386385        //model2->setInfeasibilityCost(1.0e10);
    387         disasterHandler_->setOsiModel(this);
    388         if (inCbcOrOther) {
    389           disasterHandler_->setSimplex(model2);
    390           disasterHandler_->setWhereFrom(6);
    391           model2->setDisasterHandler(disasterHandler_);
    392         }
     386        disasterHandler_->setOsiModel(this);
     387        if (inCbcOrOther) {
     388          disasterHandler_->setSimplex(model2);
     389          disasterHandler_->setWhereFrom(6);
     390          model2->setDisasterHandler(disasterHandler_);
     391        }
    393392        model2->primal(1);
    394         totalIterations += model2->numberIterations();
    395         if (inCbcOrOther) {
    396           if(disasterHandler_->inTrouble()) {
     393        totalIterations += model2->numberIterations();
     394        if (inCbcOrOther) {
     395          if (disasterHandler_->inTrouble()) {
    397396#ifdef COIN_DEVELOP
    398             printf("primal trouble a\n");
    399 #endif
    400             if (disasterHandler_->typeOfDisaster()) {
    401               // We want to abort
    402               abortSearch=true;
    403               goto disaster;
    404             }
    405             // try just going back in (but with dual)
    406             disasterHandler_->setPhase(1);
    407             model2->dual();
    408             totalIterations += model2->numberIterations();
    409             if (disasterHandler_->inTrouble()) {
     397            printf("primal trouble a\n");
     398#endif
     399            if (disasterHandler_->typeOfDisaster()) {
     400              // We want to abort
     401              abortSearch = true;
     402              goto disaster;
     403            }
     404            // try just going back in (but with dual)
     405            disasterHandler_->setPhase(1);
     406            model2->dual();
     407            totalIterations += model2->numberIterations();
     408            if (disasterHandler_->inTrouble()) {
    410409#ifdef COIN_DEVELOP
    411               printf("primal trouble b\n");
    412 #endif
    413               if (disasterHandler_->typeOfDisaster()) {
    414                 // We want to abort
    415                 abortSearch=true;
    416                 goto disaster;
    417               }
    418               // try primal with original basis
    419               disasterHandler_->setPhase(2);
    420               setBasis(basis_,model2);
    421               model2->dual();
    422               totalIterations += model2->numberIterations();
    423             }
    424             if(disasterHandler_->inTrouble()) {
     410              printf("primal trouble b\n");
     411#endif
     412              if (disasterHandler_->typeOfDisaster()) {
     413                // We want to abort
     414                abortSearch = true;
     415                goto disaster;
     416              }
     417              // try primal with original basis
     418              disasterHandler_->setPhase(2);
     419              setBasis(basis_, model2);
     420              model2->dual();
     421              totalIterations += model2->numberIterations();
     422            }
     423            if (disasterHandler_->inTrouble()) {
    425424#ifdef COIN_DEVELOP
    426               printf("disaster - treat as infeasible\n");
    427 #endif
    428               if (disasterHandler_->typeOfDisaster()) {
    429                 // We want to abort
    430                 abortSearch=true;
    431                 goto disaster;
    432               }
    433               model2->setProblemStatus(1);
    434             }
    435           }
    436           // reset
    437           model2->setDisasterHandler(NULL);
    438         }
     425              printf("disaster - treat as infeasible\n");
     426#endif
     427              if (disasterHandler_->typeOfDisaster()) {
     428                // We want to abort
     429                abortSearch = true;
     430                goto disaster;
     431              }
     432              model2->setProblemStatus(1);
     433            }
     434          }
     435          // reset
     436          model2->setDisasterHandler(NULL);
     437        }
    439438        // check if clp thought it was in a loop
    440         if (model2->status()==3&&!model2->hitMaximumIterations()) {
     439        if (model2->status() == 3 && !model2->hitMaximumIterations()) {
    441440          // switch algorithm
    442           disasterHandler_->setOsiModel(this);
    443           if (inCbcOrOther) {
    444             disasterHandler_->setSimplex(model2);
    445             disasterHandler_->setWhereFrom(4);
    446             model2->setDisasterHandler(disasterHandler_);
    447           }
    448           model2->dual(0);
    449           totalIterations += model2->numberIterations();
    450           if (inCbcOrOther) {
    451             if(disasterHandler_->inTrouble()) {
     441          disasterHandler_->setOsiModel(this);
     442          if (inCbcOrOther) {
     443            disasterHandler_->setSimplex(model2);
     444            disasterHandler_->setWhereFrom(4);
     445            model2->setDisasterHandler(disasterHandler_);
     446          }
     447          model2->dual(0);
     448          totalIterations += model2->numberIterations();
     449          if (inCbcOrOther) {
     450            if (disasterHandler_->inTrouble()) {
    452451#ifdef COIN_DEVELOP
    453               printf("dual trouble a\n");
    454 #endif
    455               if (disasterHandler_->typeOfDisaster()) {
    456                 // We want to abort
    457                 abortSearch=true;
    458                 goto disaster;
    459               }
    460               // try just going back in
    461               disasterHandler_->setPhase(1);
    462               model2->dual();
    463               totalIterations += model2->numberIterations();
    464               if (disasterHandler_->inTrouble()) {
     452              printf("dual trouble a\n");
     453#endif
     454              if (disasterHandler_->typeOfDisaster()) {
     455                // We want to abort
     456                abortSearch = true;
     457                goto disaster;
     458              }
     459              // try just going back in
     460              disasterHandler_->setPhase(1);
     461              model2->dual();
     462              totalIterations += model2->numberIterations();
     463              if (disasterHandler_->inTrouble()) {
    465464#ifdef COIN_DEVELOP
    466                 printf("dual trouble b\n");
    467 #endif
    468                 if (disasterHandler_->typeOfDisaster()) {
    469                   // We want to abort
    470                   abortSearch=true;
    471                 goto disaster;
    472                 }
    473                 // try primal with original basis
    474                 disasterHandler_->setPhase(2);
    475                 setBasis(basis_,model2);
    476                 model2->primal();
    477                 totalIterations += model2->numberIterations();
    478               }
    479               if(disasterHandler_->inTrouble()) {
     465                printf("dual trouble b\n");
     466#endif
     467                if (disasterHandler_->typeOfDisaster()) {
     468                  // We want to abort
     469                  abortSearch = true;
     470                  goto disaster;
     471                }
     472                // try primal with original basis
     473                disasterHandler_->setPhase(2);
     474                setBasis(basis_, model2);
     475                model2->primal();
     476                totalIterations += model2->numberIterations();
     477              }
     478              if (disasterHandler_->inTrouble()) {
    480479#ifdef COIN_DEVELOP
    481                 printf("disaster - treat as infeasible\n");
    482 #endif
    483                 if (disasterHandler_->typeOfDisaster()) {
    484                   // We want to abort
    485                   abortSearch=true;
    486                   goto disaster;
    487                 }
    488                 model2->setProblemStatus(1);
    489               }
    490             }
    491             // reset
    492             model2->setDisasterHandler(NULL);
    493           }
     480                printf("disaster - treat as infeasible\n");
     481#endif
     482                if (disasterHandler_->typeOfDisaster()) {
     483                  // We want to abort
     484                  abortSearch = true;
     485                  goto disaster;
     486                }
     487                model2->setProblemStatus(1);
     488              }
     489            }
     490            // reset
     491            model2->setDisasterHandler(NULL);
     492          }
    494493        }
    495494      }
    496495      model2->setPerturbation(savePerturbation);
    497       if (model2!=solver) {
     496      if (model2 != solver) {
    498497        int presolvedStatus = model2->status();
    499498        pinfo->postsolve(true);
    500         delete pinfo;
    501         pinfo = NULL;
    502        
     499        delete pinfo;
     500        pinfo = NULL;
     501
    503502        delete model2;
    504         int oldStatus=solver->status();
    505         solver->setProblemStatus(presolvedStatus);
    506         if (solver->logLevel()==63) // for gcc 4.6 bug
    507           printf("pstat %d stat %d\n",presolvedStatus,oldStatus);
     503        int oldStatus = solver->status();
     504        solver->setProblemStatus(presolvedStatus);
     505        if (solver->logLevel() == 63) // for gcc 4.6 bug
     506          printf("pstat %d stat %d\n", presolvedStatus, oldStatus);
    508507        //printf("Resolving from postsolved model\n");
    509508        // later try without (1) and check duals before solve
    510         if (presolvedStatus!=3
    511             &&(presolvedStatus||oldStatus==-1)) {
    512           if (!inCbcOrOther||presolvedStatus!=1) {
    513             disasterHandler_->setOsiModel(this);
    514             if (inCbcOrOther) {
    515               disasterHandler_->setSimplex(solver); // as "borrowed"
    516               disasterHandler_->setWhereFrom(6);
    517               solver->setDisasterHandler(disasterHandler_);
    518             }
    519             solver->primal(1);
    520             totalIterations += solver->numberIterations();
    521             if (inCbcOrOther) {
    522               if(disasterHandler_->inTrouble()) {
     509        if (presolvedStatus != 3
     510          && (presolvedStatus || oldStatus == -1)) {
     511          if (!inCbcOrOther || presolvedStatus != 1) {
     512            disasterHandler_->setOsiModel(this);
     513            if (inCbcOrOther) {
     514              disasterHandler_->setSimplex(solver); // as "borrowed"
     515              disasterHandler_->setWhereFrom(6);
     516              solver->setDisasterHandler(disasterHandler_);
     517            }
     518            solver->primal(1);
     519            totalIterations += solver->numberIterations();
     520            if (inCbcOrOther) {
     521              if (disasterHandler_->inTrouble()) {
    523522#ifdef COIN_DEVELOP
    524                 printf("primal trouble a\n");
    525 #endif
    526                 if (disasterHandler_->typeOfDisaster()) {
    527                   // We want to abort
    528                   abortSearch=true;
    529                   goto disaster;
    530                 }
    531                 // try just going back in (but with dual)
    532                 disasterHandler_->setPhase(1);
    533                 solver->dual();
    534                 totalIterations += solver->numberIterations();
    535                 if (disasterHandler_->inTrouble()) {
     523                printf("primal trouble a\n");
     524#endif
     525                if (disasterHandler_->typeOfDisaster()) {
     526                  // We want to abort
     527                  abortSearch = true;
     528                  goto disaster;
     529                }
     530                // try just going back in (but with dual)
     531                disasterHandler_->setPhase(1);
     532                solver->dual();
     533                totalIterations += solver->numberIterations();
     534                if (disasterHandler_->inTrouble()) {
    536535#ifdef COIN_DEVELOP
    537                   printf("primal trouble b\n");
    538 #endif
    539                   if (disasterHandler_->typeOfDisaster()) {
    540                     // We want to abort
    541                     abortSearch=true;
    542                     goto disaster;
    543                   }
    544                   // try primal with original basis
    545                   disasterHandler_->setPhase(2);
    546                   setBasis(basis_,solver);
    547                   solver->dual();
    548                   totalIterations += solver->numberIterations();
    549                 }
    550                 if(disasterHandler_->inTrouble()) {
     536                  printf("primal trouble b\n");
     537#endif
     538                  if (disasterHandler_->typeOfDisaster()) {
     539                    // We want to abort
     540                    abortSearch = true;
     541                    goto disaster;
     542                  }
     543                  // try primal with original basis
     544                  disasterHandler_->setPhase(2);
     545                  setBasis(basis_, solver);
     546                  solver->dual();
     547                  totalIterations += solver->numberIterations();
     548                }
     549                if (disasterHandler_->inTrouble()) {
    551550#ifdef COIN_DEVELOP
    552                   printf("disaster - treat as infeasible\n");
    553 #endif
    554                   if (disasterHandler_->typeOfDisaster()) {
    555                     // We want to abort
    556                     abortSearch=true;
    557                     goto disaster;
    558                   }
    559                   solver->setProblemStatus(1);
    560                 }
    561               }
    562               // reset
    563               solver->setDisasterHandler(NULL);
    564             }
    565           }
    566         }
    567       }
    568       lastAlgorithm_=1; // primal
     551                  printf("disaster - treat as infeasible\n");
     552#endif
     553                  if (disasterHandler_->typeOfDisaster()) {
     554                    // We want to abort
     555                    abortSearch = true;
     556                    goto disaster;
     557                  }
     558                  solver->setProblemStatus(1);
     559                }
     560              }
     561              // reset
     562              solver->setDisasterHandler(NULL);
     563            }
     564          }
     565        }
     566      }
     567      lastAlgorithm_ = 1; // primal
    569568      //if (solver->numberIterations())
    570569      //printf("****** iterated %d\n",solver->numberIterations());
    571570    } else {
    572571      // do we want crash
    573       if (doCrash>0)
    574         solver->crash(1000.0,2);
    575       else if (doCrash==0)
    576         solver->crash(1000.0,0);
    577       if (algorithm<0)
    578         doPrimal=false;
    579       else if (algorithm>0)
    580         doPrimal=true;
     572      if (doCrash > 0)
     573        solver->crash(1000.0, 2);
     574      else if (doCrash == 0)
     575        solver->crash(1000.0, 0);
     576      if (algorithm < 0)
     577        doPrimal = false;
     578      else if (algorithm > 0)
     579        doPrimal = true;
    581580      disasterHandler_->setOsiModel(this);
    582581      disasterHandler_->setSimplex(solver); // as "borrowed"
    583       bool inCbcOrOther = (modelPtr_->specialOptions()&0x03000000)!=0;
    584       if (!doPrimal) 
    585         disasterHandler_->setWhereFrom(4);
     582      bool inCbcOrOther = (modelPtr_->specialOptions() & 0x03000000) != 0;
     583      if (!doPrimal)
     584        disasterHandler_->setWhereFrom(4);
    586585      else
    587         disasterHandler_->setWhereFrom(6);
     586        disasterHandler_->setWhereFrom(6);
    588587      if (inCbcOrOther)
    589         solver->setDisasterHandler(disasterHandler_);
     588        solver->setDisasterHandler(disasterHandler_);
    590589      if (!doPrimal) {
    591590        //printf("doing dual\n");
    592591        solver->dual(0);
    593         totalIterations += solver->numberIterations();
    594         if (inCbcOrOther) {
    595           if(disasterHandler_->inTrouble()) {
     592        totalIterations += solver->numberIterations();
     593        if (inCbcOrOther) {
     594          if (disasterHandler_->inTrouble()) {
    596595#ifdef COIN_DEVELOP
    597             printf("dual trouble a\n");
    598 #endif
    599             if (disasterHandler_->typeOfDisaster()) {
    600               // We want to abort
    601               abortSearch=true;
    602               goto disaster;
    603             }
    604             // try just going back in
    605             disasterHandler_->setPhase(1);
    606             solver->dual();
    607             totalIterations += solver->numberIterations();
    608             if (disasterHandler_->inTrouble()) {
     596            printf("dual trouble a\n");
     597#endif
     598            if (disasterHandler_->typeOfDisaster()) {
     599              // We want to abort
     600              abortSearch = true;
     601              goto disaster;
     602            }
     603            // try just going back in
     604            disasterHandler_->setPhase(1);
     605            solver->dual();
     606            totalIterations += solver->numberIterations();
     607            if (disasterHandler_->inTrouble()) {
    609608#ifdef COIN_DEVELOP
    610               printf("dual trouble b\n");
    611 #endif
    612               if (disasterHandler_->typeOfDisaster()) {
    613                 // We want to abort
    614                 abortSearch=true;
    615                 goto disaster;
    616               }
    617               // try primal with original basis
    618               disasterHandler_->setPhase(2);
    619               setBasis(basis_,solver);
    620               solver->primal();
    621               totalIterations += solver->numberIterations();
    622             }
    623             if(disasterHandler_->inTrouble()) {
     609              printf("dual trouble b\n");
     610#endif
     611              if (disasterHandler_->typeOfDisaster()) {
     612                // We want to abort
     613                abortSearch = true;
     614                goto disaster;
     615              }
     616              // try primal with original basis
     617              disasterHandler_->setPhase(2);
     618              setBasis(basis_, solver);
     619              solver->primal();
     620              totalIterations += solver->numberIterations();
     621            }
     622            if (disasterHandler_->inTrouble()) {
    624623#ifdef COIN_DEVELOP
    625               printf("disaster - treat as infeasible\n");
    626 #endif
    627               if (disasterHandler_->typeOfDisaster()) {
    628                 // We want to abort
    629                 abortSearch=true;
    630                 goto disaster;
    631               }
    632               solver->setProblemStatus(1);
    633             }
    634           }
    635           // reset
    636           solver->setDisasterHandler(NULL);
    637         }
    638         lastAlgorithm_=2; // dual
     624              printf("disaster - treat as infeasible\n");
     625#endif
     626              if (disasterHandler_->typeOfDisaster()) {
     627                // We want to abort
     628                abortSearch = true;
     629                goto disaster;
     630              }
     631              solver->setProblemStatus(1);
     632            }
     633          }
     634          // reset
     635          solver->setDisasterHandler(NULL);
     636        }
     637        lastAlgorithm_ = 2; // dual
    639638        // check if clp thought it was in a loop
    640         if (solver->status()==3&&!solver->hitMaximumIterations()) {
     639        if (solver->status() == 3 && !solver->hitMaximumIterations()) {
    641640          // switch algorithm
    642641          solver->primal(0);
    643           totalIterations += solver->numberIterations();
    644           lastAlgorithm_=1; // primal
     642          totalIterations += solver->numberIterations();
     643          lastAlgorithm_ = 1; // primal
    645644        }
    646645      } else {
    647646        //printf("doing primal\n");
    648647        solver->primal(1);
    649         totalIterations += solver->numberIterations();
    650         if (inCbcOrOther) {
    651           if(disasterHandler_->inTrouble()) {
     648        totalIterations += solver->numberIterations();
     649        if (inCbcOrOther) {
     650          if (disasterHandler_->inTrouble()) {
    652651#ifdef COIN_DEVELOP
    653             printf("primal trouble a\n");
    654 #endif
    655             if (disasterHandler_->typeOfDisaster()) {
    656               // We want to abort
    657               abortSearch=true;
    658               goto disaster;
    659             }
    660             // try just going back in (but with dual)
    661             disasterHandler_->setPhase(1);
    662             solver->dual();
    663             totalIterations += solver->numberIterations();
    664             if (disasterHandler_->inTrouble()) {
     652            printf("primal trouble a\n");
     653#endif
     654            if (disasterHandler_->typeOfDisaster()) {
     655              // We want to abort
     656              abortSearch = true;
     657              goto disaster;
     658            }
     659            // try just going back in (but with dual)
     660            disasterHandler_->setPhase(1);
     661            solver->dual();
     662            totalIterations += solver->numberIterations();
     663            if (disasterHandler_->inTrouble()) {
    665664#ifdef COIN_DEVELOP
    666               printf("primal trouble b\n");
    667 #endif
    668               if (disasterHandler_->typeOfDisaster()) {
    669                 // We want to abort
    670                 abortSearch=true;
    671                 goto disaster;
    672               }
    673               // try primal with original basis
    674               disasterHandler_->setPhase(2);
    675               setBasis(basis_,solver);
    676               solver->dual();
    677               totalIterations += solver->numberIterations();
    678             }
    679             if(disasterHandler_->inTrouble()) {
     665              printf("primal trouble b\n");
     666#endif
     667              if (disasterHandler_->typeOfDisaster()) {
     668                // We want to abort
     669                abortSearch = true;
     670                goto disaster;
     671              }
     672              // try primal with original basis
     673              disasterHandler_->setPhase(2);
     674              setBasis(basis_, solver);
     675              solver->dual();
     676              totalIterations += solver->numberIterations();
     677            }
     678            if (disasterHandler_->inTrouble()) {
    680679#ifdef COIN_DEVELOP
    681               printf("disaster - treat as infeasible\n");
    682 #endif
    683               if (disasterHandler_->typeOfDisaster()) {
    684                 // We want to abort
    685                 abortSearch=true;
    686                 goto disaster;
    687               }
    688               solver->setProblemStatus(1);
    689             }
    690           }
    691           // reset
    692           solver->setDisasterHandler(NULL);
    693         }
    694         lastAlgorithm_=1; // primal
     680              printf("disaster - treat as infeasible\n");
     681#endif
     682              if (disasterHandler_->typeOfDisaster()) {
     683                // We want to abort
     684                abortSearch = true;
     685                goto disaster;
     686              }
     687              solver->setProblemStatus(1);
     688            }
     689          }
     690          // reset
     691          solver->setDisasterHandler(NULL);
     692        }
     693        lastAlgorithm_ = 1; // primal
    695694        // check if clp thought it was in a loop
    696         if (solver->status()==3&&!solver->hitMaximumIterations()) {
     695        if (solver->status() == 3 && !solver->hitMaximumIterations()) {
    697696          // switch algorithm
    698697          solver->dual(0);
    699           totalIterations += solver->numberIterations();
    700           lastAlgorithm_=2; // dual
     698          totalIterations += solver->numberIterations();
     699          lastAlgorithm_ = 2; // dual
    701700        }
    702701      }
    703702    }
    704703    // If scaled feasible but unscaled infeasible take action
    705     if (!solver->status()&&cleanupScaling_) {
     704    if (!solver->status() && cleanupScaling_) {
    706705      solver->cleanup(cleanupScaling_);
    707706    }
    708707    basis_ = getBasis(solver);
    709708    //basis_.print();
    710     const double * rowScale2 = solver->rowScale();
     709    const double *rowScale2 = solver->rowScale();
    711710    solver->setSpecialOptions(saveOptions);
    712     if (!rowScale1&&rowScale2) {
     711    if (!rowScale1 && rowScale2) {
    713712      // need to release memory
    714713      if (!solver->savedRowScale_) {
    715         solver->setRowScale(NULL);
    716         solver->setColumnScale(NULL);
     714        solver->setRowScale(NULL);
     715        solver->setColumnScale(NULL);
    717716      } else {
    718         solver->rowScale_=NULL;
    719         solver->columnScale_=NULL;
     717        solver->rowScale_ = NULL;
     718        solver->columnScale_ = NULL;
    720719      }
    721720    }
    722721  } else {
    723722    // User doing nothing and all slack basis
    724     ClpSolve options=solveOptions_;
     723    ClpSolve options = solveOptions_;
    725724    bool yesNo;
    726725    OsiHintStrength strength;
    727     getHintParam(OsiDoInBranchAndCut,yesNo,strength);
     726    getHintParam(OsiDoInBranchAndCut, yesNo, strength);
    728727    if (yesNo) {
    729       solver->setSpecialOptions(solver->specialOptions()|1024);
     728      solver->setSpecialOptions(solver->specialOptions() | 1024);
    730729    }
    731730    solver->initialSolve(options);
     
    733732    lastAlgorithm_ = 2; // say dual
    734733    // If scaled feasible but unscaled infeasible take action
    735     if (!solver->status()&&cleanupScaling_) {
     734    if (!solver->status() && cleanupScaling_) {
    736735      solver->cleanup(cleanupScaling_);
    737736    }
     
    740739  }
    741740  solver->messageHandler()->setLogLevel(saveMessageLevel);
    742  disaster:
     741disaster:
    743742  if (deleteSolver) {
    744743    solver->returnModel(*modelPtr_);
     
    747746  if (startFinishOptions) {
    748747    int save = modelPtr_->logLevel();
    749     if (save<2) modelPtr_->setLogLevel(0);
    750     modelPtr_->dual(0,startFinishOptions);
     748    if (save < 2)
     749      modelPtr_->setLogLevel(0);
     750    modelPtr_->dual(0, startFinishOptions);
    751751    totalIterations += modelPtr_->numberIterations();
    752752    modelPtr_->setLogLevel(save);
    753753  }
    754   if (saveSolveType==2) {
     754  if (saveSolveType == 2) {
    755755    enableSimplexInterface(doingPrimal);
    756756  }
    757757  if (savedObjective) {
    758758    // fix up
    759     modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
     759    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
    760760    //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    761     modelPtr_->objective_=savedObjective;
     761    modelPtr_->objective_ = savedObjective;
    762762    if (!modelPtr_->problemStatus_) {
    763       CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
    764       CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
    765       if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
    766         CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
     763      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
     764      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
     765      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
     766        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
    767767      modelPtr_->computeObjectiveValue();
    768768    }
     
    770770  modelPtr_->setNumberIterations(totalIterations);
    771771  handler_->setLogLevel(saveMessageLevel2);
    772   if (modelPtr_->problemStatus_==3&&lastAlgorithm_==2)
     772  if (modelPtr_->problemStatus_ == 3 && lastAlgorithm_ == 2)
    773773    modelPtr_->computeObjectiveValue();
    774774  // mark so we can pick up objective value quickly
    775   modelPtr_->upperIn_=0.0;
     775  modelPtr_->upperIn_ = 0.0;
    776776#ifdef PRINT_TIME
    777   time1 = CoinCpuTime()-time1;
     777  time1 = CoinCpuTime() - time1;
    778778  totalTime += time1;
    779779#endif
    780   assert (!modelPtr_->disasterHandler());
    781   if (lastAlgorithm_<1||lastAlgorithm_>2)
    782     lastAlgorithm_=1;
     780  assert(!modelPtr_->disasterHandler());
     781  if (lastAlgorithm_ < 1 || lastAlgorithm_ > 2)
     782    lastAlgorithm_ = 1;
    783783  if (abortSearch) {
    784     lastAlgorithm_=-911;
     784    lastAlgorithm_ = -911;
    785785    modelPtr_->setProblemStatus(4);
    786786  }
     
    794794#endif
    795795#ifdef PRINT_TIME
    796   std::cout<<time1<<" seconds - total "<<totalTime<<std::endl;
     796  std::cout << time1 << " seconds - total " << totalTime << std::endl;
    797797#endif
    798798  delete pinfo;
     
    805805    int i;
    806806    int n = getNumCols();
    807     const double *lower = getColLower() ;
    808     const double *upper = getColUpper() ;
    809     for (i=0;i<n;i++) {
    810       assert (lower[i]<1.0e12);
    811       assert (upper[i]>-1.0e12);
     807    const double *lower = getColLower();
     808    const double *upper = getColUpper();
     809    for (i = 0; i < n; i++) {
     810      assert(lower[i] < 1.0e12);
     811      assert(upper[i] > -1.0e12);
    812812    }
    813813    n = getNumRows();
    814     lower = getRowLower() ;
    815     upper = getRowUpper() ;
    816     for (i=0;i<n;i++) {
    817       assert (lower[i]<1.0e12);
    818       assert (upper[i]>-1.0e12);
    819     }
    820   }
    821 #endif
    822   if ((stuff_.solverOptions_&65536)!=0) {
     814    lower = getRowLower();
     815    upper = getRowUpper();
     816    for (i = 0; i < n; i++) {
     817      assert(lower[i] < 1.0e12);
     818      assert(upper[i] > -1.0e12);
     819    }
     820  }
     821#endif
     822  if ((stuff_.solverOptions_ & 65536) != 0) {
    823823    modelPtr_->fastDual2(&stuff_);
    824824    return;
    825825  }
    826   if ((specialOptions_&2097152)!=0||(specialOptions_&4194304)!=0) {
     826  if ((specialOptions_ & 2097152) != 0 || (specialOptions_ & 4194304) != 0) {
    827827    bool takeHint;
    828828    OsiHintStrength strength;
    829829    int algorithm = 0;
    830     getHintParam(OsiDoDualInResolve,takeHint,strength);
    831     if (strength!=OsiHintIgnore)
     830    getHintParam(OsiDoDualInResolve, takeHint, strength);
     831    if (strength != OsiHintIgnore)
    832832      algorithm = takeHint ? -1 : 1;
    833     if (algorithm>0||(specialOptions_&4194304)!=0) {
     833    if (algorithm > 0 || (specialOptions_ & 4194304) != 0) {
    834834      // Gub
    835       resolveGub((9*modelPtr_->numberRows())/10);
     835      resolveGub((9 * modelPtr_->numberRows()) / 10);
    836836      return;
    837837    }
     
    841841  bool takeHint;
    842842  OsiHintStrength strength;
    843   bool gotHint = (getHintParam(OsiDoInBranchAndCut,takeHint,strength));
    844   assert (gotHint);
     843  bool gotHint = (getHintParam(OsiDoInBranchAndCut, takeHint, strength));
     844  assert(gotHint);
    845845  // mark so we can pick up objective value quickly
    846   modelPtr_->upperIn_=0.0;
    847   if ((specialOptions_&4096)!=0) {
     846  modelPtr_->upperIn_ = 0.0;
     847  if ((specialOptions_ & 4096) != 0) {
    848848    // Quick check to see if optimal
    849849    modelPtr_->checkSolutionInternal();
    850     if (modelPtr_->problemStatus()==0) {
     850    if (modelPtr_->problemStatus() == 0) {
    851851      modelPtr_->setNumberIterations(0);
    852852      return;
    853853    }
    854854  }
    855   int totalIterations=0;
    856   bool abortSearch=false;
    857   ClpObjective * savedObjective=NULL;
    858   double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
     855  int totalIterations = 0;
     856  bool abortSearch = false;
     857  ClpObjective *savedObjective = NULL;
     858  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
    859859  if (fakeObjective_) {
    860     modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~128));
     860    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() & (~128));
    861861    // See if all with costs fixed
    862862    int numberColumns = modelPtr_->numberColumns_;
    863     const double * obj = modelPtr_->objective();
    864     const double * lower = modelPtr_->columnLower();
    865     const double * upper = modelPtr_->columnUpper();
     863    const double *obj = modelPtr_->objective();
     864    const double *lower = modelPtr_->columnLower();
     865    const double *upper = modelPtr_->columnUpper();
    866866    int i;
    867     for (i=0;i<numberColumns;i++) {
     867    for (i = 0; i < numberColumns; i++) {
    868868      double objValue = obj[i];
    869869      if (objValue) {
    870         if (lower[i]!=upper[i])
    871           break;
    872       }
    873     }
    874     if (i==numberColumns) {
    875       if ((specialOptions_&524288)==0) {
    876         // Set fake
    877         savedObjective=modelPtr_->objective_;
    878         modelPtr_->objective_=fakeObjective_;
    879         modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
     870        if (lower[i] != upper[i])
     871          break;
     872      }
     873    }
     874    if (i == numberColumns) {
     875      if ((specialOptions_ & 524288) == 0) {
     876        // Set fake
     877        savedObjective = modelPtr_->objective_;
     878        modelPtr_->objective_ = fakeObjective_;
     879        modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
    880880      } else {
    881         modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()|128);
     881        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() | 128);
    882882      }
    883883    }
    884884  }
    885885  // If using Clp initialSolve and primal - just do here
    886   gotHint = (getHintParam(OsiDoDualInResolve,takeHint,strength));
    887   assert (gotHint);
    888   if (strength!=OsiHintIgnore&&!takeHint&&solveOptions_.getSpecialOption(6)) {
    889     ClpSolve options=solveOptions_;
     886  gotHint = (getHintParam(OsiDoDualInResolve, takeHint, strength));
     887  assert(gotHint);
     888  if (strength != OsiHintIgnore && !takeHint && solveOptions_.getSpecialOption(6)) {
     889    ClpSolve options = solveOptions_;
    890890    // presolve
    891     getHintParam(OsiDoPresolveInResolve,takeHint,strength);
    892     if (strength!=OsiHintIgnore&&!takeHint)
     891    getHintParam(OsiDoPresolveInResolve, takeHint, strength);
     892    if (strength != OsiHintIgnore && !takeHint)
    893893      options.setPresolveType(ClpSolve::presolveOff);
    894894    int saveOptions = modelPtr_->specialOptions();
    895     getHintParam(OsiDoInBranchAndCut,takeHint,strength);
     895    getHintParam(OsiDoInBranchAndCut, takeHint, strength);
    896896    if (takeHint) {
    897       modelPtr_->setSpecialOptions(modelPtr_->specialOptions()|1024);
    898     }
    899     setBasis(basis_,modelPtr_);
     897      modelPtr_->setSpecialOptions(modelPtr_->specialOptions() | 1024);
     898    }
     899    setBasis(basis_, modelPtr_);
    900900    modelPtr_->initialSolve(options);
    901901    lastAlgorithm_ = 1; // say primal
    902902    // If scaled feasible but unscaled infeasible take action
    903     if (!modelPtr_->status()&&cleanupScaling_) {
     903    if (!modelPtr_->status() && cleanupScaling_) {
    904904      modelPtr_->cleanup(cleanupScaling_);
    905905    }
     
    907907    basis_ = getBasis(modelPtr_);
    908908  }
    909   int saveSolveType=modelPtr_->solveType();
    910   bool doingPrimal = modelPtr_->algorithm()>0;
    911   if (saveSolveType==2) {
     909  int saveSolveType = modelPtr_->solveType();
     910  bool doingPrimal = modelPtr_->algorithm() > 0;
     911  if (saveSolveType == 2) {
    912912    disableSimplexInterface();
    913913  }
    914914  int saveOptions = modelPtr_->specialOptions();
    915   int startFinishOptions=0;
    916   if (specialOptions_!=0x80000000) {
    917     if((specialOptions_&1)==0) {
    918       startFinishOptions=0;
    919       modelPtr_->setSpecialOptions(saveOptions|(64|1024|32768));
     915  int startFinishOptions = 0;
     916  if (specialOptions_ != 0x80000000) {
     917    if ((specialOptions_ & 1) == 0) {
     918      startFinishOptions = 0;
     919      modelPtr_->setSpecialOptions(saveOptions | (64 | 1024 | 32768));
    920920    } else {
    921       startFinishOptions=1+4;
    922       if ((specialOptions_&8)!=0)
    923         startFinishOptions +=2; // allow re-use of factorization
    924       if((specialOptions_&4)==0||!takeHint)
    925         modelPtr_->setSpecialOptions(saveOptions|(64|128|512|1024|4096|32768));
     921      startFinishOptions = 1 + 4;
     922      if ((specialOptions_ & 8) != 0)
     923        startFinishOptions += 2; // allow re-use of factorization
     924      if ((specialOptions_ & 4) == 0 || !takeHint)
     925        modelPtr_->setSpecialOptions(saveOptions | (64 | 128 | 512 | 1024 | 4096 | 32768));
    926926      else
    927         modelPtr_->setSpecialOptions(saveOptions|(64|128|512|1024|2048|4096|32768));
     927        modelPtr_->setSpecialOptions(saveOptions | (64 | 128 | 512 | 1024 | 2048 | 4096 | 32768));
    928928    }
    929929  } else {
    930     modelPtr_->setSpecialOptions(saveOptions|64|32768);
     930    modelPtr_->setSpecialOptions(saveOptions | 64 | 32768);
    931931  }
    932932  //printf("options %d size %d\n",modelPtr_->specialOptions(),modelPtr_->numberColumns());
    933933  //modelPtr_->setSolveType(1);
    934934  // Set message handler to have same levels etc
    935   int saveMessageLevel=modelPtr_->logLevel();
    936   int messageLevel=messageHandler()->logLevel();
     935  int saveMessageLevel = modelPtr_->logLevel();
     936  int messageLevel = messageHandler()->logLevel();
    937937  bool oldDefault;
    938   CoinMessageHandler * saveHandler = NULL;
     938  CoinMessageHandler *saveHandler = NULL;
    939939  if (!defaultHandler_)
    940     saveHandler = modelPtr_->pushMessageHandler(handler_,oldDefault);
     940    saveHandler = modelPtr_->pushMessageHandler(handler_, oldDefault);
    941941  //printf("basis before dual\n");
    942942  //basis_.print();
    943   setBasis(basis_,modelPtr_);
     943  setBasis(basis_, modelPtr_);
    944944#ifdef SAVE_MODEL
    945945  resolveTry++;
    946946#if SAVE_MODEL > 1
    947   if (resolveTry>=loResolveTry&&
    948       resolveTry<=hiResolveTry) {
     947  if (resolveTry >= loResolveTry && resolveTry <= hiResolveTry) {
    949948    char fileName[20];
    950     sprintf(fileName,"save%d.mod",resolveTry);
     949    sprintf(fileName, "save%d.mod", resolveTry);
    951950    modelPtr_->saveModel(fileName);
    952951  }
     
    955954  // set reasonable defaults
    956955  // Switch off printing if asked to
    957   gotHint = (getHintParam(OsiDoReducePrint,takeHint,strength));
    958   assert (gotHint);
    959   if (strength!=OsiHintIgnore&&takeHint) {
    960     if (messageLevel>0)
     956  gotHint = (getHintParam(OsiDoReducePrint, takeHint, strength));
     957  assert(gotHint);
     958  if (strength != OsiHintIgnore && takeHint) {
     959    if (messageLevel > 0)
    961960      messageLevel--;
    962961  }
    963   if (messageLevel<modelPtr_->messageHandler()->logLevel())
     962  if (messageLevel < modelPtr_->messageHandler()->logLevel())
    964963    modelPtr_->messageHandler()->setLogLevel(messageLevel);
    965964  // See if user set factorization frequency
    966965  int userFactorizationFrequency = modelPtr_->factorization()->maximumPivots();
    967966  // scaling
    968   if (modelPtr_->solveType()==1) {
    969     gotHint = (getHintParam(OsiDoScale,takeHint,strength));
    970     assert (gotHint);
    971     if (strength==OsiHintIgnore||takeHint) {
     967  if (modelPtr_->solveType() == 1) {
     968    gotHint = (getHintParam(OsiDoScale, takeHint, strength));
     969    assert(gotHint);
     970    if (strength == OsiHintIgnore || takeHint) {
    972971      if (!modelPtr_->scalingFlag())
    973         modelPtr_->scaling(3);
     972        modelPtr_->scaling(3);
    974973    } else {
    975974      modelPtr_->scaling(0);
     
    981980  // algorithm -1 force dual, +1 force primal
    982981  int algorithm = -1;
    983   gotHint = (getHintParam(OsiDoDualInResolve,takeHint,strength));
    984   assert (gotHint);
    985   if (strength!=OsiHintIgnore)
     982  gotHint = (getHintParam(OsiDoDualInResolve, takeHint, strength));
     983  assert(gotHint);
     984  if (strength != OsiHintIgnore)
    986985    algorithm = takeHint ? -1 : 1;
    987986  //modelPtr_->saveModel("save.bad");
    988987  // presolve
    989   gotHint = (getHintParam(OsiDoPresolveInResolve,takeHint,strength));
    990   assert (gotHint);
    991   if (strength!=OsiHintIgnore&&takeHint) {
     988  gotHint = (getHintParam(OsiDoPresolveInResolve, takeHint, strength));
     989  assert(gotHint);
     990  if (strength != OsiHintIgnore && takeHint) {
    992991#ifdef KEEP_SMALL
    993992    if (smallModel_) {
    994       delete [] spareArrays_;
     993      delete[] spareArrays_;
    995994      spareArrays_ = NULL;
    996995      delete smallModel_;
    997       smallModel_=NULL;
     996      smallModel_ = NULL;
    998997    }
    999998#endif
    1000999    ClpPresolve pinfo;
    1001     if ((specialOptions_&128)!=0) {
     1000    if ((specialOptions_ & 128) != 0) {
    10021001      specialOptions_ &= ~128;
    10031002    }
    1004     if ((modelPtr_->specialOptions()&1024)!=0) {
     1003    if ((modelPtr_->specialOptions() & 1024) != 0) {
    10051004      pinfo.setDoDual(false);
    10061005      pinfo.setDoTripleton(false);
     
    10091008      pinfo.setDoSingletonColumn(false);
    10101009    }
    1011     ClpSimplex * model2 = pinfo.presolvedModel(*modelPtr_,1.0e-8);
     1010    ClpSimplex *model2 = pinfo.presolvedModel(*modelPtr_, 1.0e-8);
    10121011    if (!model2) {
    10131012      // problem found to be infeasible - whats best?
     
    10151014    }
    10161015    // return number of rows
    1017     int * stats = reinterpret_cast<int *> (getApplicationData());
     1016    int *stats = reinterpret_cast< int * >(getApplicationData());
    10181017    if (stats) {
    1019       stats[0]=model2->numberRows();
    1020       stats[1]=model2->numberColumns();
     1018      stats[0] = model2->numberRows();
     1019      stats[1] = model2->numberColumns();
    10211020    }
    10221021    //printf("rows %d -> %d, columns %d -> %d\n",
     
    10241023    //     modelPtr_->numberColumns(),model2->numberColumns());
    10251024    // change from 200
    1026     if (modelPtr_->factorization()->maximumPivots()==200)
    1027       model2->factorization()->maximumPivots(100+model2->numberRows()/50);
     1025    if (modelPtr_->factorization()->maximumPivots() == 200)
     1026      model2->factorization()->maximumPivots(100 + model2->numberRows() / 50);
    10281027    else
    10291028      model2->factorization()->maximumPivots(userFactorizationFrequency);
    1030     if (algorithm<0) {
     1029    if (algorithm < 0) {
    10311030      model2->dual();
    10321031      totalIterations += model2->numberIterations();
    10331032      // check if clp thought it was in a loop
    1034       if (model2->status()==3&&!model2->hitMaximumIterations()) {
    1035         // switch algorithm
    1036         model2->primal();
    1037         totalIterations += model2->numberIterations();
     1033      if (model2->status() == 3 && !model2->hitMaximumIterations()) {
     1034        // switch algorithm
     1035        model2->primal();
     1036        totalIterations += model2->numberIterations();
    10381037      }
    10391038    } else {
     
    10411040      totalIterations += model2->numberIterations();
    10421041      // check if clp thought it was in a loop
    1043       if (model2->status()==3&&!model2->hitMaximumIterations()) {
    1044         // switch algorithm
    1045         model2->dual();
    1046         totalIterations += model2->numberIterations();
    1047       }
    1048     }
    1049     if (model2!=modelPtr_) {
    1050       int finalStatus=model2->status();
     1042      if (model2->status() == 3 && !model2->hitMaximumIterations()) {
     1043        // switch algorithm
     1044        model2->dual();
     1045        totalIterations += model2->numberIterations();
     1046      }
     1047    }
     1048    if (model2 != modelPtr_) {
     1049      int finalStatus = model2->status();
    10511050      pinfo.postsolve(true);
    1052    
     1051
    10531052      delete model2;
    10541053      // later try without (1) and check duals before solve
    1055       if (finalStatus!=3&&(finalStatus||modelPtr_->status()==-1)) {
     1054      if (finalStatus != 3 && (finalStatus || modelPtr_->status() == -1)) {
    10561055        modelPtr_->primal(1);
    1057         totalIterations += modelPtr_->numberIterations();
    1058         lastAlgorithm_=1; // primal
     1056        totalIterations += modelPtr_->numberIterations();
     1057        lastAlgorithm_ = 1; // primal
    10591058        //if (modelPtr_->numberIterations())
    10601059        //printf("****** iterated %d\n",modelPtr_->numberIterations());
     
    10641063    //modelPtr_->setLogLevel(63);
    10651064    //modelPtr_->setDualTolerance(1.0e-7);
    1066     if (false&&modelPtr_->scalingFlag_>0&&!modelPtr_->rowScale_&&
    1067         !modelPtr_->rowCopy_&&matrixByRow_) {
    1068       assert (matrixByRow_->getNumElements()==modelPtr_->clpMatrix()->getNumElements());
     1065    if (false && modelPtr_->scalingFlag_ > 0 && !modelPtr_->rowScale_ && !modelPtr_->rowCopy_ && matrixByRow_) {
     1066      assert(matrixByRow_->getNumElements() == modelPtr_->clpMatrix()->getNumElements());
    10691067      modelPtr_->setNewRowCopy(new ClpPackedMatrix(*matrixByRow_));
    10701068    }
    1071     if (algorithm<0) {
     1069    if (algorithm < 0) {
    10721070      //writeMps("try1");
    10731071      int savePerturbation = modelPtr_->perturbation();
    1074       if ((specialOptions_&2)!=0)
    1075         modelPtr_->setPerturbation(100);
     1072      if ((specialOptions_ & 2) != 0)
     1073        modelPtr_->setPerturbation(100);
    10761074      //modelPtr_->messageHandler()->setLogLevel(1);
    10771075      //writeMpsNative("bad",NULL,NULL,2,1,1.0);
    10781076      disasterHandler_->setOsiModel(this);
    1079       bool inCbcOrOther = (modelPtr_->specialOptions()&0x03000000)!=0;
     1077      bool inCbcOrOther = (modelPtr_->specialOptions() & 0x03000000) != 0;
    10801078#if 0
    10811079      // See how many integers fixed
     
    11001098      }
    11011099#endif
    1102       if((specialOptions_&1)==0||
    1103          (specialOptions_&2048)!=0||
    1104          (modelPtr_->specialOptions_&2097152)!=0/*||skipCrunch*/) {
    1105         disasterHandler_->setWhereFrom(0); // dual
    1106         if (inCbcOrOther)
    1107           modelPtr_->setDisasterHandler(disasterHandler_);
    1108         bool specialScale;
    1109         if ((specialOptions_&131072)!=0&&!modelPtr_->rowScale_) {
    1110           modelPtr_->rowScale_ = rowScale_.array();
    1111           modelPtr_->columnScale_ = columnScale_.array();
    1112           specialScale=true;
    1113         } else {
    1114           specialScale=false;
    1115         }
     1100      if ((specialOptions_ & 1) == 0 || (specialOptions_ & 2048) != 0 || (modelPtr_->specialOptions_ & 2097152) != 0 /*||skipCrunch*/) {
     1101        disasterHandler_->setWhereFrom(0); // dual
     1102        if (inCbcOrOther)
     1103          modelPtr_->setDisasterHandler(disasterHandler_);
     1104        bool specialScale;
     1105        if ((specialOptions_ & 131072) != 0 && !modelPtr_->rowScale_) {
     1106          modelPtr_->rowScale_ = rowScale_.array();
     1107          modelPtr_->columnScale_ = columnScale_.array();
     1108          specialScale = true;
     1109        } else {
     1110          specialScale = false;
     1111        }
    11161112#ifdef KEEP_SMALL
    1117         if (smallModel_) {
    1118           delete [] spareArrays_;
    1119           spareArrays_ = NULL;
    1120           delete smallModel_;
    1121           smallModel_=NULL;
    1122         }
     1113        if (smallModel_) {
     1114          delete[] spareArrays_;
     1115          spareArrays_ = NULL;
     1116          delete smallModel_;
     1117          smallModel_ = NULL;
     1118        }
    11231119#endif
    11241120#ifdef CBC_STATISTICS
    1125         osi_dual++;
    1126 #endif 
    1127         modelPtr_->dual(0,startFinishOptions);
    1128         totalIterations += modelPtr_->numberIterations();
    1129         if (specialScale) {
    1130           modelPtr_->rowScale_ = NULL;
    1131           modelPtr_->columnScale_ = NULL;
    1132         }
     1121        osi_dual++;
     1122#endif
     1123        modelPtr_->dual(0, startFinishOptions);
     1124        totalIterations += modelPtr_->numberIterations();
     1125        if (specialScale) {
     1126          modelPtr_->rowScale_ = NULL;
     1127          modelPtr_->columnScale_ = NULL;
     1128        }
    11331129      } else {
    11341130#ifdef CBC_STATISTICS
    1135         osi_crunch++;
    1136 #endif 
    1137         crunch();
    1138         totalIterations += modelPtr_->numberIterations();
    1139         if (modelPtr_->problemStatus()==4)
    1140           goto disaster;
    1141         // should have already been fixed if problems
    1142         inCbcOrOther=false;
     1131        osi_crunch++;
     1132#endif
     1133        crunch();
     1134        totalIterations += modelPtr_->numberIterations();
     1135        if (modelPtr_->problemStatus() == 4)
     1136          goto disaster;
     1137        // should have already been fixed if problems
     1138        inCbcOrOther = false;
    11431139      }
    11441140      if (inCbcOrOther) {
    1145         if(disasterHandler_->inTrouble()) {
    1146           if (disasterHandler_->typeOfDisaster()) {
    1147             // We want to abort
    1148             abortSearch=true;
    1149             goto disaster;
    1150           }
    1151           // try just going back in
    1152           disasterHandler_->setPhase(1);
    1153           modelPtr_->dual();
    1154           totalIterations += modelPtr_->numberIterations();
    1155           if (disasterHandler_->inTrouble()) {
    1156             if (disasterHandler_->typeOfDisaster()) {
    1157               // We want to abort
    1158               abortSearch=true;
    1159               goto disaster;
    1160             }
    1161             // try primal with original basis
    1162             disasterHandler_->setPhase(2);
    1163             setBasis(basis_,modelPtr_);
    1164             modelPtr_->primal();
    1165             totalIterations += modelPtr_->numberIterations();
    1166           }
    1167           if(disasterHandler_->inTrouble()) {
     1141        if (disasterHandler_->inTrouble()) {
     1142          if (disasterHandler_->typeOfDisaster()) {
     1143            // We want to abort
     1144            abortSearch = true;
     1145            goto disaster;
     1146          }
     1147          // try just going back in
     1148          disasterHandler_->setPhase(1);
     1149          modelPtr_->dual();
     1150          totalIterations += modelPtr_->numberIterations();
     1151          if (disasterHandler_->inTrouble()) {
     1152            if (disasterHandler_->typeOfDisaster()) {
     1153              // We want to abort
     1154              abortSearch = true;
     1155              goto disaster;
     1156            }
     1157            // try primal with original basis
     1158            disasterHandler_->setPhase(2);
     1159            setBasis(basis_, modelPtr_);
     1160            modelPtr_->primal();
     1161            totalIterations += modelPtr_->numberIterations();
     1162          }
     1163          if (disasterHandler_->inTrouble()) {
    11681164#ifdef COIN_DEVELOP
    1169             printf("disaster - treat as infeasible\n");
    1170 #endif
    1171             if (disasterHandler_->typeOfDisaster()) {
    1172               // We want to abort
    1173               abortSearch=true;
    1174               goto disaster;
    1175             }
    1176             modelPtr_->setProblemStatus(1);
    1177           }
    1178         }
    1179         // reset
    1180         modelPtr_->setDisasterHandler(NULL);
    1181       }
    1182       if (modelPtr_->problemStatus()==4) {
    1183         // bad bounds?
    1184         modelPtr_->setProblemStatus(1);
    1185       }
    1186       if (!modelPtr_->problemStatus()&&0) {
     1165            printf("disaster - treat as infeasible\n");
     1166#endif
     1167            if (disasterHandler_->typeOfDisaster()) {
     1168              // We want to abort
     1169              abortSearch = true;
     1170              goto disaster;
     1171            }
     1172            modelPtr_->setProblemStatus(1);
     1173          }
     1174        }
     1175        // reset
     1176        modelPtr_->setDisasterHandler(NULL);
     1177      }
     1178      if (modelPtr_->problemStatus() == 4) {
     1179        // bad bounds?
     1180        modelPtr_->setProblemStatus(1);
     1181      }
     1182      if (!modelPtr_->problemStatus() && 0) {
    11871183        int numberColumns = modelPtr_->numberColumns();
    1188         const double * columnLower = modelPtr_->columnLower();
    1189         const double * columnUpper = modelPtr_->columnUpper();
    1190         int nBad=0;
    1191         for (int i=0;i<numberColumns;i++) {
    1192           if (columnLower[i]==columnUpper[i]&&modelPtr_->getColumnStatus(i)==ClpSimplex::basic) {
     1184        const double *columnLower = modelPtr_->columnLower();
     1185        const double *columnUpper = modelPtr_->columnUpper();
     1186        int nBad = 0;
     1187        for (int i = 0; i < numberColumns; i++) {
     1188          if (columnLower[i] == columnUpper[i] && modelPtr_->getColumnStatus(i) == ClpSimplex::basic) {
    11931189            nBad++;
    1194             modelPtr_->setColumnStatus(i,ClpSimplex::isFixed);
     1190            modelPtr_->setColumnStatus(i, ClpSimplex::isFixed);
    11951191          }
    11961192        }
    11971193        if (nBad) {
    11981194          modelPtr_->primal(1);
    1199     totalIterations += modelPtr_->numberIterations();
    1200           printf("%d fixed basic - %d iterations\n",nBad,modelPtr_->numberIterations());
     1195          totalIterations += modelPtr_->numberIterations();
     1196          printf("%d fixed basic - %d iterations\n", nBad, modelPtr_->numberIterations());
    12011197        }
    12021198      }
    1203       assert (modelPtr_->objectiveValue()<1.0e100);
     1199      assert(modelPtr_->objectiveValue() < 1.0e100);
    12041200      modelPtr_->setPerturbation(savePerturbation);
    1205       lastAlgorithm_=2; // dual
     1201      lastAlgorithm_ = 2; // dual
    12061202      // check if clp thought it was in a loop
    1207       if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
    1208         modelPtr_->setSpecialOptions(saveOptions);
    1209         // switch algorithm
    1210         //modelPtr_->messageHandler()->setLogLevel(63);
    1211         // Allow for catastrophe
    1212         int saveMax = modelPtr_->maximumIterations();
    1213         int numberIterations = modelPtr_->numberIterations();
    1214         int numberRows = modelPtr_->numberRows();
    1215         int numberColumns = modelPtr_->numberColumns();
    1216         if (modelPtr_->maximumIterations()>100000+numberIterations)
    1217           modelPtr_->setMaximumIterations(numberIterations + 1000 + 2*numberRows+numberColumns);
    1218         modelPtr_->primal(0,startFinishOptions);
    1219         totalIterations += modelPtr_->numberIterations();
    1220         modelPtr_->setMaximumIterations(saveMax);
    1221         lastAlgorithm_=1; // primal
    1222         if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
     1203      if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
     1204        modelPtr_->setSpecialOptions(saveOptions);
     1205        // switch algorithm
     1206        //modelPtr_->messageHandler()->setLogLevel(63);
     1207        // Allow for catastrophe
     1208        int saveMax = modelPtr_->maximumIterations();
     1209        int numberIterations = modelPtr_->numberIterations();
     1210        int numberRows = modelPtr_->numberRows();
     1211        int numberColumns = modelPtr_->numberColumns();
     1212        if (modelPtr_->maximumIterations() > 100000 + numberIterations)
     1213          modelPtr_->setMaximumIterations(numberIterations + 1000 + 2 * numberRows + numberColumns);
     1214        modelPtr_->primal(0, startFinishOptions);
     1215        totalIterations += modelPtr_->numberIterations();
     1216        modelPtr_->setMaximumIterations(saveMax);
     1217        lastAlgorithm_ = 1; // primal
     1218        if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
    12231219#ifdef COIN_DEVELOP
    1224           printf("in trouble - try all slack\n");
    1225 #endif
    1226           CoinWarmStartBasis allSlack;
    1227           setBasis(allSlack,modelPtr_);
    1228           modelPtr_->dual();
    1229           totalIterations += modelPtr_->numberIterations();
    1230           if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
    1231             if (modelPtr_->numberPrimalInfeasibilities()) {
     1220          printf("in trouble - try all slack\n");
     1221#endif
     1222          CoinWarmStartBasis allSlack;
     1223          setBasis(allSlack, modelPtr_);
     1224          modelPtr_->dual();
     1225          totalIterations += modelPtr_->numberIterations();
     1226          if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
     1227            if (modelPtr_->numberPrimalInfeasibilities()) {
    12321228#ifdef COIN_DEVELOP
    1233               printf("Real real trouble - treat as infeasible\n");
    1234 #endif
    1235               modelPtr_->setProblemStatus(1);
    1236             } else {
     1229              printf("Real real trouble - treat as infeasible\n");
     1230#endif
     1231              modelPtr_->setProblemStatus(1);
     1232            } else {
    12371233#ifdef COIN_DEVELOP
    1238               printf("Real real trouble - treat as optimal\n");
    1239 #endif
    1240               modelPtr_->setProblemStatus(0);
    1241             }
    1242           }
    1243         }
    1244       }
    1245       assert (modelPtr_->objectiveValue()<1.0e100);
     1234              printf("Real real trouble - treat as optimal\n");
     1235#endif
     1236              modelPtr_->setProblemStatus(0);
     1237            }
     1238          }
     1239        }
     1240      }
     1241      assert(modelPtr_->objectiveValue() < 1.0e100);
    12461242    } else {
    12471243#ifdef KEEP_SMALL
    12481244      if (smallModel_) {
    1249         delete [] spareArrays_;
    1250         spareArrays_ = NULL;
    1251         delete smallModel_;
    1252         smallModel_=NULL;
     1245        delete[] spareArrays_;
     1246        spareArrays_ = NULL;
     1247        delete smallModel_;
     1248        smallModel_ = NULL;
    12531249      }
    12541250#endif
     
    12561252#ifdef CBC_STATISTICS
    12571253      osi_primal++;
    1258 #endif 
    1259       modelPtr_->primal(1,startFinishOptions);
     1254#endif
     1255      modelPtr_->primal(1, startFinishOptions);
    12601256      totalIterations += modelPtr_->numberIterations();
    1261       lastAlgorithm_=1; // primal
     1257      lastAlgorithm_ = 1; // primal
    12621258      // check if clp thought it was in a loop
    1263       if (modelPtr_->status()==3&&!modelPtr_->hitMaximumIterations()) {
    1264         // switch algorithm
    1265         modelPtr_->dual();
    1266         totalIterations += modelPtr_->numberIterations();
    1267         lastAlgorithm_=2; // dual
     1259      if (modelPtr_->status() == 3 && !modelPtr_->hitMaximumIterations()) {
     1260        // switch algorithm
     1261        modelPtr_->dual();
     1262        totalIterations += modelPtr_->numberIterations();
     1263        lastAlgorithm_ = 2; // dual
    12681264      }
    12691265    }
     
    12751271  }
    12761272  basis_ = getBasis(modelPtr_);
    1277  disaster:
     1273disaster:
    12781274  //printf("basis after dual\n");
    12791275  //basis_.print();
    12801276  if (!defaultHandler_)
    1281     modelPtr_->popMessageHandler(saveHandler,oldDefault);
     1277    modelPtr_->popMessageHandler(saveHandler, oldDefault);
    12821278  modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
    1283   if (saveSolveType==2) {
     1279  if (saveSolveType == 2) {
    12841280    int saveStatus = modelPtr_->problemStatus_;
    12851281    enableSimplexInterface(doingPrimal);
    1286     modelPtr_->problemStatus_=saveStatus;
     1282    modelPtr_->problemStatus_ = saveStatus;
    12871283  }
    12881284#ifdef COIN_DEVELOP_x
     
    12901286  if (doingDoneBranch) {
    12911287    if (modelPtr_->numberIterations())
    1292       printf("***** done %d iterations after general\n",modelPtr_->numberIterations());
    1293     doingDoneBranch=false;
     1288      printf("***** done %d iterations after general\n", modelPtr_->numberIterations());
     1289    doingDoneBranch = false;
    12941290  }
    12951291#endif
     
    12971293  //modelPtr_->setSolveType(saveSolveType);
    12981294  if (abortSearch) {
    1299     lastAlgorithm_=-911;
     1295    lastAlgorithm_ = -911;
    13001296    modelPtr_->setProblemStatus(4);
    13011297  }
    13021298  if (savedObjective) {
    13031299    // fix up
    1304     modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
     1300    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
    13051301    //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    1306     modelPtr_->objective_=savedObjective;
     1302    modelPtr_->objective_ = savedObjective;
    13071303    if (!modelPtr_->problemStatus_) {
    1308       CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
    1309       CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
    1310       if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
    1311         CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
     1304      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
     1305      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
     1306      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
     1307        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
    13121308      modelPtr_->computeObjectiveValue();
    13131309    }
    13141310  }
    13151311  modelPtr_->setSpecialOptions(saveOptions); // restore
    1316   if (modelPtr_->problemStatus_==3&&lastAlgorithm_==2)
     1312  if (modelPtr_->problemStatus_ == 3 && lastAlgorithm_ == 2)
    13171313    modelPtr_->computeObjectiveValue();
    1318   if (lastAlgorithm_<1||lastAlgorithm_>2)
    1319     lastAlgorithm_=1;
     1314  if (lastAlgorithm_ < 1 || lastAlgorithm_ > 2)
     1315    lastAlgorithm_ = 1;
    13201316#ifdef SAVE_MODEL
    1321   if (resolveTry>=loResolveTry&&
    1322       resolveTry<=hiResolveTry) {
    1323     printf("resolve %d took %d iterations - algorithm %d\n",resolveTry,modelPtr_->numberIterations(),lastAlgorithm_);
     1317  if (resolveTry >= loResolveTry && resolveTry <= hiResolveTry) {
     1318    printf("resolve %d took %d iterations - algorithm %d\n", resolveTry, modelPtr_->numberIterations(), lastAlgorithm_);
    13241319  }
    13251320#endif
     
    13311326#include "ClpSimplexOther.hpp"
    13321327// Resolve an LP relaxation after problem modification (try GUB)
    1333 void
    1334 OsiClpSolverInterface::resolveGub(int needed)
     1328void OsiClpSolverInterface::resolveGub(int needed)
    13351329{
    13361330  bool takeHint;
    13371331  OsiHintStrength strength;
    13381332  // Switch off printing if asked to
    1339   getHintParam(OsiDoReducePrint,takeHint,strength);
    1340   int saveMessageLevel=modelPtr_->logLevel();
    1341   if (strength!=OsiHintIgnore&&takeHint) {
    1342     int messageLevel=messageHandler()->logLevel();
    1343     if (messageLevel>0)
    1344       modelPtr_->messageHandler()->setLogLevel(messageLevel-1);
     1333  getHintParam(OsiDoReducePrint, takeHint, strength);
     1334  int saveMessageLevel = modelPtr_->logLevel();
     1335  if (strength != OsiHintIgnore && takeHint) {
     1336    int messageLevel = messageHandler()->logLevel();
     1337    if (messageLevel > 0)
     1338      modelPtr_->messageHandler()->setLogLevel(messageLevel - 1);
    13451339    else
    13461340      modelPtr_->messageHandler()->setLogLevel(0);
    13471341  }
    13481342  //modelPtr_->messageHandler()->setLogLevel(1);
    1349   setBasis(basis_,modelPtr_);
     1343  setBasis(basis_, modelPtr_);
    13501344  // find gub
    13511345  int numberRows = modelPtr_->numberRows();
    1352   int * which = new int[numberRows];
     1346  int *which = new int[numberRows];
    13531347  int numberColumns = modelPtr_->numberColumns();
    1354   int * whichC = new int[numberColumns+numberRows];
    1355   ClpSimplex * model2 =
    1356     static_cast<ClpSimplexOther *> (modelPtr_)->gubVersion(which,whichC,
    1357                                                            needed,100);
     1348  int *whichC = new int[numberColumns + numberRows];
     1349  ClpSimplex *model2 = static_cast< ClpSimplexOther * >(modelPtr_)->gubVersion(which, whichC,
     1350    needed, 100);
    13581351  if (model2) {
    13591352    // move in solution
    1360     static_cast<ClpSimplexOther *> (model2)->setGubBasis(*modelPtr_,
    1361                                                          which,whichC);
    1362     model2->setLogLevel(CoinMin(1,model2->logLevel()));
     1353    static_cast< ClpSimplexOther * >(model2)->setGubBasis(*modelPtr_,
     1354      which, whichC);
     1355    model2->setLogLevel(CoinMin(1, model2->logLevel()));
    13631356    ClpPrimalColumnSteepest steepest(5);
    13641357    model2->setPrimalColumnPivotAlgorithm(steepest);
     
    13661359    model2->primal();
    13671360    //printf("Primal took %g seconds\n",CoinCpuTime()-time1);
    1368     static_cast<ClpSimplexOther *> (model2)->getGubBasis(*modelPtr_,
    1369                                                          which,whichC);
     1361    static_cast< ClpSimplexOther * >(model2)->getGubBasis(*modelPtr_,
     1362      which, whichC);
    13701363    int totalIterations = model2->numberIterations();
    13711364    delete model2;
    13721365    //modelPtr_->setLogLevel(63);
    13731366    modelPtr_->primal(1);
    1374     modelPtr_->setNumberIterations(totalIterations+modelPtr_->numberIterations());
     1367    modelPtr_->setNumberIterations(totalIterations + modelPtr_->numberIterations());
    13751368  } else {
    13761369    modelPtr_->dual();
    13771370  }
    1378   delete [] which;
    1379   delete [] whichC;
     1371  delete[] which;
     1372  delete[] whichC;
    13801373  basis_ = getBasis(modelPtr_);
    13811374  modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
    13821375}
    13831376// Sort of lexicographic resolve
    1384 void
    1385 OsiClpSolverInterface::lexSolve()
     1377void OsiClpSolverInterface::lexSolve()
    13861378{
    13871379#if 1
    13881380  abort();
    13891381#else
    1390   ((ClpSimplexPrimal *) modelPtr_)->lexSolve();
    1391   printf("itA %d\n",modelPtr_->numberIterations());
     1382  ((ClpSimplexPrimal *)modelPtr_)->lexSolve();
     1383  printf("itA %d\n", modelPtr_->numberIterations());
    13921384  modelPtr_->primal();
    1393   printf("itB %d\n",modelPtr_->numberIterations());
     1385  printf("itB %d\n", modelPtr_->numberIterations());
    13941386  basis_ = getBasis(modelPtr_);
    13951387#endif
     
    14111403               1 leaves
    14121404  */
    1413 void
    1414 OsiClpSolverInterface::setupForRepeatedUse(int senseOfAdventure, int printOut)
     1405void OsiClpSolverInterface::setupForRepeatedUse(int senseOfAdventure, int printOut)
    14151406{
    14161407  // First try
    14171408  switch (senseOfAdventure) {
    14181409  case 0:
    1419     specialOptions_=8;
     1410    specialOptions_ = 8;
    14201411    break;
    14211412  case 1:
    1422     specialOptions_=1+2+8;
     1413    specialOptions_ = 1 + 2 + 8;
    14231414    break;
    14241415  case 2:
    1425     specialOptions_=1+2+4+8;
     1416    specialOptions_ = 1 + 2 + 4 + 8;
    14261417    break;
    14271418  case 3:
    1428     specialOptions_=1+8;
     1419    specialOptions_ = 1 + 8;
    14291420    break;
    14301421  }
     
    14331424  specialOptions_ &= ~1;
    14341425#endif
    1435   bool stopPrinting=false;
    1436   if (printOut<0) {
    1437     stopPrinting=true;
     1426  bool stopPrinting = false;
     1427  if (printOut < 0) {
     1428    stopPrinting = true;
    14381429  } else if (!printOut) {
    14391430    bool takeHint;
    14401431    OsiHintStrength strength;
    1441     getHintParam(OsiDoReducePrint,takeHint,strength);
    1442     int messageLevel=messageHandler()->logLevel();
    1443     if (strength!=OsiHintIgnore&&takeHint)
     1432    getHintParam(OsiDoReducePrint, takeHint, strength);
     1433    int messageLevel = messageHandler()->logLevel();
     1434    if (strength != OsiHintIgnore && takeHint)
    14441435      messageLevel--;
    1445     stopPrinting = (messageLevel<=0);
     1436    stopPrinting = (messageLevel <= 0);
    14461437  }
    14471438#ifndef COIN_DEVELOP
    14481439  if (stopPrinting) {
    1449     CoinMessages * messagesPointer = modelPtr_->messagesPointer();
    1450     // won't even build messages 
    1451     messagesPointer->setDetailMessages(100,10000,reinterpret_cast<int *> (NULL));
     1440    CoinMessages *messagesPointer = modelPtr_->messagesPointer();
     1441    // won't even build messages
     1442    messagesPointer->setDetailMessages(100, 10000, reinterpret_cast< int * >(NULL));
    14521443  }
    14531444#endif
     
    14571448// only called in debug mode
    14581449static void indexError(int index,
    1459                         std::string methodName)
    1460 {
    1461   std::cerr<<"Illegal index "<<index<<" in OsiClpSolverInterface::"<<methodName<<std::endl;
    1462   throw CoinError("Illegal index",methodName,"OsiClpSolverInterface");
     1450  std::string methodName)
     1451{
     1452  std::cerr << "Illegal index " << index << " in OsiClpSolverInterface::" << methodName << std::endl;
     1453  throw CoinError("Illegal index", methodName, "OsiClpSolverInterface");
    14631454}
    14641455#endif
     
    14671458//#############################################################################
    14681459
    1469 bool
    1470 OsiClpSolverInterface::setIntParam(OsiIntParam key, int value)
    1471 {
    1472   return modelPtr_->setIntParam(static_cast<ClpIntParam> (key), value);
     1460bool OsiClpSolverInterface::setIntParam(OsiIntParam key, int value)
     1461{
     1462  return modelPtr_->setIntParam(static_cast< ClpIntParam >(key), value);
    14731463}
    14741464
    14751465//-----------------------------------------------------------------------------
    14761466
    1477 bool
    1478 OsiClpSolverInterface::setDblParam(OsiDblParam key, double value)
    1479 {
    1480   if (key != OsiLastDblParam ) {
    1481     if (key==OsiDualObjectiveLimit||key==OsiPrimalObjectiveLimit)
     1467bool OsiClpSolverInterface::setDblParam(OsiDblParam key, double value)
     1468{
     1469  if (key != OsiLastDblParam) {
     1470    if (key == OsiDualObjectiveLimit || key == OsiPrimalObjectiveLimit)
    14821471      value *= modelPtr_->optimizationDirection();
    1483     return modelPtr_->setDblParam(static_cast<ClpDblParam> (key), value);
     1472    return modelPtr_->setDblParam(static_cast< ClpDblParam >(key), value);
    14841473  } else {
    14851474    return false;
     
    14891478//-----------------------------------------------------------------------------
    14901479
    1491 bool
    1492 OsiClpSolverInterface::setStrParam(OsiStrParam key, const std::string & value)
    1493 {
    1494   assert (key!=OsiSolverName);
    1495   if (key != OsiLastStrParam ) {
    1496     return modelPtr_->setStrParam(static_cast<ClpStrParam> (key), value);
     1480bool OsiClpSolverInterface::setStrParam(OsiStrParam key, const std::string &value)
     1481{
     1482  assert(key != OsiSolverName);
     1483  if (key != OsiLastStrParam) {
     1484    return modelPtr_->setStrParam(static_cast< ClpStrParam >(key), value);
    14971485  } else {
    14981486    return false;
     
    15001488}
    15011489
    1502 
    15031490//-----------------------------------------------------------------------------
    15041491
    1505 bool
    1506 OsiClpSolverInterface::getIntParam(OsiIntParam key, int& value) const
    1507 {
    1508   return modelPtr_->getIntParam(static_cast<ClpIntParam> (key), value);
     1492bool OsiClpSolverInterface::getIntParam(OsiIntParam key, int &value) const
     1493{
     1494  return modelPtr_->getIntParam(static_cast< ClpIntParam >(key), value);
    15091495}
    15101496
    15111497//-----------------------------------------------------------------------------
    15121498
    1513 bool
    1514 OsiClpSolverInterface::getDblParam(OsiDblParam key, double& value) const
    1515 {
    1516   if (key != OsiLastDblParam ) {
    1517     bool condition =  modelPtr_->getDblParam(static_cast<ClpDblParam> (key), value);
    1518     if (key==OsiDualObjectiveLimit||key==OsiPrimalObjectiveLimit)
     1499bool OsiClpSolverInterface::getDblParam(OsiDblParam key, double &value) const
     1500{
     1501  if (key != OsiLastDblParam) {
     1502    bool condition = modelPtr_->getDblParam(static_cast< ClpDblParam >(key), value);
     1503    if (key == OsiDualObjectiveLimit || key == OsiPrimalObjectiveLimit)
    15191504      value *= modelPtr_->optimizationDirection();
    15201505    return condition;
     
    15261511//-----------------------------------------------------------------------------
    15271512
    1528 bool
    1529 OsiClpSolverInterface::getStrParam(OsiStrParam key, std::string & value) const
    1530 {
    1531   if ( key==OsiSolverName ) {
     1513bool OsiClpSolverInterface::getStrParam(OsiStrParam key, std::string &value) const
     1514{
     1515  if (key == OsiSolverName) {
    15321516    value = "clp";
    15331517    return true;
    15341518  }
    1535   if (key != OsiLastStrParam ) {
    1536     return modelPtr_->getStrParam(static_cast<ClpStrParam> (key), value);
     1519  if (key != OsiLastStrParam) {
     1520    return modelPtr_->getStrParam(static_cast< ClpStrParam >(key), value);
    15371521  } else {
    15381522    return false;
    15391523  }
    15401524}
    1541 
    15421525
    15431526//#############################################################################
     
    15481531{
    15491532  // not sure about -1 (should not happen)
    1550   return (modelPtr_->status()==4||modelPtr_->status()==-1||
    1551           (modelPtr_->status()==1&&modelPtr_->secondaryStatus()==8));
     1533  return (modelPtr_->status() == 4 || modelPtr_->status() == -1 || (modelPtr_->status() == 1 && modelPtr_->secondaryStatus() == 8));
    15521534}
    15531535
     
    15641546  const int stat = modelPtr_->status();
    15651547  if (stat != 1)
    1566      return false;
     1548    return false;
    15671549  return true;
    15681550}
     
    15851567    return false;
    15861568  }
    1587    
     1569
    15881570  const double obj = modelPtr_->objectiveValue();
    1589   int maxmin = static_cast<int> (modelPtr_->optimizationDirection());
     1571  int maxmin = static_cast< int >(modelPtr_->optimizationDirection());
    15901572
    15911573  switch (lastAlgorithm_) {
    1592    case 0: // no simplex was needed
    1593      return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
    1594    case 2: // dual simplex
    1595      if (modelPtr_->status() == 0) // optimal
    1596         return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
    1597      return false;
    1598    case 1: // primal simplex
    1599      return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
     1574  case 0: // no simplex was needed
     1575    return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
     1576  case 2: // dual simplex
     1577    if (modelPtr_->status() == 0) // optimal
     1578      return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
     1579    return false;
     1580  case 1: // primal simplex
     1581    return maxmin > 0 ? (obj < limit) /*minim*/ : (-obj < limit) /*maxim*/;
    16001582  }
    16011583  return false; // fake return
     
    16081590  if (stat == 1)
    16091591    return true;
    1610   else if (stat<0)
     1592  else if (stat < 0)
    16111593    return false;
    16121594  double limit = 0.0;
     
    16161598    return false;
    16171599  }
    1618    
     1600
    16191601  const double obj = modelPtr_->objectiveValue();
    1620   int maxmin = static_cast<int> (modelPtr_->optimizationDirection());
     1602  int maxmin = static_cast< int >(modelPtr_->optimizationDirection());
    16211603
    16221604  switch (lastAlgorithm_) {
    1623    case 0: // no simplex was needed
    1624      return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
    1625    case 1: // primal simplex
    1626      if (stat == 0) // optimal
    1627         return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
    1628      return false;
    1629    case 2: // dual simplex
    1630      if (stat != 0 && stat != 3)
    1631         // over dual limit
    1632         return true;
    1633      return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
     1605  case 0: // no simplex was needed
     1606    return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
     1607  case 1: // primal simplex
     1608    if (stat == 0) // optimal
     1609      return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
     1610    return false;
     1611  case 2: // dual simplex
     1612    if (stat != 0 && stat != 3)
     1613      // over dual limit
     1614      return true;
     1615    return maxmin > 0 ? (obj > limit) /*minim*/ : (-obj > limit) /*maxim*/;
    16341616  }
    16351617  return false; // fake return
     
    16461628// WarmStart related methods
    16471629//#############################################################################
    1648 CoinWarmStart *OsiClpSolverInterface::getEmptyWarmStart () const
    1649   { return (static_cast<CoinWarmStart *>(new CoinWarmStartBasis())) ; }
    1650 
    1651 CoinWarmStart* OsiClpSolverInterface::getWarmStart() const
     1630CoinWarmStart *OsiClpSolverInterface::getEmptyWarmStart() const
     1631{
     1632  return (static_cast< CoinWarmStart * >(new CoinWarmStartBasis()));
     1633}
     1634
     1635CoinWarmStart *OsiClpSolverInterface::getWarmStart() const
    16521636{
    16531637
     
    16621646   OsiClp version always returns pointer and false.
    16631647*/
    1664 CoinWarmStart*
    1665 OsiClpSolverInterface::getPointerToWarmStart(bool & mustDelete)
     1648CoinWarmStart *
     1649OsiClpSolverInterface::getPointerToWarmStart(bool &mustDelete)
    16661650{
    16671651  mustDelete = false;
     
    16711655//-----------------------------------------------------------------------------
    16721656
    1673 bool OsiClpSolverInterface::setWarmStart(const CoinWarmStart* warmstart)
     1657bool OsiClpSolverInterface::setWarmStart(const CoinWarmStart *warmstart)
    16741658{
    16751659  modelPtr_->whatsChanged_ &= 0xffff;
    1676   const CoinWarmStartBasis* ws =
    1677     dynamic_cast<const CoinWarmStartBasis*>(warmstart);
     1660  const CoinWarmStartBasis *ws = dynamic_cast< const CoinWarmStartBasis * >(warmstart);
    16781661  if (ws) {
    16791662    basis_ = CoinWarmStartBasis(*ws);
     
    16951678#ifdef CBC_STATISTICS
    16961679  osi_hot++;
    1697 #endif 
     1680#endif
    16981681  //printf("HotStart options %x changed %x, small %x spare %x\n",
    16991682  // specialOptions_,modelPtr_->whatsChanged_,
    17001683  // smallModel_,spareArrays_);
    17011684  modelPtr_->setProblemStatus(0);
    1702   saveData_.perturbation_=0;
     1685  saveData_.perturbation_ = 0;
    17031686  saveData_.specialOptions_ = modelPtr_->specialOptions_;
    17041687  modelPtr_->specialOptions_ |= 0x1000000;
    1705   modelPtr_->specialOptions_ = saveData_.specialOptions_; 
    1706   ClpObjective * savedObjective=NULL;
    1707   double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
     1688  modelPtr_->specialOptions_ = saveData_.specialOptions_;
     1689  ClpObjective *savedObjective = NULL;
     1690  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
    17081691  if (fakeObjective_) {
    1709     modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~128));
     1692    modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() & (~128));
    17101693    // See if all with costs fixed
    17111694    int numberColumns = modelPtr_->numberColumns_;
    1712     const double * obj = modelPtr_->objective();
    1713     const double * lower = modelPtr_->columnLower();
    1714     const double * upper = modelPtr_->columnUpper();
     1695    const double *obj = modelPtr_->objective();
     1696    const double *lower = modelPtr_->columnLower();
     1697    const double *upper = modelPtr_->columnUpper();
    17151698    int i;
    1716     for (i=0;i<numberColumns;i++) {
     1699    for (i = 0; i < numberColumns; i++) {
    17171700      double objValue = obj[i];
    17181701      if (objValue) {
    1719         if (lower[i]!=upper[i])
    1720           break;
    1721       }
    1722     }
    1723     if (i==numberColumns) {
    1724       if ((specialOptions_&524288)==0) {
    1725         // Set fake
    1726         savedObjective=modelPtr_->objective_;
    1727         modelPtr_->objective_=fakeObjective_;
    1728         modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
    1729         saveData_.perturbation_=1;
     1702        if (lower[i] != upper[i])
     1703          break;
     1704      }
     1705    }
     1706    if (i == numberColumns) {
     1707      if ((specialOptions_ & 524288) == 0) {
     1708        // Set fake
     1709        savedObjective = modelPtr_->objective_;
     1710        modelPtr_->objective_ = fakeObjective_;
     1711        modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
     1712        saveData_.perturbation_ = 1;
    17301713      } else {
    1731         modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()|128);
     1714        modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions() | 128);
    17321715      }
    17331716    }
     
    17351718#define CLEAN_HOT_START
    17361719#ifdef CLEAN_HOT_START
    1737   if ((specialOptions_&65536)!=0) {
     1720  if ((specialOptions_ & 65536) != 0) {
    17381721    //specialOptions_ |= 65536;
    1739     saveData_.scalingFlag_=modelPtr_->logLevel();
    1740     if (modelPtr_->logLevel()<2)
     1722    saveData_.scalingFlag_ = modelPtr_->logLevel();
     1723    if (modelPtr_->logLevel() < 2)
    17411724      modelPtr_->setLogLevel(0);
    1742     assert ((specialOptions_&128)==0);
     1725    assert((specialOptions_ & 128) == 0);
    17431726    // space for save arrays
    17441727    int numberColumns = modelPtr_->numberColumns();
    17451728    int numberRows = modelPtr_->numberRows();
    1746     // Get space for strong branching 
    1747     int size = static_cast<int>((1+4*(numberRows+numberColumns))*sizeof(double));
     1729    // Get space for strong branching
     1730    int size = static_cast< int >((1 + 4 * (numberRows + numberColumns)) * sizeof(double));
    17481731    // and for save of original column bounds
    1749     size += static_cast<int>(2*numberColumns*sizeof(double));
    1750     size += static_cast<int>((1+4*numberRows+2*numberColumns)*sizeof(int));
    1751     size += numberRows+numberColumns;
    1752     assert (spareArrays_==NULL);
     1732    size += static_cast< int >(2 * numberColumns * sizeof(double));
     1733    size += static_cast< int >((1 + 4 * numberRows + 2 * numberColumns) * sizeof(int));
     1734    size += numberRows + numberColumns;
     1735    assert(spareArrays_ == NULL);
    17531736    spareArrays_ = new char[size];
    17541737    //memset(spareArrays_,0x20,size);
    17551738    // Setup for strong branching
    1756     assert (factorization_==NULL);
    1757     if ((specialOptions_&131072)!=0) {
    1758       assert (lastNumberRows_>=0);
    1759       if (modelPtr_->rowScale_!=rowScale_.array()) {
    1760         assert(modelPtr_->columnScale_!=columnScale_.array());
    1761         delete [] modelPtr_->rowScale_;
    1762         modelPtr_->rowScale_=NULL;
    1763         delete [] modelPtr_->columnScale_;
    1764         modelPtr_->columnScale_=NULL;
    1765         if (lastNumberRows_==modelPtr_->numberRows()) {
    1766           // use scaling
    1767           modelPtr_->rowScale_ = rowScale_.array();
    1768           modelPtr_->columnScale_ = columnScale_.array();
    1769         } else {
    1770           specialOptions_ &= ~131072;
    1771         }
    1772       }
    1773       lastNumberRows_ = -1 -lastNumberRows_;
    1774     }
    1775     factorization_ = static_cast<ClpSimplexDual *>(modelPtr_)->setupForStrongBranching(spareArrays_,numberRows,
    1776                                                                                        numberColumns,true);
    1777     double * arrayD = reinterpret_cast<double *> (spareArrays_);
    1778     arrayD[0]=modelPtr_->objectiveValue()* modelPtr_->optimizationDirection();
    1779     double * saveSolution = arrayD+1;
    1780     double * saveLower = saveSolution + (numberRows+numberColumns);
    1781     double * saveUpper = saveLower + (numberRows+numberColumns);
    1782     double * saveObjective = saveUpper + (numberRows+numberColumns);
    1783     double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
    1784     double * saveUpperOriginal = saveLowerOriginal + numberColumns;
    1785     CoinMemcpyN( modelPtr_->columnLower(),numberColumns, saveLowerOriginal);
    1786     CoinMemcpyN( modelPtr_->columnUpper(),numberColumns, saveUpperOriginal);
     1739    assert(factorization_ == NULL);
     1740    if ((specialOptions_ & 131072) != 0) {
     1741      assert(lastNumberRows_ >= 0);
     1742      if (modelPtr_->rowScale_ != rowScale_.array()) {
     1743        assert(modelPtr_->columnScale_ != columnScale_.array());
     1744        delete[] modelPtr_->rowScale_;
     1745        modelPtr_->rowScale_ = NULL;
     1746        delete[] modelPtr_->columnScale_;
     1747        modelPtr_->columnScale_ = NULL;
     1748        if (lastNumberRows_ == modelPtr_->numberRows()) {
     1749          // use scaling
     1750          modelPtr_->rowScale_ = rowScale_.array();
     1751          modelPtr_->columnScale_ = columnScale_.array();
     1752        } else {
     1753          specialOptions_ &= ~131072;
     1754        }
     1755      }
     1756      lastNumberRows_ = -1 - lastNumberRows_;
     1757    }
     1758    factorization_ = static_cast< ClpSimplexDual * >(modelPtr_)->setupForStrongBranching(spareArrays_, numberRows,
     1759      numberColumns, true);
     1760    double *arrayD = reinterpret_cast< double * >(spareArrays_);
     1761    arrayD[0] = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
     1762    double *saveSolution = arrayD + 1;
     1763    double *saveLower = saveSolution + (numberRows + numberColumns);
     1764    double *saveUpper = saveLower + (numberRows + numberColumns);
     1765    double *saveObjective = saveUpper + (numberRows + numberColumns);
     1766    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
     1767    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
     1768    CoinMemcpyN(modelPtr_->columnLower(), numberColumns, saveLowerOriginal);
     1769    CoinMemcpyN(modelPtr_->columnUpper(), numberColumns, saveUpperOriginal);
    17871770#if 0
    17881771    if (whichRange_&&whichRange_[0]) {
     
    18111794      columnActivity_=downRange;
    18121795    }
    1813 #endif 
     1796#endif
    18141797    if (savedObjective) {
    18151798      // fix up
    1816       modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
     1799      modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
    18171800      //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    1818       modelPtr_->objective_=savedObjective;
     1801      modelPtr_->objective_ = savedObjective;
    18191802      if (!modelPtr_->problemStatus_) {
    1820         CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
    1821         CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
    1822         if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
    1823           CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
    1824         modelPtr_->computeObjectiveValue();
     1803        CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
     1804        CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
     1805        if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
     1806          CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
     1807        modelPtr_->computeObjectiveValue();
    18251808      }
    18261809    }
     
    18281811  }
    18291812#endif
    1830   if ((specialOptions_&8192)==0&&false) { // ||(specialOptions_&65536)!=0) {
     1813  if ((specialOptions_ & 8192) == 0 && false) { // ||(specialOptions_&65536)!=0) {
    18311814    delete ws_;
    1832     ws_ = dynamic_cast<CoinWarmStartBasis*>(getWarmStart());
     1815    ws_ = dynamic_cast< CoinWarmStartBasis * >(getWarmStart());
    18331816    int numberRows = modelPtr_->numberRows();
    1834     rowActivity_= new double[numberRows];
    1835     CoinMemcpyN(modelPtr_->primalRowSolution(),numberRows,rowActivity_);
     1817    rowActivity_ = new double[numberRows];
     1818    CoinMemcpyN(modelPtr_->primalRowSolution(), numberRows, rowActivity_);
    18361819    int numberColumns = modelPtr_->numberColumns();
    1837     columnActivity_= new double[numberColumns];
    1838     CoinMemcpyN(modelPtr_->primalColumnSolution(),numberColumns,columnActivity_);
     1820    columnActivity_ = new double[numberColumns];
     1821    CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns, columnActivity_);
    18391822  } else {
    18401823#if 0
     
    18531836    int numberRows = modelPtr_->numberRows();
    18541837    // Get space for crunch and strong branching (too much)
    1855     int size = static_cast<int>((1+4*(numberRows+numberColumns))*sizeof(double));
     1838    int size = static_cast< int >((1 + 4 * (numberRows + numberColumns)) * sizeof(double));
    18561839    // and for save of original column bounds
    1857     size += static_cast<int>(2*numberColumns*sizeof(double));
    1858     size += static_cast<int>((1+4*numberRows+2*numberColumns)*sizeof(int));
    1859     size += numberRows+numberColumns;
     1840    size += static_cast< int >(2 * numberColumns * sizeof(double));
     1841    size += static_cast< int >((1 + 4 * numberRows + 2 * numberColumns) * sizeof(int));
     1842    size += numberRows + numberColumns;
    18601843#ifdef KEEP_SMALL
    1861     if(smallModel_&&(modelPtr_->whatsChanged_&0x30000)!=0x30000) {
     1844    if (smallModel_ && (modelPtr_->whatsChanged_ & 0x30000) != 0x30000) {
    18621845      //printf("Bounds changed ? %x\n",modelPtr_->whatsChanged_);
    18631846      delete smallModel_;
    1864       smallModel_=NULL;
     1847      smallModel_ = NULL;
    18651848    }
    18661849    if (!smallModel_) {
    1867       delete [] spareArrays_;
     1850      delete[] spareArrays_;
    18681851      spareArrays_ = NULL;
    18691852    }
    18701853#endif
    1871     if (spareArrays_==NULL) {
     1854    if (spareArrays_ == NULL) {
    18721855      //if (smallModel_)
    18731856      //printf("small model %x\n",smallModel_);
    18741857      delete smallModel_;
    1875       smallModel_=NULL;
     1858      smallModel_ = NULL;
    18761859      spareArrays_ = new char[size];
    18771860      //memset(spareArrays_,0x20,size);
    18781861    } else {
    1879       double * arrayD = reinterpret_cast<double *> (spareArrays_);
    1880       double * saveSolution = arrayD+1;
    1881       double * saveLower = saveSolution + (numberRows+numberColumns);
    1882       double * saveUpper = saveLower + (numberRows+numberColumns);
    1883       double * saveObjective = saveUpper + (numberRows+numberColumns);
    1884       double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
    1885       double * saveUpperOriginal = saveLowerOriginal + numberColumns;
    1886       double * lowerOriginal = modelPtr_->columnLower();
    1887       double * upperOriginal = modelPtr_->columnUpper();
     1862      double *arrayD = reinterpret_cast< double * >(spareArrays_);
     1863      double *saveSolution = arrayD + 1;
     1864      double *saveLower = saveSolution + (numberRows + numberColumns);
     1865      double *saveUpper = saveLower + (numberRows + numberColumns);
     1866      double *saveObjective = saveUpper + (numberRows + numberColumns);
     1867      double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
     1868      double *saveUpperOriginal = saveLowerOriginal + numberColumns;
     1869      double *lowerOriginal = modelPtr_->columnLower();
     1870      double *upperOriginal = modelPtr_->columnUpper();
    18881871      arrayD = saveUpperOriginal + numberColumns;
    1889       int * savePivot = reinterpret_cast<int *> (arrayD);
    1890       int * whichRow = savePivot+numberRows;
    1891       int * whichColumn = whichRow + 3*numberRows;
    1892       int nSame=0;
    1893       int nSub=0;
    1894       for (int i=0;i<numberColumns;i++) {
    1895         double lo = lowerOriginal[i];
    1896         //char * xx = (char *) (saveLowerOriginal+i);
    1897         //assert (xx[0]!=0x20||xx[1]!=0x20);
    1898         //xx = (char *) (saveUpperOriginal+i);
    1899         //assert (xx[0]!=0x20||xx[1]!=0x20);
    1900         double loOld = saveLowerOriginal[i];
    1901         //assert (!loOld||fabs(loOld)>1.0e-30);
    1902         double up = upperOriginal[i];
    1903         double upOld = saveUpperOriginal[i];
    1904         if (lo>=loOld&&up<=upOld) {
    1905           if (lo==loOld&&up==upOld) {
    1906             nSame++;
    1907           } else {
    1908             nSub++;
    1909             //if (!isInteger(i))
    1910             //nSub+=10;
    1911           }
    1912         }
     1872      int *savePivot = reinterpret_cast< int * >(arrayD);
     1873      int *whichRow = savePivot + numberRows;
     1874      int *whichColumn = whichRow + 3 * numberRows;
     1875      int nSame = 0;
     1876      int nSub = 0;
     1877      for (int i = 0; i < numberColumns; i++) {
     1878        double lo = lowerOriginal[i];
     1879        //char * xx = (char *) (saveLowerOriginal+i);
     1880        //assert (xx[0]!=0x20||xx[1]!=0x20);
     1881        //xx = (char *) (saveUpperOriginal+i);
     1882        //assert (xx[0]!=0x20||xx[1]!=0x20);
     1883        double loOld = saveLowerOriginal[i];
     1884        //assert (!loOld||fabs(loOld)>1.0e-30);
     1885        double up = upperOriginal[i];
     1886        double upOld = saveUpperOriginal[i];
     1887        if (lo >= loOld && up <= upOld) {
     1888          if (lo == loOld && up == upOld) {
     1889            nSame++;
     1890          } else {
     1891            nSub++;
     1892            //if (!isInteger(i))
     1893            //nSub+=10;
     1894          }
     1895        }
    19131896      }
    19141897      //printf("Mark Hot %d bounds same, %d interior, %d bad\n",
    19151898      //     nSame,nSub,numberColumns-nSame-nSub);
    1916       if (nSame<numberColumns) {
    1917         if (nSame+nSub<numberColumns) {
    1918           delete smallModel_;
    1919           smallModel_=NULL;
    1920         } else {
    1921           // we can fix up (but should we if large number fixed?)
    1922           assert (smallModel_);
    1923           double * lowerSmall = smallModel_->columnLower();
    1924           double * upperSmall = smallModel_->columnUpper();
    1925           int numberColumns2 = smallModel_->numberColumns();
    1926           for (int i=0;i<numberColumns2;i++) {
    1927             int iColumn = whichColumn[i];
    1928             lowerSmall[i]=lowerOriginal[iColumn];
    1929             upperSmall[i]=upperOriginal[iColumn];
    1930           }
    1931         }
    1932       }
    1933     }
    1934     double * arrayD = reinterpret_cast<double *> (spareArrays_);
    1935     arrayD[0]=modelPtr_->objectiveValue()* modelPtr_->optimizationDirection();
    1936     double * saveSolution = arrayD+1;
    1937     double * saveLower = saveSolution + (numberRows+numberColumns);
    1938     double * saveUpper = saveLower + (numberRows+numberColumns);
    1939     double * saveObjective = saveUpper + (numberRows+numberColumns);
    1940     double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
    1941     double * saveUpperOriginal = saveLowerOriginal + numberColumns;
     1899      if (nSame < numberColumns) {
     1900        if (nSame + nSub < numberColumns) {
     1901          delete smallModel_;
     1902          smallModel_ = NULL;
     1903        } else {
     1904          // we can fix up (but should we if large number fixed?)
     1905          assert(smallModel_);
     1906          double *lowerSmall = smallModel_->columnLower();
     1907          double *upperSmall = smallModel_->columnUpper();
     1908          int numberColumns2 = smallModel_->numberColumns();
     1909          for (int i = 0; i < numberColumns2; i++) {
     1910            int iColumn = whichColumn[i];
     1911            lowerSmall[i] = lowerOriginal[iColumn];
     1912            upperSmall[i] = upperOriginal[iColumn];
     1913          }
     1914        }
     1915      }
     1916    }
     1917    double *arrayD = reinterpret_cast< double * >(spareArrays_);
     1918    arrayD[0] = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
     1919    double *saveSolution = arrayD + 1;
     1920    double *saveLower = saveSolution + (numberRows + numberColumns);
     1921    double *saveUpper = saveLower + (numberRows + numberColumns);
     1922    double *saveObjective = saveUpper + (numberRows + numberColumns);
     1923    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
     1924    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
    19421925    arrayD = saveUpperOriginal + numberColumns;
    1943     int * savePivot = reinterpret_cast<int *> (arrayD);
    1944     int * whichRow = savePivot+numberRows;
    1945     int * whichColumn = whichRow + 3*numberRows;
    1946     int * arrayI = whichColumn + 2*numberColumns;
     1926    int *savePivot = reinterpret_cast< int * >(arrayD);
     1927    int *whichRow = savePivot + numberRows;
     1928    int *whichColumn = whichRow + 3 * numberRows;
     1929    int *arrayI = whichColumn + 2 * numberColumns;
    19471930    //unsigned char * saveStatus = (unsigned char *) (arrayI+1);
    19481931    // Use dual region
    1949     double * rhs = modelPtr_->dualRowSolution();
    1950     int nBound=0;
    1951     ClpSimplex * small;
     1932    double *rhs = modelPtr_->dualRowSolution();
     1933    int nBound = 0;
     1934    ClpSimplex *small;
    19521935#ifndef KEEP_SMALL
    1953     assert (!smallModel_);
    1954     small = static_cast<ClpSimplexOther *> (modelPtr_)->crunch(rhs,whichRow,whichColumn,nBound,true);
    1955     bool needSolveInSetupHotStart=true;
     1936    assert(!smallModel_);
     1937    small = static_cast< ClpSimplexOther * >(modelPtr_)->crunch(rhs, whichRow, whichColumn, nBound, true);
     1938    bool needSolveInSetupHotStart = true;
    19561939#else
    1957     bool needSolveInSetupHotStart=true;
     1940    bool needSolveInSetupHotStart = true;
    19581941    if (!smallModel_) {
    19591942#ifndef NDEBUG
    1960       CoinFillN(whichRow,3*numberRows+2*numberColumns,-1);
    1961 #endif
    1962       small = static_cast<ClpSimplexOther *> (modelPtr_)->crunch(rhs,whichRow,whichColumn,nBound,true);
     1943      CoinFillN(whichRow, 3 * numberRows + 2 * numberColumns, -1);
     1944#endif
     1945      small = static_cast< ClpSimplexOther * >(modelPtr_)->crunch(rhs, whichRow, whichColumn, nBound, true);
    19631946#ifndef NDEBUG
    1964       int nCopy = 3*numberRows+2*numberColumns;
    1965       for (int i=0;i<nCopy;i++)
    1966         assert (whichRow[i]>=-CoinMax(numberRows,numberColumns)&&whichRow[i]<CoinMax(numberRows,numberColumns));
    1967 #endif
    1968       smallModel_=small;
     1947      int nCopy = 3 * numberRows + 2 * numberColumns;
     1948      for (int i = 0; i < nCopy; i++)
     1949        assert(whichRow[i] >= -CoinMax(numberRows, numberColumns) && whichRow[i] < CoinMax(numberRows, numberColumns));
     1950#endif
     1951      smallModel_ = small;
    19691952      //int hotIts = small->intParam_[ClpMaxNumIterationHotStart];
    19701953      //if (5*small->factorization_->maximumPivots()>
     
    19721955      //small->factorization_->maximumPivots(hotIts+1);
    19731956    } else {
    1974       assert((modelPtr_->whatsChanged_&0x30000)==0x30000);
     1957      assert((modelPtr_->whatsChanged_ & 0x30000) == 0x30000);
    19751958      //delete [] spareArrays_;
    19761959      //spareArrays_ = NULL;
    1977       assert (spareArrays_);
    1978       int nCopy = 3*numberRows+2*numberColumns;
     1960      assert(spareArrays_);
     1961      int nCopy = 3 * numberRows + 2 * numberColumns;
    19791962      nBound = whichRow[nCopy];
    19801963#ifndef NDEBUG
    1981       for (int i=0;i<nCopy;i++)
    1982         assert (whichRow[i]>=-CoinMax(numberRows,numberColumns)&&whichRow[i]<CoinMax(numberRows,numberColumns));
    1983 #endif
    1984       needSolveInSetupHotStart=false;
     1964      for (int i = 0; i < nCopy; i++)
     1965        assert(whichRow[i] >= -CoinMax(numberRows, numberColumns) && whichRow[i] < CoinMax(numberRows, numberColumns));
     1966#endif
     1967      needSolveInSetupHotStart = false;
    19851968      small = smallModel_;
    19861969    }
     
    19901973      small->specialOptions_ &= ~65536;
    19911974    }
    1992     if (small&&(specialOptions_&131072)!=0) {
    1993       assert (lastNumberRows_>=0);
     1975    if (small && (specialOptions_ & 131072) != 0) {
     1976      assert(lastNumberRows_ >= 0);
    19941977      int numberRows2 = small->numberRows();
    19951978      int numberColumns2 = small->numberColumns();
    1996       double * rowScale2 = new double [2*numberRows2];
    1997       const double * rowScale = rowScale_.array();
    1998       double * inverseScale2 = rowScale2+numberRows2;
    1999       const double * inverseScale = rowScale+modelPtr_->numberRows_;
     1979      double *rowScale2 = new double[2 * numberRows2];
     1980      const double *rowScale = rowScale_.array();
     1981      double *inverseScale2 = rowScale2 + numberRows2;
     1982      const double *inverseScale = rowScale + modelPtr_->numberRows_;
    20001983      int i;
    2001       for (i=0;i<numberRows2;i++) {
    2002         int iRow = whichRow[i];
    2003         rowScale2[i]=rowScale[iRow];
    2004         inverseScale2[i]=inverseScale[iRow];
     1984      for (i = 0; i < numberRows2; i++) {
     1985        int iRow = whichRow[i];
     1986        rowScale2[i] = rowScale[iRow];
     1987        inverseScale2[i] = inverseScale[iRow];
    20051988      }
    20061989      small->setRowScale(rowScale2);
    2007       double * columnScale2 = new double [2*numberColumns2];
    2008       const double * columnScale = columnScale_.array();
    2009       inverseScale2 = columnScale2+numberColumns2;
    2010       inverseScale = columnScale+modelPtr_->numberColumns_;
    2011       for (i=0;i<numberColumns2;i++) {
    2012         int iColumn = whichColumn[i];
    2013         columnScale2[i]=columnScale[iColumn];
    2014         inverseScale2[i]=inverseScale[iColumn];
     1990      double *columnScale2 = new double[2 * numberColumns2];
     1991      const double *columnScale = columnScale_.array();
     1992      inverseScale2 = columnScale2 + numberColumns2;
     1993      inverseScale = columnScale + modelPtr_->numberColumns_;
     1994      for (i = 0; i < numberColumns2; i++) {
     1995        int iColumn = whichColumn[i];
     1996        columnScale2[i] = columnScale[iColumn];
     1997        inverseScale2[i] = inverseScale[iColumn];
    20151998      }
    20161999      small->setColumnScale(columnScale2);
     
    20182001    if (!small) {
    20192002      // should never be infeasible .... but
    2020       delete [] spareArrays_;
    2021       spareArrays_=NULL;
     2003      delete[] spareArrays_;
     2004      spareArrays_ = NULL;
    20222005      delete ws_;
    2023       ws_ = dynamic_cast<CoinWarmStartBasis*>(getWarmStart());
     2006      ws_ = dynamic_cast< CoinWarmStartBasis * >(getWarmStart());
    20242007      int numberRows = modelPtr_->numberRows();
    2025       rowActivity_= new double[numberRows];
    2026       CoinMemcpyN(modelPtr_->primalRowSolution(),numberRows,rowActivity_);
     2008      rowActivity_ = new double[numberRows];
     2009      CoinMemcpyN(modelPtr_->primalRowSolution(), numberRows, rowActivity_);
    20272010      int numberColumns = modelPtr_->numberColumns();
    2028       columnActivity_= new double[numberColumns];
    2029       CoinMemcpyN(modelPtr_->primalColumnSolution(),numberColumns,columnActivity_);
     2011      columnActivity_ = new double[numberColumns];
     2012      CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns, columnActivity_);
    20302013      modelPtr_->setProblemStatus(1);
    20312014      if (savedObjective) {
    2032         // fix up
    2033         modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
    2034         //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    2035         modelPtr_->objective_=savedObjective;
     2015        // fix up
     2016        modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
     2017        //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
     2018        modelPtr_->objective_ = savedObjective;
    20362019      }
    20372020      return;
     
    20392022    int clpOptions = modelPtr_->specialOptions();
    20402023    clpOptions &= ~65536;
    2041     if((specialOptions_&1)==0) {
    2042       small->setSpecialOptions(clpOptions|(64|1024));
     2024    if ((specialOptions_ & 1) == 0) {
     2025      small->setSpecialOptions(clpOptions | (64 | 1024));
    20432026    } else {
    2044       if((specialOptions_&4)==0)
    2045         small->setSpecialOptions(clpOptions|(64|128|512|1024|4096));
     2027      if ((specialOptions_ & 4) == 0)
     2028        small->setSpecialOptions(clpOptions | (64 | 128 | 512 | 1024 | 4096));
    20462029      else
    2047         small->setSpecialOptions(clpOptions|(64|128|512|1024|2048|4096));
    2048     }
    2049     arrayI[0]=nBound;
    2050     assert (smallModel_==NULL||small==smallModel_);
    2051     if ((specialOptions_&256)!=0||1) {
     2030        small->setSpecialOptions(clpOptions | (64 | 128 | 512 | 1024 | 2048 | 4096));
     2031    }
     2032    arrayI[0] = nBound;
     2033    assert(smallModel_ == NULL || small == smallModel_);
     2034    if ((specialOptions_ & 256) != 0 || 1) {
    20522035      // only need to do this on second pass in CbcNode
    2053       if (modelPtr_->logLevel()<2) small->setLogLevel(0);
     2036      if (modelPtr_->logLevel() < 2)
     2037        small->setLogLevel(0);
    20542038      small->specialOptions_ |= 262144;
    20552039      small->moreSpecialOptions_ = modelPtr_->moreSpecialOptions_;
     
    20582042      small->dual();
    20592043#else
    2060       assert (factorization_==NULL);
     2044      assert(factorization_ == NULL);
    20612045      //needSolveInSetupHotStart=true;
    2062       ClpFactorization * factorization = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,
    2063                        numberRows,numberColumns,
    2064                                                                                                        needSolveInSetupHotStart);
    2065 #endif
    2066       if (small->numberIterations()>0&&small->logLevel()>2)
    2067         printf("**** iterated small %d\n",small->numberIterations());
     2046      ClpFactorization *factorization = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_,
     2047        numberRows, numberColumns,
     2048        needSolveInSetupHotStart);
     2049#endif
     2050      if (small->numberIterations() > 0 && small->logLevel() > 2)
     2051        printf("**** iterated small %d\n", small->numberIterations());
    20682052      //small->setLogLevel(0);
    20692053      // Could be infeasible if forced one way (and other way stopped on iterations)
     
    20712055      if (small->status()) {
    20722056#ifndef KEEP_SMALL
    2073         if (small!=modelPtr_)
    2074           delete small;
    2075         //delete smallModel_;
    2076         //smallModel_=NULL;
    2077         assert (!smallModel_);
     2057        if (small != modelPtr_)
     2058          delete small;
     2059        //delete smallModel_;
     2060        //smallModel_=NULL;
     2061        assert(!smallModel_);
    20782062#else
    2079         assert (small==smallModel_);
    2080         if (smallModel_!=modelPtr_) {
    2081           delete smallModel_;
    2082         }
    2083         smallModel_=NULL;
    2084 #endif
    2085         delete [] spareArrays_;
    2086         spareArrays_=NULL;
    2087         delete ws_;
    2088         ws_ = dynamic_cast<CoinWarmStartBasis*>(getWarmStart());
    2089         int numberRows = modelPtr_->numberRows();
    2090         rowActivity_= new double[numberRows];
    2091  CoinMemcpyN(modelPtr_->primalRowSolution(),    numberRows,rowActivity_);
    2092         int numberColumns = modelPtr_->numberColumns();
    2093         columnActivity_= new double[numberColumns];
    2094  CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns,columnActivity_);
    2095         modelPtr_->setProblemStatus(1);
    2096         if (savedObjective) {
    2097           // fix up
    2098           modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
    2099           //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    2100           modelPtr_->objective_=savedObjective;
    2101         }
    2102         return;
     2063        assert(small == smallModel_);
     2064        if (smallModel_ != modelPtr_) {
     2065          delete smallModel_;
     2066        }
     2067        smallModel_ = NULL;
     2068#endif
     2069        delete[] spareArrays_;
     2070        spareArrays_ = NULL;
     2071        delete ws_;
     2072        ws_ = dynamic_cast< CoinWarmStartBasis * >(getWarmStart());
     2073        int numberRows = modelPtr_->numberRows();
     2074        rowActivity_ = new double[numberRows];
     2075        CoinMemcpyN(modelPtr_->primalRowSolution(), numberRows, rowActivity_);
     2076        int numberColumns = modelPtr_->numberColumns();
     2077        columnActivity_ = new double[numberColumns];
     2078        CoinMemcpyN(modelPtr_->primalColumnSolution(), numberColumns, columnActivity_);
     2079        modelPtr_->setProblemStatus(1);
     2080        if (savedObjective) {
     2081          // fix up
     2082          modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
     2083          //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
     2084          modelPtr_->objective_ = savedObjective;
     2085        }
     2086        return;
    21032087      } else {
    2104         // update model
    2105         static_cast<ClpSimplexOther *> (modelPtr_)->afterCrunch(*small,whichRow,whichColumn,nBound);
    2106       } 
     2088        // update model
     2089        static_cast< ClpSimplexOther * >(modelPtr_)->afterCrunch(*small, whichRow, whichColumn, nBound);
     2090      }
    21072091#ifndef SETUP_HOT
    2108       assert (factorization_==NULL);
    2109       factorization_ = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,numberRows,
    2110                              numberColumns,false);
     2092      assert(factorization_ == NULL);
     2093      factorization_ = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_, numberRows,
     2094        numberColumns, false);
    21112095#else
    2112       assert (factorization!=NULL || small->problemStatus_ );
     2096      assert(factorization != NULL || small->problemStatus_);
    21132097      factorization_ = factorization;
    21142098      if (factorization_ == NULL)
    2115         factorization_ = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,numberRows,numberColumns,false);
     2099        factorization_ = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_, numberRows, numberColumns, false);
    21162100#endif
    21172101    } else {
    2118       assert (factorization_==NULL);
    2119       factorization_ = static_cast<ClpSimplexDual *>(small)->setupForStrongBranching(spareArrays_,numberRows,
    2120                                                                                      numberColumns,false);
    2121     }
    2122     smallModel_=small;
    2123     if (modelPtr_->logLevel()<2) smallModel_->setLogLevel(0);
     2102      assert(factorization_ == NULL);
     2103      factorization_ = static_cast< ClpSimplexDual * >(small)->setupForStrongBranching(spareArrays_, numberRows,
     2104        numberColumns, false);
     2105    }
     2106    smallModel_ = small;
     2107    if (modelPtr_->logLevel() < 2)
     2108      smallModel_->setLogLevel(0);
    21242109    // Setup for strong branching
    21252110    int numberColumns2 = smallModel_->numberColumns();
    2126     CoinMemcpyN( modelPtr_->columnLower(),numberColumns, saveLowerOriginal);
    2127     CoinMemcpyN( modelPtr_->columnUpper(),numberColumns, saveUpperOriginal);
    2128     const double * smallLower = smallModel_->columnLower();
    2129     const double * smallUpper = smallModel_->columnUpper();
     2111    CoinMemcpyN(modelPtr_->columnLower(), numberColumns, saveLowerOriginal);
     2112    CoinMemcpyN(modelPtr_->columnUpper(), numberColumns, saveUpperOriginal);
     2113    const double *smallLower = smallModel_->columnLower();
     2114    const double *smallUpper = smallModel_->columnUpper();
    21302115    // But modify if bounds changed in small
    2131     for (int i=0;i<numberColumns2;i++) {
     2116    for (int i = 0; i < numberColumns2; i++) {
    21322117      int iColumn = whichColumn[i];
    21332118      saveLowerOriginal[iColumn] = CoinMax(saveLowerOriginal[iColumn],
    2134                                            smallLower[i]);
     2119        smallLower[i]);
    21352120      saveUpperOriginal[iColumn] = CoinMin(saveUpperOriginal[iColumn],
    2136                                            smallUpper[i]);
    2137     }
    2138     if (whichRange_&&whichRange_[0]) {
     2121        smallUpper[i]);
     2122    }
     2123    if (whichRange_ && whichRange_[0]) {
    21392124      // get ranging information
    21402125      int numberToDo = whichRange_[0];
    2141       int * which = new int [numberToDo];
     2126      int *which = new int[numberToDo];
    21422127      // Convert column numbers
    2143       int * backColumn = whichColumn+numberColumns;
    2144       for (int i=0;i<numberToDo;i++) {
    2145         int iColumn = whichRange_[i+1];
    2146         which[i]=backColumn[iColumn];
    2147       }
    2148       double * downRange=new double [numberToDo];
    2149       double * upRange=new double [numberToDo];
    2150       int * whichDown = new int [numberToDo];
    2151       int * whichUp = new int [numberToDo];
     2128      int *backColumn = whichColumn + numberColumns;
     2129      for (int i = 0; i < numberToDo; i++) {
     2130        int iColumn = whichRange_[i + 1];
     2131        which[i] = backColumn[iColumn];
     2132      }
     2133      double *downRange = new double[numberToDo];
     2134      double *upRange = new double[numberToDo];
     2135      int *whichDown = new int[numberToDo];
     2136      int *whichUp = new int[numberToDo];
    21522137      smallModel_->setFactorization(*factorization_);
    2153       smallModel_->gutsOfSolution(NULL,NULL,false);
     2138      smallModel_->gutsOfSolution(NULL, NULL, false);
    21542139      // Tell code we can increase costs in some cases
    21552140      smallModel_->setCurrentDualTolerance(0.0);
    2156       static_cast<ClpSimplexOther *> (smallModel_)->dualRanging(numberToDo,which,
    2157                          upRange, whichUp, downRange, whichDown);
    2158       delete [] whichDown;
    2159       delete [] whichUp;
    2160       delete [] which;
    2161       rowActivity_=upRange;
    2162       columnActivity_=downRange;
    2163     }
    2164   }
    2165     if (savedObjective) {
    2166       // fix up
    2167       modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
    2168       //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    2169       modelPtr_->objective_=savedObjective;
    2170       if (!modelPtr_->problemStatus_) {
    2171         CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
    2172         CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
    2173         if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
    2174           CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
    2175         modelPtr_->computeObjectiveValue();
    2176       }
    2177     }
     2141      static_cast< ClpSimplexOther * >(smallModel_)->dualRanging(numberToDo, which, upRange, whichUp, downRange, whichDown);
     2142      delete[] whichDown;
     2143      delete[] whichUp;
     2144      delete[] which;
     2145      rowActivity_ = upRange;
     2146      columnActivity_ = downRange;
     2147    }
     2148  }
     2149  if (savedObjective) {
     2150    // fix up
     2151    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
     2152    //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
     2153    modelPtr_->objective_ = savedObjective;
     2154    if (!modelPtr_->problemStatus_) {
     2155      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
     2156      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
     2157      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
     2158        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
     2159      modelPtr_->computeObjectiveValue();
     2160    }
     2161  }
    21782162}
    21792163
     
    21822166#ifdef KEEP_SMALL
    21832167  if (!spareArrays_) {
    2184     assert (!smallModel_);
    2185     assert (modelPtr_->problemStatus_==1);
     2168    assert(!smallModel_);
     2169    assert(modelPtr_->problemStatus_ == 1);
    21862170    return;
    21872171  }
    21882172#endif
    2189   ClpObjective * savedObjective=NULL;
    2190   double savedDualLimit=modelPtr_->dblParam_[ClpDualObjectiveLimit];
     2173  ClpObjective *savedObjective = NULL;
     2174  double savedDualLimit = modelPtr_->dblParam_[ClpDualObjectiveLimit];
    21912175  if (saveData_.perturbation_) {
    21922176    // Set fake
    2193     savedObjective=modelPtr_->objective_;
    2194     modelPtr_->objective_=fakeObjective_;
    2195     modelPtr_->dblParam_[ClpDualObjectiveLimit]=COIN_DBL_MAX;
     2177    savedObjective = modelPtr_->objective_;
     2178    modelPtr_->objective_ = fakeObjective_;
     2179    modelPtr_->dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
    21962180  }
    21972181  int numberRows = modelPtr_->numberRows();
    21982182  int numberColumns = modelPtr_->numberColumns();
    2199   modelPtr_->getIntParam(ClpMaxNumIteration,itlimOrig_);
     2183  modelPtr_->getIntParam(ClpMaxNumIteration, itlimOrig_);
    22002184  int itlim;
    22012185  modelPtr_->getIntParam(ClpMaxNumIterationHotStart, itlim);
    22022186  // Is there an extra copy of scaled bounds
    2203   int extraCopy = (modelPtr_->maximumRows_>0) ? modelPtr_->maximumRows_+modelPtr_->maximumColumns_ : 0;
     2187  int extraCopy = (modelPtr_->maximumRows_ > 0) ? modelPtr_->maximumRows_ + modelPtr_->maximumColumns_ : 0;
    22042188#ifdef CLEAN_HOT_START
    2205   if ((specialOptions_&65536)!=0) {
    2206     double * arrayD = reinterpret_cast<double *> (spareArrays_);
     2189  if ((specialOptions_ & 65536) != 0) {
     2190    double *arrayD = reinterpret_cast< double * >(spareArrays_);
    22072191    double saveObjectiveValue = arrayD[0];
    2208     double * saveSolution = arrayD+1;
    2209     int number = numberRows+numberColumns;
    2210     CoinMemcpyN(saveSolution,number,modelPtr_->solutionRegion());
    2211     double * saveLower = saveSolution + (numberRows+numberColumns);
    2212     CoinMemcpyN(saveLower,number,modelPtr_->lowerRegion());
    2213     double * saveUpper = saveLower + (numberRows+numberColumns);
    2214     CoinMemcpyN(saveUpper,number,modelPtr_->upperRegion());
    2215     double * saveObjective = saveUpper + (numberRows+numberColumns);
    2216     CoinMemcpyN(saveObjective,number,modelPtr_->costRegion());
    2217     double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
    2218     double * saveUpperOriginal = saveLowerOriginal + numberColumns;
     2192    double *saveSolution = arrayD + 1;
     2193    int number = numberRows + numberColumns;
     2194    CoinMemcpyN(saveSolution, number, modelPtr_->solutionRegion());
     2195    double *saveLower = saveSolution + (numberRows + numberColumns);
     2196    CoinMemcpyN(saveLower, number, modelPtr_->lowerRegion());
     2197    double *saveUpper = saveLower + (numberRows + numberColumns);
     2198    CoinMemcpyN(saveUpper, number, modelPtr_->upperRegion());
     2199    double *saveObjective = saveUpper + (numberRows + numberColumns);
     2200    CoinMemcpyN(saveObjective, number, modelPtr_->costRegion());
     2201    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
     2202    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
    22192203    arrayD = saveUpperOriginal + numberColumns;
    2220     int * savePivot = reinterpret_cast<int *> (arrayD);
    2221     CoinMemcpyN(savePivot,numberRows,modelPtr_->pivotVariable());
    2222     int * whichRow = savePivot+numberRows;
    2223     int * whichColumn = whichRow + 3*numberRows;
    2224     int * arrayI = whichColumn + 2*numberColumns;
    2225     unsigned char * saveStatus = reinterpret_cast<unsigned char *> (arrayI+1);
    2226     CoinMemcpyN(saveStatus,number,modelPtr_->statusArray());
     2204    int *savePivot = reinterpret_cast< int * >(arrayD);
     2205    CoinMemcpyN(savePivot, numberRows, modelPtr_->pivotVariable());
     2206    int *whichRow = savePivot + numberRows;
     2207    int *whichColumn = whichRow + 3 * numberRows;
     2208    int *arrayI = whichColumn + 2 * numberColumns;
     2209    unsigned char *saveStatus = reinterpret_cast< unsigned char * >(arrayI + 1);
     2210    CoinMemcpyN(saveStatus, number, modelPtr_->statusArray());
    22272211    modelPtr_->setFactorization(*factorization_);
    2228     double * columnLower = modelPtr_->columnLower();
    2229     double * columnUpper = modelPtr_->columnUpper();
     2212    double *columnLower = modelPtr_->columnLower();
     2213    double *columnUpper = modelPtr_->columnUpper();
    22302214    // make sure whatsChanged_ has 1 set
    22312215    modelPtr_->setWhatsChanged(511);
    2232     double * lowerInternal = modelPtr_->lowerRegion();
    2233     double * upperInternal = modelPtr_->upperRegion();
     2216    double *lowerInternal = modelPtr_->lowerRegion();
     2217    double *upperInternal = modelPtr_->upperRegion();
    22342218    double rhsScale = modelPtr_->rhsScale();
    2235     const double * columnScale = NULL;
    2236     if (modelPtr_->scalingFlag()>0)
    2237       columnScale = modelPtr_->columnScale() ;
     2219    const double *columnScale = NULL;
     2220    if (modelPtr_->scalingFlag() > 0)
     2221      columnScale = modelPtr_->columnScale();
    22382222    // and do bounds in case dual needs them
    22392223    int iColumn;
    2240     for (iColumn=0;iColumn<numberColumns;iColumn++) {
    2241       if (columnLower[iColumn]>saveLowerOriginal[iColumn]) {
    2242         double value = columnLower[iColumn];
    2243         value *= rhsScale;
    2244         if (columnScale)
    2245           value /= columnScale[iColumn];
    2246         lowerInternal[iColumn]=value;
    2247         if (extraCopy)
    2248           lowerInternal[iColumn+extraCopy]=value;
    2249       }
    2250       if (columnUpper[iColumn]<saveUpperOriginal[iColumn]) {
    2251         double value = columnUpper[iColumn];
    2252         value *= rhsScale;
    2253         if (columnScale)
    2254           value /= columnScale[iColumn];
    2255         upperInternal[iColumn]=value;
    2256         if (extraCopy)
    2257           upperInternal[iColumn+extraCopy]=value;
     2224    for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2225      if (columnLower[iColumn] > saveLowerOriginal[iColumn]) {
     2226        double value = columnLower[iColumn];
     2227        value *= rhsScale;
     2228        if (columnScale)
     2229          value /= columnScale[iColumn];
     2230        lowerInternal[iColumn] = value;
     2231        if (extraCopy)
     2232          lowerInternal[iColumn + extraCopy] = value;
     2233      }
     2234      if (columnUpper[iColumn] < saveUpperOriginal[iColumn]) {
     2235        double value = columnUpper[iColumn];
     2236        value *= rhsScale;
     2237        if (columnScale)
     2238          value /= columnScale[iColumn];
     2239        upperInternal[iColumn] = value;
     2240        if (extraCopy)
     2241          upperInternal[iColumn + extraCopy] = value;
    22582242      }
    22592243    }
    22602244    // Start of fast iterations
    2261     bool alwaysFinish= ((specialOptions_&32)==0) ? true : false;
     2245    bool alwaysFinish = ((specialOptions_ & 32) == 0) ? true : false;
    22622246    //modelPtr_->setLogLevel(1);
    2263     modelPtr_->setIntParam(ClpMaxNumIteration,itlim);
    2264     int saveNumberFake = (static_cast<ClpSimplexDual *>(modelPtr_))->numberFake_;
    2265     int status = (static_cast<ClpSimplexDual *>(modelPtr_))->fastDual(alwaysFinish);
    2266     (static_cast<ClpSimplexDual *>(modelPtr_))->numberFake_ = saveNumberFake;
    2267    
     2247    modelPtr_->setIntParam(ClpMaxNumIteration, itlim);
     2248    int saveNumberFake = (static_cast< ClpSimplexDual * >(modelPtr_))->numberFake_;
     2249    int status = (static_cast< ClpSimplexDual * >(modelPtr_))->fastDual(alwaysFinish);
     2250    (static_cast< ClpSimplexDual * >(modelPtr_))->numberFake_ = saveNumberFake;
     2251
    22682252    int problemStatus = modelPtr_->problemStatus();
    2269     double objectiveValue =modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
    2270     CoinAssert (modelPtr_->problemStatus()||modelPtr_->objectiveValue()<1.0e50);
     2253    double objectiveValue = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
     2254    CoinAssert(modelPtr_->problemStatus() || modelPtr_->objectiveValue() < 1.0e50);
    22712255    // make sure plausible
    2272     double obj = CoinMax(objectiveValue,saveObjectiveValue);
    2273     if (problemStatus==10||problemStatus<0) {
     2256    double obj = CoinMax(objectiveValue, saveObjectiveValue);
     2257    if (problemStatus == 10 || problemStatus < 0) {
    22742258      // was trying to clean up or something odd
    2275       if (problemStatus==10) {
    2276         obj = saveObjectiveValue;
    2277         lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
    2278       }
    2279       status=1;
     2259      if (problemStatus == 10) {
     2260        obj = saveObjectiveValue;
     2261        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
     2262      }
     2263      status = 1;
    22802264    }
    22812265    if (status) {
    22822266      // not finished - might be optimal
    22832267      modelPtr_->checkPrimalSolution(modelPtr_->solutionRegion(0),
    2284                                      modelPtr_->solutionRegion(1));
     2268        modelPtr_->solutionRegion(1));
    22852269      //modelPtr_->gutsOfSolution(NULL,NULL,0);
    22862270      //if (problemStatus==3)
    22872271      //modelPtr_->computeObjectiveValue();
    2288       objectiveValue =modelPtr_->objectiveValue() *
    2289         modelPtr_->optimizationDirection();
    2290       obj = CoinMax(objectiveValue,saveObjectiveValue);
    2291       if (!modelPtr_->numberDualInfeasibilities()) {
    2292         double limit = 0.0;
    2293         modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
    2294         if (modelPtr_->secondaryStatus()==1&&!problemStatus&&obj<limit) {
    2295           obj=limit;
    2296           problemStatus=3;
    2297         }
    2298         if (!modelPtr_->numberPrimalInfeasibilities()&&obj<limit) {
    2299           problemStatus=0;
    2300         } else if (problemStatus==10) {
    2301           problemStatus=3;
    2302           obj = saveObjectiveValue;
    2303         } else if (!modelPtr_->numberPrimalInfeasibilities()) {
    2304           problemStatus=1; // infeasible
    2305         }
     2272      objectiveValue = modelPtr_->objectiveValue() * modelPtr_->optimizationDirection();
     2273      obj = CoinMax(objectiveValue, saveObjectiveValue);
     2274      if (!modelPtr_->numberDualInfeasibilities()) {
     2275        double limit = 0.0;
     2276        modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
     2277        if (modelPtr_->secondaryStatus() == 1 && !problemStatus && obj < limit) {
     2278          obj = limit;
     2279          problemStatus = 3;
     2280        }
     2281        if (!modelPtr_->numberPrimalInfeasibilities() && obj < limit) {
     2282          problemStatus = 0;
     2283        } else if (problemStatus == 10) {
     2284          problemStatus = 3;
     2285          obj = saveObjectiveValue;
     2286        } else if (!modelPtr_->numberPrimalInfeasibilities()) {
     2287          problemStatus = 1; // infeasible
     2288        }
    23062289      } else {
    2307         // can't say much
    2308         //if (problemStatus==3)
    2309         //modelPtr_->computeObjectiveValue();
    2310         lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
    2311         obj = saveObjectiveValue;
    2312         problemStatus=3;
     2290        // can't say much
     2291        //if (problemStatus==3)
     2292        //modelPtr_->computeObjectiveValue();
     2293        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
     2294        obj = saveObjectiveValue;
     2295        problemStatus = 3;
    23132296      }
    23142297    } else if (!problemStatus) {
    2315       if (modelPtr_->isDualObjectiveLimitReached()) 
    2316         problemStatus=1; // infeasible
    2317     }
    2318     if (status&&!problemStatus) {
    2319       problemStatus=3; // can't be sure
    2320       lastAlgorithm_=1;
    2321     }
    2322     if (problemStatus<0)
    2323       problemStatus=3;
     2298      if (modelPtr_->isDualObjectiveLimitReached())
     2299        problemStatus = 1; // infeasible
     2300    }
     2301    if (status && !problemStatus) {
     2302      problemStatus = 3; // can't be sure
     2303      lastAlgorithm_ = 1;
     2304    }
     2305    if (problemStatus < 0)
     2306      problemStatus = 3;
    23242307    modelPtr_->setProblemStatus(problemStatus);
    2325     modelPtr_->setObjectiveValue(obj*modelPtr_->optimizationDirection());
    2326     double * solution = modelPtr_->primalColumnSolution();
    2327     const double * solution2 = modelPtr_->solutionRegion();
     2308    modelPtr_->setObjectiveValue(obj * modelPtr_->optimizationDirection());
     2309    double *solution = modelPtr_->primalColumnSolution();
     2310    const double *solution2 = modelPtr_->solutionRegion();
    23282311    // could just do changed bounds - also try double size scale so can use * not /
    23292312    if (!columnScale) {
    2330       for (iColumn=0;iColumn<numberColumns;iColumn++) {
    2331         solution[iColumn]= solution2[iColumn];
     2313      for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2314        solution[iColumn] = solution2[iColumn];
    23322315      }
    23332316    } else {
    2334       for (iColumn=0;iColumn<numberColumns;iColumn++) {
    2335         solution[iColumn]= solution2[iColumn]*columnScale[iColumn];
    2336       }
    2337     }
    2338     CoinMemcpyN(saveLowerOriginal,numberColumns,columnLower);
    2339     CoinMemcpyN(saveUpperOriginal,numberColumns,columnUpper);
     2317      for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     2318        solution[iColumn] = solution2[iColumn] * columnScale[iColumn];
     2319      }
     2320    }
     2321    CoinMemcpyN(saveLowerOriginal, numberColumns, columnLower);
     2322    CoinMemcpyN(saveUpperOriginal, numberColumns, columnUpper);
    23402323#if 0
    23412324    // could combine with loop above
     
    23562339#endif
    23572340    // and back bounds
    2358     CoinMemcpyN(saveLower,number,modelPtr_->lowerRegion());
    2359     CoinMemcpyN(saveUpper,number,modelPtr_->upperRegion());
     2341    CoinMemcpyN(saveLower, number, modelPtr_->lowerRegion());
     2342    CoinMemcpyN(saveUpper, number, modelPtr_->upperRegion());
    23602343    if (extraCopy) {
    2361       CoinMemcpyN(saveLower,number,modelPtr_->lowerRegion()+extraCopy);
    2362       CoinMemcpyN(saveUpper,number,modelPtr_->upperRegion()+extraCopy);
    2363     }
    2364     modelPtr_->setIntParam(ClpMaxNumIteration,itlimOrig_);
     2344      CoinMemcpyN(saveLower, number, modelPtr_->lowerRegion() + extraCopy);
     2345      CoinMemcpyN(saveUpper, number, modelPtr_->upperRegion() + extraCopy);
     2346    }
     2347    modelPtr_->setIntParam(ClpMaxNumIteration, itlimOrig_);
    23652348    if (savedObjective) {
    23662349      // fix up
    2367       modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
     2350      modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
    23682351      //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    2369       modelPtr_->objective_=savedObjective;
     2352      modelPtr_->objective_ = savedObjective;
    23702353      if (!modelPtr_->problemStatus_) {
    2371         CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
    2372         CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
    2373         if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
    2374           CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
    2375         modelPtr_->computeObjectiveValue();
     2354        CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
     2355        CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
     2356        if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
     2357          CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
     2358        modelPtr_->computeObjectiveValue();
    23762359      }
    23772360    }
     
    23792362  }
    23802363#endif
    2381   if (smallModel_==NULL) {
     2364  if (smallModel_ == NULL) {
    23822365    setWarmStart(ws_);
    2383     CoinMemcpyN(           rowActivity_,numberRows,modelPtr_->primalRowSolution());
    2384     CoinMemcpyN(columnActivity_,numberColumns,modelPtr_->primalColumnSolution());
    2385     modelPtr_->setIntParam(ClpMaxNumIteration,CoinMin(itlim,9999));
     2366    CoinMemcpyN(rowActivity_, numberRows, modelPtr_->primalRowSolution());
     2367    CoinMemcpyN(columnActivity_, numberColumns, modelPtr_->primalColumnSolution());
     2368    modelPtr_->setIntParam(ClpMaxNumIteration, CoinMin(itlim, 9999));
    23862369    resolve();
    23872370  } else {
    2388     assert (spareArrays_);
    2389     double * arrayD = reinterpret_cast<double *> (spareArrays_);
     2371    assert(spareArrays_);
     2372    double *arrayD = reinterpret_cast< double * >(spareArrays_);
    23902373    double saveObjectiveValue = arrayD[0];
    2391     double * saveSolution = arrayD+1;
     2374    double *saveSolution = arrayD + 1;
    23922375    // double check arrays exist (? for nonlinear)
    23932376    //if (!smallModel_->solutionRegion())
     
    23952378    int numberRows2 = smallModel_->numberRows();
    23962379    int numberColumns2 = smallModel_->numberColumns();
    2397     int number = numberRows2+numberColumns2;
    2398     CoinMemcpyN(saveSolution,number,smallModel_->solutionRegion());
    2399     double * saveLower = saveSolution + (numberRows+numberColumns);
    2400     CoinMemcpyN(saveLower,number,smallModel_->lowerRegion());
    2401     double * saveUpper = saveLower + (numberRows+numberColumns);
    2402     CoinMemcpyN(saveUpper,number,smallModel_->upperRegion());
    2403     double * saveObjective = saveUpper + (numberRows+numberColumns);
    2404     CoinMemcpyN(saveObjective,number,smallModel_->costRegion());
    2405     double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
    2406     double * saveUpperOriginal = saveLowerOriginal + numberColumns;
     2380    int number = numberRows2 + numberColumns2;
     2381    CoinMemcpyN(saveSolution, number, smallModel_->solutionRegion());
     2382    double *saveLower = saveSolution + (numberRows + numberColumns);
     2383    CoinMemcpyN(saveLower, number, smallModel_->lowerRegion());
     2384    double *saveUpper = saveLower + (numberRows + numberColumns);
     2385    CoinMemcpyN(saveUpper, number, smallModel_->upperRegion());
     2386    double *saveObjective = saveUpper + (numberRows + numberColumns);
     2387    CoinMemcpyN(saveObjective, number, smallModel_->costRegion());
     2388    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
     2389    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
    24072390    arrayD = saveUpperOriginal + numberColumns;
    2408     int * savePivot = reinterpret_cast<int *> (arrayD);
    2409     CoinMemcpyN(savePivot,numberRows2,smallModel_->pivotVariable());
    2410     int * whichRow = savePivot+numberRows;
    2411     int * whichColumn = whichRow + 3*numberRows;
    2412     int * arrayI = whichColumn + 2*numberColumns;
    2413     unsigned char * saveStatus = reinterpret_cast<unsigned char *> (arrayI+1);
    2414     CoinMemcpyN(saveStatus,number,smallModel_->statusArray());
     2391    int *savePivot = reinterpret_cast< int * >(arrayD);
     2392    CoinMemcpyN(savePivot, numberRows2, smallModel_->pivotVariable());
     2393    int *whichRow = savePivot + numberRows;
     2394    int *whichColumn = whichRow + 3 * numberRows;
     2395    int *arrayI = whichColumn + 2 * numberColumns;
     2396    unsigned char *saveStatus = reinterpret_cast< unsigned char * >(arrayI + 1);
     2397    CoinMemcpyN(saveStatus, number, smallModel_->statusArray());
    24152398    /* If factorization_ NULL then infeasible
    24162399       not really sure how could have slipped through.
    24172400       But this can't make situation worse */
    2418     if (factorization_) 
     2401    if (factorization_)
    24192402      smallModel_->setFactorization(*factorization_);
    24202403    //int * backColumn = whichColumn+numberColumns;
    2421     const double * lowerBig = modelPtr_->columnLower();
    2422     const double * upperBig = modelPtr_->columnUpper();
     2404    const double *lowerBig = modelPtr_->columnLower();
     2405    const double *upperBig = modelPtr_->columnUpper();
    24232406    // make sure whatsChanged_ has 1 set
    24242407    smallModel_->setWhatsChanged(511);
    2425     double * lowerSmall = smallModel_->lowerRegion();
    2426     double * upperSmall = smallModel_->upperRegion();
    2427     double * solutionSmall = smallModel_->solutionRegion();
    2428     double * lowerSmallReal = smallModel_->columnLower();
    2429     double * upperSmallReal = smallModel_->columnUpper();
     2408    double *lowerSmall = smallModel_->lowerRegion();
     2409    double *upperSmall = smallModel_->upperRegion();
     2410    double *solutionSmall = smallModel_->solutionRegion();
     2411    double *lowerSmallReal = smallModel_->columnLower();
     2412    double *upperSmallReal = smallModel_->columnUpper();
    24302413    int i;
    24312414    double rhsScale = smallModel_->rhsScale();
    2432     const double * columnScale = NULL;
    2433     const double * rowScale = NULL;
    2434     if (smallModel_->scalingFlag()>0) {
     2415    const double *columnScale = NULL;
     2416    const double *rowScale = NULL;
     2417    if (smallModel_->scalingFlag() > 0) {
    24352418      columnScale = smallModel_->columnScale();
    24362419      rowScale = smallModel_->rowScale();
     
    24382421    // and do bounds in case dual needs them
    24392422    // may be infeasible
    2440     for (i=0;i<numberColumns2;i++) {
     2423    for (i = 0; i < numberColumns2; i++) {
    24412424      int iColumn = whichColumn[i];
    2442       if (lowerBig[iColumn]>saveLowerOriginal[iColumn]) {
     2425      if (lowerBig[iColumn] > saveLowerOriginal[iColumn]) {
    24432426        double value = lowerBig[iColumn];
    2444         lowerSmallReal[i]=value;
     2427        lowerSmallReal[i] = value;
    24452428        value *= rhsScale;
    24462429        if (columnScale)
    24472430          value /= columnScale[i];
    2448         lowerSmall[i]=value;
    2449         if (smallModel_->getColumnStatus(i)==ClpSimplex::atLowerBound)
    2450           solutionSmall[i]=value;
    2451       }
    2452       if (upperBig[iColumn]<saveUpperOriginal[iColumn]) {
     2431        lowerSmall[i] = value;
     2432        if (smallModel_->getColumnStatus(i) == ClpSimplex::atLowerBound)
     2433          solutionSmall[i] = value;
     2434      }
     2435      if (upperBig[iColumn] < saveUpperOriginal[iColumn]) {
    24532436        double value = upperBig[iColumn];
    2454         upperSmallReal[i]=value;
     2437        upperSmallReal[i] = value;
    24552438        value *= rhsScale;
    24562439        if (columnScale)
    24572440          value /= columnScale[i];
    2458         upperSmall[i]=value;
    2459         if (smallModel_->getColumnStatus(i)==ClpSimplex::atUpperBound)
    2460           solutionSmall[i]=value;
    2461       }
    2462       if (upperSmall[i]<lowerSmall[i]-1.0e-8)
    2463         break;
     2441        upperSmall[i] = value;
     2442        if (smallModel_->getColumnStatus(i) == ClpSimplex::atUpperBound)
     2443          solutionSmall[i] = value;
     2444      }
     2445      if (upperSmall[i] < lowerSmall[i] - 1.0e-8)
     2446        break;
    24642447    }
    24652448    /* If factorization_ NULL then infeasible
    24662449       not really sure how could have slipped through.
    24672450       But this can't make situation worse */
    2468     bool infeasible = (i<numberColumns2||!factorization_);
     2451    bool infeasible = (i < numberColumns2 || !factorization_);
    24692452    // Start of fast iterations
    2470     bool alwaysFinish= ((specialOptions_&32)==0) ? true : false;
     2453    bool alwaysFinish = ((specialOptions_ & 32) == 0) ? true : false;
    24712454    //smallModel_->setLogLevel(1);
    2472     smallModel_->setIntParam(ClpMaxNumIteration,itlim);
    2473     int saveNumberFake = (static_cast<ClpSimplexDual *>(smallModel_))->numberFake_;
     2455    smallModel_->setIntParam(ClpMaxNumIteration, itlim);
     2456    int saveNumberFake = (static_cast< ClpSimplexDual * >(smallModel_))->numberFake_;
    24742457    int status;
    24752458    if (!infeasible) {
    2476       if((modelPtr_->specialOptions()&0x011200000)==0x11200000) {
    2477         smallModel_->specialOptions_|=2097152;
    2478         //smallModel_->specialOptions_&=~2097152;
    2479         delete [] modelPtr_->ray_;
    2480         delete [] smallModel_->ray_;
    2481         modelPtr_->ray_=NULL;
    2482         smallModel_->ray_=NULL;
    2483       }
    2484       status = static_cast<ClpSimplexDual *>(smallModel_)->fastDual(alwaysFinish);
    2485       if((modelPtr_->specialOptions()&0x011200000)==0x11200000&&smallModel_->ray_) {
    2486         if (smallModel_->sequenceOut_<smallModel_->numberColumns_)
    2487             modelPtr_->sequenceOut_ = whichColumn[smallModel_->sequenceOut_];
    2488         else
    2489             modelPtr_->sequenceOut_ = whichRow[smallModel_->sequenceOut_-smallModel_->numberColumns_]+modelPtr_->numberColumns_;
    2490         if (smallModel_->rowScale_) {
    2491           // scale ray
    2492           double scaleFactor=1.0;
    2493           if (smallModel_->sequenceOut_<smallModel_->numberColumns_)
    2494             scaleFactor = smallModel_->columnScale_[smallModel_->sequenceOut_];
    2495           for (int i = 0; i < smallModel_->numberRows_; i++) {
    2496             smallModel_->ray_[i] *= smallModel_->rowScale_[i]*scaleFactor;
    2497           }
    2498         }
    2499       } 
     2459      if ((modelPtr_->specialOptions() & 0x011200000) == 0x11200000) {
     2460        smallModel_->specialOptions_ |= 2097152;
     2461        //smallModel_->specialOptions_&=~2097152;
     2462        delete[] modelPtr_->ray_;
     2463        delete[] smallModel_->ray_;
     2464        modelPtr_->ray_ = NULL;
     2465        smallModel_->ray_ = NULL;
     2466      }
     2467      status = static_cast< ClpSimplexDual * >(smallModel_)->fastDual(alwaysFinish);
     2468      if ((modelPtr_->specialOptions() & 0x011200000) == 0x11200000 && smallModel_->ray_) {
     2469        if (smallModel_->sequenceOut_ < smallModel_->numberColumns_)
     2470          modelPtr_->sequenceOut_ = whichColumn[smallModel_->sequenceOut_];
     2471        else
     2472          modelPtr_->sequenceOut_ = whichRow[smallModel_->sequenceOut_ - smallModel_->numberColumns_] + modelPtr_->numberColumns_;
     2473        if (smallModel_->rowScale_) {
     2474          // scale ray
     2475          double scaleFactor = 1.0;
     2476          if (smallModel_->sequenceOut_ < smallModel_->numberColumns_)
     2477            scaleFactor = smallModel_->columnScale_[smallModel_->sequenceOut_];
     2478          for (int i = 0; i < smallModel_->numberRows_; i++) {
     2479            smallModel_->ray_[i] *= smallModel_->rowScale_[i] * scaleFactor;
     2480          }
     2481        }
     2482      }
    25002483    } else {
    2501       status=0;
     2484      status = 0;
    25022485      smallModel_->setProblemStatus(1);
    25032486    }
    2504     (static_cast<ClpSimplexDual *>(smallModel_))->numberFake_ = saveNumberFake;
    2505     if (smallModel_->numberIterations()==-98) {
     2487    (static_cast< ClpSimplexDual * >(smallModel_))->numberFake_ = saveNumberFake;
     2488    if (smallModel_->numberIterations() == -98) {
    25062489      printf("rrrrrrrrrrrr\n");
    25072490      smallModel_->checkPrimalSolution(smallModel_->solutionRegion(0),
    2508                                      smallModel_->solutionRegion(1));
     2491        smallModel_->solutionRegion(1));
    25092492      //smallModel_->gutsOfSolution(NULL,NULL,0);
    25102493      //if (problemStatus==3)
    25112494      //smallModel_->computeObjectiveValue();
    2512       printf("robj %g\n",smallModel_->objectiveValue() *
    2513              modelPtr_->optimizationDirection());
     2495      printf("robj %g\n", smallModel_->objectiveValue() * modelPtr_->optimizationDirection());
    25142496      writeMps("rr.mps");
    25152497      smallModel_->writeMps("rr_small.mps");
     
    25202502      double limit = 0.0;
    25212503      modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
    2522       if (temp.problemStatus()==0&&temp.objectiveValue()<limit) {
    2523         printf("inf obj %g, true %g - offsets %g %g\n",smallModel_->objectiveValue(),
    2524                temp.objectiveValue(),
    2525                smallModel_->objectiveOffset(),temp.objectiveOffset());
     2504      if (temp.problemStatus() == 0 && temp.objectiveValue() < limit) {
     2505        printf("inf obj %g, true %g - offsets %g %g\n", smallModel_->objectiveValue(),
     2506          temp.objectiveValue(),
     2507          smallModel_->objectiveOffset(), temp.objectiveOffset());
    25262508      }
    25272509      printf("big\n");
    25282510      temp = *modelPtr_;
    25292511      temp.dual();
    2530       if (temp.problemStatus()==0&&temp.objectiveValue()<limit) {
    2531         printf("inf obj %g, true %g - offsets %g %g\n",smallModel_->objectiveValue(),
    2532                temp.objectiveValue(),
    2533                smallModel_->objectiveOffset(),temp.objectiveOffset());
     2512      if (temp.problemStatus() == 0 && temp.objectiveValue() < limit) {
     2513        printf("inf obj %g, true %g - offsets %g %g\n", smallModel_->objectiveValue(),
     2514          temp.objectiveValue(),
     2515          smallModel_->objectiveOffset(), temp.objectiveOffset());
    25342516      }
    25352517    }
    25362518    int problemStatus = smallModel_->problemStatus();
    2537     double objectiveValue =smallModel_->objectiveValue() * modelPtr_->optimizationDirection();
    2538     CoinAssert (smallModel_->problemStatus()||smallModel_->objectiveValue()<1.0e50);
     2519    double objectiveValue = smallModel_->objectiveValue() * modelPtr_->optimizationDirection();
     2520    CoinAssert(smallModel_->problemStatus() || smallModel_->objectiveValue() < 1.0e50);
    25392521    // make sure plausible
    2540     double obj = CoinMax(objectiveValue,saveObjectiveValue);
    2541     if (problemStatus==10||problemStatus<0) {
     2522    double obj = CoinMax(objectiveValue, saveObjectiveValue);
     2523    if (problemStatus == 10 || problemStatus < 0) {
    25422524      // was trying to clean up or something odd
    2543       if (problemStatus==10)
    2544         lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
    2545       status=1;
     2525      if (problemStatus == 10)
     2526        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
     2527      status = 1;
    25462528    }
    25472529    if (status) {
    25482530      // not finished - might be optimal
    25492531      smallModel_->checkPrimalSolution(smallModel_->solutionRegion(0),
    2550                                      smallModel_->solutionRegion(1));
     2532        smallModel_->solutionRegion(1));
    25512533      //smallModel_->gutsOfSolution(NULL,NULL,0);
    25522534      //if (problemStatus==3)
    25532535      //smallModel_->computeObjectiveValue();
    2554       objectiveValue =smallModel_->objectiveValue() *
    2555         modelPtr_->optimizationDirection();
    2556       if (problemStatus!=10)
    2557         obj = CoinMax(objectiveValue,saveObjectiveValue);
    2558       if (!smallModel_->numberDualInfeasibilities()) {
     2536      objectiveValue = smallModel_->objectiveValue() * modelPtr_->optimizationDirection();
     2537      if (problemStatus != 10)
     2538        obj = CoinMax(objectiveValue, saveObjectiveValue);
     2539      if (!smallModel_->numberDualInfeasibilities()) {
    25592540        double limit = 0.0;
    25602541        modelPtr_->getDblParam(ClpDualObjectiveLimit, limit);
    2561         if (smallModel_->secondaryStatus()==1&&!problemStatus&&obj<limit) {
     2542        if (smallModel_->secondaryStatus() == 1 && !problemStatus && obj < limit) {
    25622543#if 0
    25632544          // switch off
     
    25732554          problemStatus=10;
    25742555#else
    2575           obj=limit;
    2576           problemStatus=3;
     2556          obj = limit;
     2557          problemStatus = 3;
    25772558#endif
    25782559        }
    2579         if (!smallModel_->numberPrimalInfeasibilities()&&obj<limit) {
    2580           problemStatus=0;
     2560        if (!smallModel_->numberPrimalInfeasibilities() && obj < limit) {
     2561          problemStatus = 0;
    25812562#if 0
    25822563          ClpSimplex temp = *smallModel_;
     
    25862567          assert (temp.problemStatus()==0&&temp.objectiveValue()<limit);
    25872568#endif
    2588         } else if (problemStatus==10) {
    2589           problemStatus=3;
     2569        } else if (problemStatus == 10) {
     2570          problemStatus = 3;
    25902571        } else if (!smallModel_->numberPrimalInfeasibilities()) {
    2591           problemStatus=1; // infeasible
    2592         } 
     2572          problemStatus = 1; // infeasible
     2573        }
    25932574      } else {
    25942575        // can't say much
    25952576        //if (problemStatus==3)
    25962577        //smallModel_->computeObjectiveValue();
    2597         lastAlgorithm_=1; // so won't fail on cutoff (in CbcNode)
    2598         problemStatus=3;
     2578        lastAlgorithm_ = 1; // so won't fail on cutoff (in CbcNode)
     2579        problemStatus = 3;
    25992580      }
    26002581    } else if (!problemStatus) {
    2601       if (smallModel_->isDualObjectiveLimitReached()) 
    2602         problemStatus=1; // infeasible
    2603     }
    2604     if (status&&!problemStatus) {
    2605       problemStatus=3; // can't be sure
    2606       lastAlgorithm_=1;
    2607     }
    2608     if (problemStatus<0)
    2609       problemStatus=3;
     2582      if (smallModel_->isDualObjectiveLimitReached())
     2583        problemStatus = 1; // infeasible
     2584    }
     2585    if (status && !problemStatus) {
     2586      problemStatus = 3; // can't be sure
     2587      lastAlgorithm_ = 1;
     2588    }
     2589    if (problemStatus < 0)
     2590      problemStatus = 3;
    26102591    modelPtr_->setProblemStatus(problemStatus);
    2611     modelPtr_->setObjectiveValue(obj*modelPtr_->optimizationDirection());
     2592    modelPtr_->setObjectiveValue(obj * modelPtr_->optimizationDirection());
    26122593    modelPtr_->setSumDualInfeasibilities(smallModel_->sumDualInfeasibilities());
    26132594    modelPtr_->setNumberDualInfeasibilities(smallModel_->numberDualInfeasibilities());
    26142595    modelPtr_->setSumPrimalInfeasibilities(smallModel_->sumPrimalInfeasibilities());
    26152596    modelPtr_->setNumberPrimalInfeasibilities(smallModel_->numberPrimalInfeasibilities());
    2616     double * solution = modelPtr_->primalColumnSolution();
    2617     const double * solution2 = smallModel_->solutionRegion();
    2618     double * djs = modelPtr_->dualColumnSolution();
     2597    double *solution = modelPtr_->primalColumnSolution();
     2598    const double *solution2 = smallModel_->solutionRegion();
     2599    double *djs = modelPtr_->dualColumnSolution();
    26192600    if (!columnScale) {
    2620       for (i=0;i<numberColumns2;i++) {
     2601      for (i = 0; i < numberColumns2; i++) {
    26212602        int iColumn = whichColumn[i];
    2622         solution[iColumn]= solution2[i];
    2623         lowerSmallReal[i]=saveLowerOriginal[iColumn];
    2624         upperSmallReal[i]=saveUpperOriginal[iColumn];
     2603        solution[iColumn] = solution2[i];
     2604        lowerSmallReal[i] = saveLowerOriginal[iColumn];
     2605        upperSmallReal[i] = saveUpperOriginal[iColumn];
    26252606      }
    26262607    } else {
    2627       for (i=0;i<numberColumns2;i++) {
     2608      for (i = 0; i < numberColumns2; i++) {
    26282609        int iColumn = whichColumn[i];
    2629         solution[iColumn]= solution2[i]*columnScale[i];
    2630         lowerSmallReal[i]=saveLowerOriginal[iColumn];
    2631         upperSmallReal[i]=saveUpperOriginal[iColumn];
     2610        solution[iColumn] = solution2[i] * columnScale[i];
     2611        lowerSmallReal[i] = saveLowerOriginal[iColumn];
     2612        upperSmallReal[i] = saveUpperOriginal[iColumn];
    26322613      }
    26332614    }
    26342615    // compute duals and djs
    2635     double * dual = modelPtr_->dualRowSolution();
    2636     const double * dual2 = smallModel_->dualRowSolution();
     2616    double *dual = modelPtr_->dualRowSolution();
     2617    const double *dual2 = smallModel_->dualRowSolution();
    26372618    if (!rowScale) {
    2638       for (i=0;i<numberRows2;i++) {
     2619      for (i = 0; i < numberRows2; i++) {
    26392620        int iRow = whichRow[i];
    2640         dual[iRow]= dual2[i];
     2621        dual[iRow] = dual2[i];
    26412622      }
    26422623    } else {
    2643       for (i=0;i<numberRows2;i++) {
     2624      for (i = 0; i < numberRows2; i++) {
    26442625        int iRow = whichRow[i];
    2645         dual[iRow]= dual2[i]*rowScale[i];
    2646       }
    2647     }
    2648     memcpy(djs,modelPtr_->objective(),numberColumns*sizeof(double));
    2649     modelPtr_->clpMatrix()->transposeTimes(-1.0,dual,djs);
     2626        dual[iRow] = dual2[i] * rowScale[i];
     2627      }
     2628    }
     2629    memcpy(djs, modelPtr_->objective(), numberColumns * sizeof(double));
     2630    modelPtr_->clpMatrix()->transposeTimes(-1.0, dual, djs);
    26502631    // could combine with loop above
    2651     if (modelPtr_==smallModel_)
     2632    if (modelPtr_ == smallModel_)
    26522633      modelPtr_->computeObjectiveValue();
    2653     if (problemStatus==1&&smallModel_->ray_) {
    2654       delete [] modelPtr_->ray_;
     2634    if (problemStatus == 1 && smallModel_->ray_) {
     2635      delete[] modelPtr_->ray_;
    26552636      // get ray to full problem
    26562637      int numberRows = modelPtr_->numberRows();
    26572638      int numberRows2 = smallModel_->numberRows();
    2658       int nCopy = 3*numberRows+2*numberColumns;
     2639      int nCopy = 3 * numberRows + 2 * numberColumns;
    26592640      int nBound = whichRow[nCopy];
    2660       double * ray = new double [numberRows];
    2661       memset(ray,0,numberRows*sizeof(double));
     2641      double *ray = new double[numberRows];
     2642      memset(ray, 0, numberRows * sizeof(double));
    26622643      for (int i = 0; i < numberRows2; i++) {
    2663         int iRow = whichRow[i];
    2664         ray[iRow] = smallModel_->ray_[i];
     2644        int iRow = whichRow[i];
     2645        ray[iRow] = smallModel_->ray_[i];
    26652646      }
    26662647      // Column copy of matrix
    2667       const double * element = getMatrixByCol()->getElements();
    2668       const int * row = getMatrixByCol()->getIndices();
    2669       const CoinBigIndex * columnStart = getMatrixByCol()->getVectorStarts();
    2670       const int * columnLength = getMatrixByCol()->getVectorLengths();
     2648      const double *element = getMatrixByCol()->getElements();
     2649      const int *row = getMatrixByCol()->getIndices();
     2650      const CoinBigIndex *columnStart = getMatrixByCol()->getVectorStarts();
     2651      const int *columnLength = getMatrixByCol()->getVectorLengths();
    26712652      // translate
    26722653      for (int jRow = nBound; jRow < 2 * numberRows; jRow++) {
    2673         int iRow = whichRow[jRow];
    2674         int iColumn = whichRow[jRow+numberRows];
    2675         if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
    2676           double value = 0.0;
    2677           double sum = 0.0;
    2678           for (CoinBigIndex j = columnStart[iColumn];
    2679                j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    2680             if (iRow == row[j]) {
    2681               value = element[j];
    2682             } else {
    2683               sum += ray[row[j]]*element[j];
    2684             }
    2685           }
    2686           ray[iRow] = -sum / value;
    2687         }
    2688       }
    2689       for (int i=0;i<modelPtr_->numberColumns_;i++) {
    2690         if (modelPtr_->getStatus(i)!=ClpSimplex::basic&&
    2691             modelPtr_->columnLower_[i]==modelPtr_->columnUpper_[i])
    2692           modelPtr_->setStatus(i,ClpSimplex::isFixed);
    2693       }
    2694       modelPtr_->ray_=ray;
     2654        int iRow = whichRow[jRow];
     2655        int iColumn = whichRow[jRow + numberRows];
     2656        if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
     2657          double value = 0.0;
     2658          double sum = 0.0;
     2659          for (CoinBigIndex j = columnStart[iColumn];
     2660               j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     2661            if (iRow == row[j]) {
     2662              value = element[j];
     2663            } else {
     2664              sum += ray[row[j]] * element[j];
     2665            }
     2666          }
     2667          ray[iRow] = -sum / value;
     2668        }
     2669      }
     2670      for (int i = 0; i < modelPtr_->numberColumns_; i++) {
     2671        if (modelPtr_->getStatus(i) != ClpSimplex::basic && modelPtr_->columnLower_[i] == modelPtr_->columnUpper_[i])
     2672          modelPtr_->setStatus(i, ClpSimplex::isFixed);
     2673      }
     2674      modelPtr_->ray_ = ray;
    26952675      //delete [] smallModel_->ray_;
    26962676      //smallModel_->ray_=NULL;
    2697       modelPtr_->directionOut_=smallModel_->directionOut_;
    2698       lastAlgorithm_=2; // dual
     2677      modelPtr_->directionOut_ = smallModel_->directionOut_;
     2678      lastAlgorithm_ = 2; // dual
    26992679    }
    27002680#if 1
    2701     if (status&&!problemStatus) {
    2702       memset(modelPtr_->primalRowSolution(),0,numberRows*sizeof(double));
    2703       modelPtr_->clpMatrix()->times(1.0,solution,modelPtr_->primalRowSolution());
     2681    if (status && !problemStatus) {
     2682      memset(modelPtr_->primalRowSolution(), 0, numberRows * sizeof(double));
     2683      modelPtr_->clpMatrix()->times(1.0, solution, modelPtr_->primalRowSolution());
    27042684      modelPtr_->checkSolutionInternal();
    27052685      //modelPtr_->setLogLevel(1);
     
    27092689      //modelPtr_->clpMatrix()->times(1.0,solution,modelPtr_->primalRowSolution());
    27102690      //modelPtr_->checkSolutionInternal();
    2711       assert (!modelPtr_->problemStatus());
     2691      assert(!modelPtr_->problemStatus());
    27122692    }
    27132693#endif
    27142694    modelPtr_->setNumberIterations(smallModel_->numberIterations());
    27152695    // and back bounds
    2716     CoinMemcpyN(saveLower,number,smallModel_->lowerRegion());
    2717     CoinMemcpyN(saveUpper,number,smallModel_->upperRegion());
     2696    CoinMemcpyN(saveLower, number, smallModel_->lowerRegion());
     2697    CoinMemcpyN(saveUpper, number, smallModel_->upperRegion());
    27182698  }
    27192699  if (savedObjective) {
    27202700    // fix up
    2721     modelPtr_->dblParam_[ClpDualObjectiveLimit]=savedDualLimit;
     2701    modelPtr_->dblParam_[ClpDualObjectiveLimit] = savedDualLimit;
    27222702    //modelPtr_->setMoreSpecialOptions(modelPtr_->moreSpecialOptions()&(~32));
    2723     modelPtr_->objective_=savedObjective;
     2703    modelPtr_->objective_ = savedObjective;
    27242704    if (!modelPtr_->problemStatus_) {
    2725       CoinZeroN(modelPtr_->dual_,modelPtr_->numberRows_);
    2726       CoinZeroN(modelPtr_->reducedCost_,modelPtr_->numberColumns_);
    2727       if (modelPtr_->dj_&&(modelPtr_->whatsChanged_&1)!=0)
    2728         CoinZeroN(modelPtr_->dj_,modelPtr_->numberColumns_+modelPtr_->numberRows_);
     2705      CoinZeroN(modelPtr_->dual_, modelPtr_->numberRows_);
     2706      CoinZeroN(modelPtr_->reducedCost_, modelPtr_->numberColumns_);
     2707      if (modelPtr_->dj_ && (modelPtr_->whatsChanged_ & 1) != 0)
     2708        CoinZeroN(modelPtr_->dj_, modelPtr_->numberColumns_ + modelPtr_->numberRows_);
    27292709      modelPtr_->computeObjectiveValue();
    27302710    }
    27312711  }
    2732   modelPtr_->setIntParam(ClpMaxNumIteration,itlimOrig_);
     2712  modelPtr_->setIntParam(ClpMaxNumIteration, itlimOrig_);
    27332713}
    27342714
     
    27362716{
    27372717#ifdef CLEAN_HOT_START
    2738   if ((specialOptions_&65536)!=0) {
     2718  if ((specialOptions_ & 65536) != 0) {
    27392719    modelPtr_->setLogLevel(saveData_.scalingFlag_);
    27402720    modelPtr_->deleteRim(0);
    2741     if (lastNumberRows_<0) {
     2721    if (lastNumberRows_ < 0) {
    27422722      specialOptions_ |= 131072;
    2743       lastNumberRows_ = -1 -lastNumberRows_;
     2723      lastNumberRows_ = -1 - lastNumberRows_;
    27442724      if (modelPtr_->rowScale_) {
    2745         if (modelPtr_->rowScale_!=rowScale_.array()) {
    2746           delete [] modelPtr_->rowScale_;
    2747           delete [] modelPtr_->columnScale_;
    2748         }
    2749         modelPtr_->rowScale_=NULL;
    2750         modelPtr_->columnScale_=NULL;
     2725        if (modelPtr_->rowScale_ != rowScale_.array()) {
     2726          delete[] modelPtr_->rowScale_;
     2727          delete[] modelPtr_->columnScale_;
     2728        }
     2729        modelPtr_->rowScale_ = NULL;
     2730        modelPtr_->columnScale_ = NULL;
    27512731      }
    27522732    }
    27532733    delete factorization_;
    2754     delete [] spareArrays_;
    2755     smallModel_=NULL;
    2756     spareArrays_=NULL;
    2757     factorization_=NULL;
    2758     delete [] rowActivity_;
    2759     delete [] columnActivity_;
    2760     rowActivity_=NULL;
    2761     columnActivity_=NULL;
     2734    delete[] spareArrays_;
     2735    smallModel_ = NULL;
     2736    spareArrays_ = NULL;
     2737    factorization_ = NULL;
     2738    delete[] rowActivity_;
     2739    delete[] columnActivity_;
     2740    rowActivity_ = NULL;
     2741    columnActivity_ = NULL;
    27622742    return;
    27632743  }
    27642744#endif
    2765   if (smallModel_==NULL) {
     2745  if (smallModel_ == NULL) {
    27662746    setWarmStart(ws_);
    27672747    int numberRows = modelPtr_->numberRows();
    27682748    int numberColumns = modelPtr_->numberColumns();
    2769     CoinMemcpyN(           rowActivity_,numberRows,modelPtr_->primalRowSolution());
    2770     CoinMemcpyN(columnActivity_,numberColumns,modelPtr_->primalColumnSolution());
     2749    CoinMemcpyN(rowActivity_, numberRows, modelPtr_->primalRowSolution());
     2750    CoinMemcpyN(columnActivity_, numberColumns, modelPtr_->primalColumnSolution());
    27712751    delete ws_;
    27722752    ws_ = NULL;
    27732753  } else {
    27742754#ifndef KEEP_SMALL
    2775     if (smallModel_!=modelPtr_)
     2755    if (smallModel_ != modelPtr_)
    27762756      delete smallModel_;
    2777     smallModel_=NULL;
     2757    smallModel_ = NULL;
    27782758#else
    2779     if (smallModel_==modelPtr_) {
    2780       smallModel_=NULL;
     2759    if (smallModel_ == modelPtr_) {
     2760      smallModel_ = NULL;
    27812761    } else if (smallModel_) {
    2782       if(!spareArrays_) {
    2783         delete smallModel_;
    2784         smallModel_=NULL;
    2785         delete factorization_;
    2786         factorization_=NULL;
     2762      if (!spareArrays_) {
     2763        delete smallModel_;
     2764        smallModel_ = NULL;
     2765        delete factorization_;
     2766        factorization_ = NULL;
    27872767      } else {
    2788         static_cast<ClpSimplexDual *> (smallModel_)->cleanupAfterStrongBranching( factorization_);
    2789         if ((smallModel_->specialOptions_&4096)==0) {
    2790           delete factorization_;
    2791         }
     2768        static_cast< ClpSimplexDual * >(smallModel_)->cleanupAfterStrongBranching(factorization_);
     2769        if ((smallModel_->specialOptions_ & 4096) == 0) {
     2770          delete factorization_;
     2771        }
    27922772      }
    27932773    }
     
    27952775    //delete [] spareArrays_;
    27962776    //spareArrays_=NULL;
    2797     factorization_=NULL;
    2798   }
    2799   delete [] rowActivity_;
    2800   delete [] columnActivity_;
    2801   rowActivity_=NULL;
    2802   columnActivity_=NULL;
     2777    factorization_ = NULL;
     2778  }
     2779  delete[] rowActivity_;
     2780  delete[] columnActivity_;
     2781  rowActivity_ = NULL;
     2782  columnActivity_ = NULL;
    28032783  // Make sure whatsChanged not out of sync
    28042784  if (!modelPtr_->columnUpperWork_)
    28052785    modelPtr_->whatsChanged_ &= ~0xffff;
    2806   modelPtr_->specialOptions_ = saveData_.specialOptions_; 
    2807 }
    2808 
    2809 #ifdef CONFLICT_CUTS 
     2786  modelPtr_->specialOptions_ = saveData_.specialOptions_;
     2787}
     2788
     2789#ifdef CONFLICT_CUTS
    28102790// Return a conflict analysis cut from small model
    2811 OsiRowCut * 
    2812 OsiClpSolverInterface::smallModelCut(const double * originalLower, const double * originalUpper,
    2813                                      int numberRowsAtContinuous,const int * whichGenerator,
    2814                                      int typeCut)
    2815 {
    2816   if(smallModel_&&smallModel_->ray_) {
     2791OsiRowCut *
     2792OsiClpSolverInterface::smallModelCut(const double *originalLower, const double *originalUpper,
     2793  int numberRowsAtContinuous, const int *whichGenerator,
     2794  int typeCut)
     2795{
     2796  if (smallModel_ && smallModel_->ray_) {
    28172797    //printf("Could do small cut\n");
    28182798    int numberRows = modelPtr_->numberRows();
     
    28202800    int numberColumns = modelPtr_->numberColumns();
    28212801    int numberColumns2 = smallModel_->numberColumns();
    2822     double * arrayD = reinterpret_cast<double *> (spareArrays_);
    2823     double * saveSolution = arrayD+1;
    2824     double * saveLower = saveSolution + (numberRows+numberColumns);
    2825     double * saveUpper = saveLower + (numberRows+numberColumns);
    2826     double * saveObjective = saveUpper + (numberRows+numberColumns);
    2827     double * saveLowerOriginal = saveObjective + (numberRows+numberColumns);
    2828     double * saveUpperOriginal = saveLowerOriginal + numberColumns;
     2802    double *arrayD = reinterpret_cast< double * >(spareArrays_);
     2803    double *saveSolution = arrayD + 1;
     2804    double *saveLower = saveSolution + (numberRows + numberColumns);
     2805    double *saveUpper = saveLower + (numberRows + numberColumns);
     2806    double *saveObjective = saveUpper + (numberRows + numberColumns);
     2807    double *saveLowerOriginal = saveObjective + (numberRows + numberColumns);
     2808    double *saveUpperOriginal = saveLowerOriginal + numberColumns;
    28292809    //double * lowerOriginal = modelPtr_->columnLower();
    28302810    //double * upperOriginal = modelPtr_->columnUpper();
    2831     int * savePivot = reinterpret_cast<int *> (saveUpperOriginal + numberColumns);
    2832     int * whichRow = savePivot+numberRows;
    2833     int * whichColumn = whichRow + 3*numberRows;
    2834     int nCopy = 3*numberRows+2*numberColumns;
     2811    int *savePivot = reinterpret_cast< int * >(saveUpperOriginal + numberColumns);
     2812    int *whichRow = savePivot + numberRows;
     2813    int *whichColumn = whichRow + 3 * numberRows;
     2814    int nCopy = 3 * numberRows + 2 * numberColumns;
    28352815    int nBound = whichRow[nCopy];
    2836     if (smallModel_->sequenceOut_>=0&&smallModel_->sequenceOut_<numberColumns2)
     2816    if (smallModel_->sequenceOut_ >= 0 && smallModel_->sequenceOut_ < numberColumns2)
    28372817      modelPtr_->sequenceOut_ = whichColumn[smallModel_->sequenceOut_];
    28382818    else
    2839       modelPtr_->sequenceOut_ = modelPtr_->numberColumns_+whichRow[smallModel_->sequenceOut_];
    2840     unsigned char * saveStatus = CoinCopyOfArray(modelPtr_->status_,
    2841                                                  numberRows+numberColumns);
     2819      modelPtr_->sequenceOut_ = modelPtr_->numberColumns_ + whichRow[smallModel_->sequenceOut_];
     2820    unsigned char *saveStatus = CoinCopyOfArray(modelPtr_->status_,
     2821      numberRows + numberColumns);
    28422822    // get ray to full problem
    28432823    for (int i = 0; i < numberColumns2; i++) {
     
    28452825      modelPtr_->setStatus(iColumn, smallModel_->getStatus(i));
    28462826    }
    2847     double * ray = new double [numberRows+numberColumns2+numberColumns];
    2848     char * mark = new char [numberRows];
    2849     memset(ray,0,(numberRows+numberColumns2+numberColumns)*sizeof(double));
    2850     double * smallFarkas = ray+numberRows;
    2851     double * farkas = smallFarkas+numberColumns2;
    2852     double * saveScale = smallModel_->rowScale_;
    2853     smallModel_->rowScale_=NULL;
    2854     smallModel_->transposeTimes(1.0,smallModel_->ray_,smallFarkas);
    2855     smallModel_->rowScale_=saveScale;
    2856     for (int i=0;i<numberColumns2;i++)
    2857       farkas[whichColumn[i]]=smallFarkas[i];
    2858     memset(mark,0,numberRows);
     2827    double *ray = new double[numberRows + numberColumns2 + numberColumns];
     2828    char *mark = new char[numberRows];
     2829    memset(ray, 0, (numberRows + numberColumns2 + numberColumns) * sizeof(double));
     2830    double *smallFarkas = ray + numberRows;
     2831    double *farkas = smallFarkas + numberColumns2;
     2832    double *saveScale = smallModel_->rowScale_;
     2833    smallModel_->rowScale_ = NULL;
     2834    smallModel_->transposeTimes(1.0, smallModel_->ray_, smallFarkas);
     2835    smallModel_->rowScale_ = saveScale;
     2836    for (int i = 0; i < numberColumns2; i++)
     2837      farkas[whichColumn[i]] = smallFarkas[i];
     2838    memset(mark, 0, numberRows);
    28592839    for (int i = 0; i < numberRows2; i++) {
    28602840      int iRow = whichRow[i];
    28612841      modelPtr_->setRowStatus(iRow, smallModel_->getRowStatus(i));
    28622842      ray[iRow] = smallModel_->ray_[i];
    2863       mark[iRow]=1;
     2843      mark[iRow] = 1;
    28642844    }
    28652845    // Column copy of matrix
    2866     const double * element = getMatrixByCol()->getElements();
    2867     const int * row = getMatrixByCol()->getIndices();
    2868     const CoinBigIndex * columnStart = getMatrixByCol()->getVectorStarts();
    2869     const int * columnLength = getMatrixByCol()->getVectorLengths();
     2846    const double *element = getMatrixByCol()->getElements();
     2847    const int *row = getMatrixByCol()->getIndices();
     2848    const CoinBigIndex *columnStart = getMatrixByCol()->getVectorStarts();
     2849    const int *columnLength = getMatrixByCol()->getVectorLengths();
    28702850    // pick up small pivot row
    28712851    int pivotRow = smallModel_->spareIntArray_[3];
    28722852    // translate
    2873     if (pivotRow>=0)
    2874       pivotRow=whichRow[pivotRow];
    2875     modelPtr_->spareIntArray_[3]=pivotRow;
     2853    if (pivotRow >= 0)
     2854      pivotRow = whichRow[pivotRow];
     2855    modelPtr_->spareIntArray_[3] = pivotRow;
    28762856    for (int jRow = nBound; jRow < 2 * numberRows; jRow++) {
    28772857      int iRow = whichRow[jRow];
    2878       int iColumn = whichRow[jRow+numberRows];
     2858      int iColumn = whichRow[jRow + numberRows];
    28792859      if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
    2880         double value = 0.0;
    2881         double sum = 0.0;
    2882         for (CoinBigIndex j = columnStart[iColumn];
    2883              j < columnStart[iColumn] + columnLength[iColumn]; j++) {
    2884           if (iRow == row[j]) {
    2885             value = element[j];
    2886           } else if (mark[row[j]]) {
    2887             sum += ray[row[j]]*element[j];
    2888           }
    2889         }
    2890         double target=farkas[iColumn];
    2891         if (iRow!=pivotRow) {
    2892           ray[iRow] = (target-sum) / value;
    2893         } else {
    2894           printf("what now - direction %d wanted %g sum %g value %g\n",
    2895                  smallModel_->directionOut_,ray[iRow],
    2896                  sum,value);
    2897         }
    2898         mark[iRow]=1;
    2899       }
    2900     }
    2901     delete [] mark;
    2902     for (int i=0;i<modelPtr_->numberColumns_;i++) {
    2903       if (modelPtr_->getStatus(i)!=ClpSimplex::basic&&
    2904           modelPtr_->columnLower_[i]==modelPtr_->columnUpper_[i])
    2905         modelPtr_->setStatus(i,ClpSimplex::isFixed);
     2860        double value = 0.0;
     2861        double sum = 0.0;
     2862        for (CoinBigIndex j = columnStart[iColumn];
     2863             j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     2864          if (iRow == row[j]) {
     2865            value = element[j];
     2866          } else if (mark[row[j]]) {
     2867            sum += ray[row[j]] * element[j];
     2868          }
     2869        }
     2870        double target = farkas[iColumn];
     2871        if (iRow != pivotRow) {
     2872          ray[iRow] = (target - sum) / value;
     2873        } else {
     2874          printf("what now - direction %d wanted %g sum %g value %g\n",
     2875            smallModel_->directionOut_, ray[iRow],
     2876            sum, value);
     2877        }
     2878        mark[iRow] = 1;
     2879      }
     2880    }
     2881    delete[] mark;
     2882    for (int i = 0; i < modelPtr_->numberColumns_; i++) {
     2883      if (modelPtr_->getStatus(i) != ClpSimplex::basic && modelPtr_->columnLower_[i] == modelPtr_->columnUpper_[i])
     2884        modelPtr_->setStatus(i, ClpSimplex::isFixed);
    29062885    }
    29072886#if 0
     
    30253004    }
    30263005#endif
    3027     modelPtr_->ray_=ray;
    3028     lastAlgorithm_=2;
    3029     modelPtr_->directionOut_=smallModel_->directionOut_;
    3030     OsiRowCut * cut = modelCut(originalLower,originalUpper,
    3031                                numberRowsAtContinuous,whichGenerator,typeCut);
     3006    modelPtr_->ray_ = ray;
     3007    lastAlgorithm_ = 2;
     3008    modelPtr_->directionOut_ = smallModel_->directionOut_;
     3009    OsiRowCut *cut = modelCut(originalLower, originalUpper,
     3010      numberRowsAtContinuous, whichGenerator, typeCut);
    30323011    smallModel_->deleteRay();
    3033     memcpy(modelPtr_->status_,saveStatus,numberRows+numberColumns);
    3034     delete [] saveStatus;
     3012    memcpy(modelPtr_->status_, saveStatus, numberRows + numberColumns);
     3013    delete[] saveStatus;
    30353014    if (cut) {
    30363015      //printf("got small cut\n");
     
    30433022  }
    30443023}
    3045 static int debugMode=0;
     3024static int debugMode = 0;
    30463025// Return a conflict analysis cut from model
    30473026//      If type is 0 then genuine cut, if 1 then only partially processed
    3048 OsiRowCut * 
    3049 OsiClpSolverInterface::modelCut(const double * originalLower, const double * originalUpper,
    3050                                 int numberRowsAtContinuous,const int * whichGenerator,
    3051                                 int typeCut)
    3052 {
    3053   OsiRowCut * cut=NULL;
     3027OsiRowCut *
     3028OsiClpSolverInterface::modelCut(const double *originalLower, const double *originalUpper,
     3029  int numberRowsAtContinuous, const int *whichGenerator,
     3030  int typeCut)
     3031{
     3032  OsiRowCut *cut = NULL;
    30543033  //return NULL;
    3055   if(modelPtr_->ray_) {
    3056     if (lastAlgorithm_==2) {
     3034  if (modelPtr_->ray_) {
     3035    if (lastAlgorithm_ == 2) {
    30573036      //printf("Could do normal cut\n");
    30583037      // could use existing arrays
    3059       int numberRows=modelPtr_->numberRows_;
    3060       int numberColumns=modelPtr_->numberColumns_;
    3061       double * farkas = new double [2*numberColumns+numberRows];
    3062       double * bound = farkas + numberColumns;
    3063       double * effectiveRhs = bound + numberColumns;
    3064       /*const*/ double * ray = modelPtr_->ray_;
     3038      int numberRows = modelPtr_->numberRows_;
     3039      int numberColumns = modelPtr_->numberColumns_;
     3040      double *farkas = new double[2 * numberColumns + numberRows];
     3041      double *bound = farkas + numberColumns;
     3042      double *effectiveRhs = bound + numberColumns;
     3043      /*const*/ double *ray = modelPtr_->ray_;
    30653044      // have to get rid of local cut rows
    30663045      whichGenerator -= numberRowsAtContinuous;
    3067       int badRows=0;
    3068       for (int iRow=numberRowsAtContinuous;iRow<numberRows;iRow++) {
    3069         int iType=whichGenerator[iRow];
    3070         if ((iType>=0&&iType<20000)) {
    3071           if (fabs(ray[iRow])>1.0e-10) {
    3072             badRows++;
    3073           }
    3074           ray[iRow]=0.0;
    3075         }
     3046      int badRows = 0;
     3047      for (int iRow = numberRowsAtContinuous; iRow < numberRows; iRow++) {
     3048        int iType = whichGenerator[iRow];
     3049        if ((iType >= 0 && iType < 20000)) {
     3050          if (fabs(ray[iRow]) > 1.0e-10) {
     3051            badRows++;
     3052          }
     3053          ray[iRow] = 0.0;
     3054        }
    30763055      }
    30773056      ClpSimplex debugModel;
    3078       if ((debugMode&4)!=0)
    3079         debugModel = *modelPtr_;
    3080       if (badRows&&(debugMode&1)!=0)
    3081         printf("%d rows from local cuts\n",badRows);
     3057      if ((debugMode & 4) != 0)
     3058        debugModel = *modelPtr_;
     3059      if (badRows && (debugMode & 1) != 0)
     3060        printf("%d rows from local cuts\n", badRows);
    30823061      // get farkas row
    3083       ClpPackedMatrix * saveMatrix = modelPtr_->scaledMatrix_;
    3084       double * saveScale = modelPtr_->rowScale_;
    3085       modelPtr_->rowScale_=NULL;
    3086       modelPtr_->scaledMatrix_=NULL;
    3087       memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
    3088       modelPtr_->transposeTimes(-1.0,ray,farkas);
     3062      ClpPackedMatrix *saveMatrix = modelPtr_->scaledMatrix_;
     3063      double *saveScale = modelPtr_->rowScale_;
     3064      modelPtr_->rowScale_ = NULL;
     3065      modelPtr_->scaledMatrix_ = NULL;
     3066      memset(farkas, 0, (2 * numberColumns + numberRows) * sizeof(double));
     3067      modelPtr_->transposeTimes(-1.0, ray, farkas);
    30893068      //const char * integerInformation = modelPtr_->integerType_;
    30903069      //assert (integerInformation);
     
    30923071      int sequenceOut = modelPtr_->sequenceOut_;
    30933072      // Put nonzero bounds in bound
    3094       const double * columnLower = modelPtr_->columnLower_;
    3095       const double * columnUpper = modelPtr_->columnUpper_;
    3096       const double * columnValue = modelPtr_->columnActivity_;
    3097       int numberBad=0;
    3098       int nNonzeroBasic=0;
    3099       for (int i=0;i<numberColumns;i++) {
    3100         double value = farkas[i];
    3101         double boundValue=0.0;
    3102         if (modelPtr_->getStatus(i)==ClpSimplex::basic) {
    3103           // treat as zero if small
    3104           if (fabs(value)<1.0e-8) {
    3105             value=0.0;
    3106             farkas[i]=0.0;
    3107           }
    3108           if (value) {
    3109             //printf("basic %d direction %d farkas %g\n",
    3110             //i,modelPtr_->directionOut_,value);
    3111             nNonzeroBasic++;
    3112             if (value<0.0)
    3113               boundValue=columnLower[i];
    3114             else
    3115               boundValue=columnUpper[i];
    3116           }
    3117         } else if (fabs(value)>1.0e-10) {
    3118           if (value<0.0) {
    3119             if (columnValue[i]>columnLower[i]+1.0e-5&&value<-1.0e-7) {
    3120               //printf("bad %d alpha %g not at lower\n",i,value);
    3121               numberBad++;
    3122             }
    3123             boundValue=columnLower[i];
    3124           } else {
    3125             if (columnValue[i]<columnUpper[i]-1.0e-5&&value>1.0e-7) {
    3126               //printf("bad %d alpha %g not at upper\n",i,value);
    3127               numberBad++;
    3128             }
    3129             boundValue=columnUpper[i];
    3130           }
    3131         }
    3132         bound[i]=boundValue;
    3133         if (fabs(boundValue)>1.0e10)
    3134           numberBad++;
    3135       }
    3136       const double * rowLower = modelPtr_->rowLower_;
    3137       const double * rowUpper = modelPtr_->rowUpper_;
     3073      const double *columnLower = modelPtr_->columnLower_;
     3074      const double *columnUpper = modelPtr_->columnUpper_;
     3075      const double *columnValue = modelPtr_->columnActivity_;
     3076      int numberBad = 0;
     3077      int nNonzeroBasic = 0;
     3078      for (int i = 0; i < numberColumns; i++) {
     3079        double value = farkas[i];
     3080        double boundValue = 0.0;
     3081        if (modelPtr_->getStatus(i) == ClpSimplex::basic) {
     3082          // treat as zero if small
     3083          if (fabs(value) < 1.0e-8) {
     3084            value = 0.0;
     3085            farkas[i] = 0.0;
     3086          }
     3087          if (value) {
     3088            //printf("basic %d direction %d farkas %g\n",
     3089            //i,modelPtr_->directionOut_,value);
     3090            nNonzeroBasic++;
     3091            if (value < 0.0)
     3092              boundValue = columnLower[i];
     3093            else
     3094              boundValue = columnUpper[i];
     3095          }
     3096        } else if (fabs(value) > 1.0e-10) {
     3097          if (value < 0.0) {
     3098            if (columnValue[i] > columnLower[i] + 1.0e-5 && value < -1.0e-7) {
     3099              //printf("bad %d alpha %g not at lower\n",i,value);
     3100              numberBad++;
     3101            }
     3102            boundValue = columnLower[i];
     3103          } else {
     3104            if (columnValue[i] < columnUpper[i] - 1.0e-5 && value > 1.0e-7) {
     3105              //printf("bad %d alpha %g not at upper\n",i,value);
     3106              numberBad++;
     3107            }
     3108            boundValue = columnUpper[i];
     3109          }
     3110        }
     3111        bound[i] = boundValue;
     3112        if (fabs(boundValue) > 1.0e10)
     3113          numberBad++;
     3114      }
     3115      const double *rowLower = modelPtr_->rowLower_;
     3116      const double *rowUpper = modelPtr_->rowUpper_;
    31383117      //int pivotRow = modelPtr_->spareIntArray_[3];
    31393118      //bool badPivot=pivotRow<0;
    3140       for (int i=0;i<numberRows;i++) {
    3141         double value = ray[i];
    3142         double rhsValue=0.0;
    3143         if (modelPtr_->getRowStatus(i)==ClpSimplex::basic) {
    3144           // treat as zero if small
    3145           if (fabs(value)<1.0e-8) {
    3146             value=0.0;
    3147             ray[i]=0.0;
    3148           }
    3149           if (value) {
    3150             //printf("row basic %d direction %d ray %g\n",
    3151             //     i,modelPtr_->directionOut_,value);
    3152             nNonzeroBasic++;
    3153             if (value<0.0)
    3154               rhsValue=rowLower[i];
    3155             else
    3156               rhsValue=rowUpper[i];
    3157           }
    3158         } else if (fabs(value)>1.0e-10) {
    3159           if (value<0.0)
    3160             rhsValue=rowLower[i];
    3161           else
    3162             rhsValue=rowUpper[i];
    3163         }
    3164         effectiveRhs[i]=rhsValue;
     3119      for (int i = 0; i < numberRows; i++) {
     3120        double value = ray[i];
     3121        double rhsValue = 0.0;
     3122        if (modelPtr_->getRowStatus(i) == ClpSimplex::basic) {
     3123          // treat as zero if small
     3124          if (fabs(value) < 1.0e-8) {
     3125            value = 0.0;
     3126            ray[i] = 0.0;
     3127          }
     3128          if (value) {
     3129            //printf("row basic %d direction %d ray %g\n",
     3130            //     i,modelPtr_->directionOut_,value);
     3131            nNonzeroBasic++;
     3132            if (value < 0.0)
     3133              rhsValue = rowLower[i];
     3134            else
     3135              rhsValue = rowUpper[i];
     3136          }
     3137        } else if (fabs(value) > 1.0e-10) {
     3138          if (value < 0.0)
     3139            rhsValue = rowLower[i];
     3140          else
     3141            rhsValue = rowUpper[i];
     3142        }
     3143        effectiveRhs[i] = rhsValue;
    31653144      }
    31663145      {
    3167         double bSum=0.0;
    3168         for (int i=0;i<numberRows;i++) {
    3169           bSum += effectiveRhs[i]*ray[i];
    3170         }
    3171         //printf("before bounds - bSum %g\n",bSum);
    3172       }
    3173       modelPtr_->times(-1.0,bound,effectiveRhs);
    3174       double bSum=0.0;
    3175       for (int i=0;i<numberRows;i++) {
    3176         bSum += effectiveRhs[i]*ray[i];
     3146        double bSum = 0.0;
     3147        for (int i = 0; i < numberRows; i++) {
     3148          bSum += effectiveRhs[i] * ray[i];
     3149        }
     3150        //printf("before bounds - bSum %g\n",bSum);
     3151      }
     3152      modelPtr_->times(-1.0, bound, effectiveRhs);
     3153      double bSum = 0.0;
     3154      for (int i = 0; i < numberRows; i++) {
     3155        bSum += effectiveRhs[i] * ray[i];
    31773156      }
    31783157#if 0
     
    32153194#endif
    32163195#endif
    3217       modelPtr_->scaledMatrix_=saveMatrix;
    3218       modelPtr_->rowScale_=saveScale;
    3219       if (numberBad||bSum>-1.0e-4/*||nNonzeroBasic>1*/ /*||bSum2>-1.0e-4*/) {
    3220 #if PRINT_CONFLICT>1 //ndef NDEBUG
    3221         printf("bad BOUND bSum %g (bSum2 %g) - %d bad - %d basic\n",
    3222                bSum,bSum2,numberBad,nNonzeroBasic);
     3196      modelPtr_->scaledMatrix_ = saveMatrix;
     3197      modelPtr_->rowScale_ = saveScale;
     3198      if (numberBad || bSum > -1.0e-4 /*||nNonzeroBasic>1*/ /*||bSum2>-1.0e-4*/) {
     3199#if PRINT_CONFLICT > 1 //ndef NDEBUG
     3200        printf("bad BOUND bSum %g (bSum2 %g) - %d bad - %d basic\n",
     3201          bSum, bSum2, numberBad, nNonzeroBasic);
    32233202#endif
    32243203      } else {
    3225         if (numberColumns<0)
    3226           debugMode=-numberColumns;
    3227         if ((debugMode&4)!=0) {
    3228           int * tempC = new int[numberColumns];
    3229           double * temp = new double[numberColumns];
    3230           int n=0;
    3231           for (int i=0;i<numberColumns;i++) {
    3232             if (fabs(farkas[i])>1.0e-12) {
    3233               temp[n]=farkas[i];
    3234               tempC[n++]=i;
    3235             }
    3236           }
    3237           debugModel.addRow(n,tempC,temp,bSum,bSum);
    3238           delete [] tempC;
    3239           delete [] temp;
    3240         }
    3241         if ((debugMode&2)!=0) {
    3242           ClpSimplex dual=*modelPtr_;
    3243           dual.setLogLevel(63);
    3244           dual.scaling(0);
    3245           dual.dual();
    3246           assert (dual.problemStatus_==1);
    3247           if (dual.ray_) {
    3248             double * farkas2 = dual.reducedCost_;
    3249             // Put nonzero bounds in farkas
    3250             const double * columnLower = dual.columnLower_;
    3251             const double * columnUpper = dual.columnUpper_;
    3252             for (int i=0;i<numberColumns;i++) {
    3253               farkas2[i]=0.0;
    3254               if (dual.getStatus(i)==ClpSimplex::atLowerBound||
    3255                   columnLower[i]==columnUpper[i]) {
    3256                 farkas2[i]=columnLower[i];
    3257               } else if (dual.getStatus(i)==ClpSimplex::atUpperBound) {
    3258                 farkas2[i]=columnUpper[i];
    3259               } else if (i==dual.sequenceOut_) {
    3260                 if (dual.directionOut_<0) {
    3261                   // above upper bound
    3262                   farkas2[i]=columnUpper[i];
    3263                 } else {
    3264                   // below lower bound
    3265                   farkas2[i]=columnLower[i];
    3266                 }
    3267               } else if (columnLower[i]==columnUpper[i]) {
    3268                 farkas2[i]=columnLower[i];
    3269               }
    3270             }
    3271             double * effectiveRhs2 = dual.rowActivity_;
    3272             const double * rowLower = dual.rowLower_;
    3273             const double * rowUpper = dual.rowUpper_;
    3274             int pivotRow = dual.spareIntArray_[3];
    3275             for (int i=0;i<numberRows;i++) {
    3276               if (dual.getRowStatus(i)==ClpSimplex::atLowerBound||
    3277                   rowUpper[i]==rowLower[i]||
    3278                   dual.getRowStatus(i)==ClpSimplex::isFixed) {
    3279                 effectiveRhs2[i]=rowLower[i];
    3280               } else if (dual.getRowStatus(i)==ClpSimplex::atUpperBound) {
    3281                 effectiveRhs2[i]=rowUpper[i];
    3282               } else {
    3283                 if (dual.getRowStatus(i)!=ClpSimplex::basic) {
    3284                   assert (rowUpper[i]>1.0e30||rowLower[i]<-1.0e30); // eventually skip
    3285                   if (rowUpper[i]<1.0e30)
    3286                     effectiveRhs2[i]=rowUpper[i];
    3287                   else
    3288                     effectiveRhs2[i]=rowLower[i];
    3289                 }
    3290               }
    3291               if (dual.getRowStatus(i)==ClpSimplex::basic) {
    3292                 effectiveRhs2[i]=0.0;
    3293                 // we should leave pivot row in and use direction for bound
    3294                 if (fabs(dual.ray_[i])>1.0e-8) {
    3295                   printf("Basic slack value %g on %d - pivotRow %d\n",ray[i],i,pivotRow);
    3296                   if (i==pivotRow) {
    3297                     if (dual.directionOut_<0)
    3298                       effectiveRhs[i]=rowUpper[i];
    3299                     else
    3300                       effectiveRhs[i]=rowLower[i];
    3301                   } else {
    3302                     dual.ray_[i]=0.0;
    3303                   }
    3304                 }
    3305               }
    3306             }
    3307             dual.times(-1.0,farkas2,effectiveRhs2);
    3308             double bSum2=0.0;
    3309             for (int i=0;i<numberRows;i++) {
    3310               bSum2 += effectiveRhs2[i]*dual.ray_[i];
    3311             }
    3312             printf("Alternate bSum %g\n",bSum2);
    3313             memset(farkas2,0,numberColumns*sizeof(double));
    3314             dual.transposeTimes(-1.0,dual.ray_,farkas2);
    3315             int nBad=0;
    3316             double largest=-1.0;
    3317             double smallest=1.0e30;
    3318             for (int i=0;i<numberColumns;i++) {
    3319               //if (fabs(farkas[i])>1.0e-12)
    3320               //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
    3321               if (fabs(farkas[i]-farkas2[i])>1.0e-7) {
    3322                 nBad++;
    3323                 largest=CoinMax(largest,fabs(farkas[i]-farkas2[i]));
    3324                 smallest=CoinMin(smallest,fabs(farkas[i]-farkas2[i]));
    3325                 //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
    3326               }
    3327             }
    3328             if (nBad)
    3329               printf("%d farkas difference %g to %g\n",nBad,smallest,largest);
    3330             dual.primal();
    3331             assert (dual.problemStatus_==1);
    3332             assert (!nBad);
    3333           }
    3334         }
    3335         const char * integerInformation = modelPtr_->integerType_;
    3336         assert (integerInformation);
    3337         int * conflict = new int[numberColumns];
    3338         double * sort = new double [numberColumns];
    3339         double relax=0.0;
    3340         int nConflict=0;
    3341         int nOriginal=0;
    3342         int nFixed=0;
    3343         for (int iColumn=0;iColumn<numberColumns;iColumn++) {
    3344           double thisRelax = 0.0;
    3345           if (integerInformation[iColumn]) {
    3346             if ((debugMode&1)!=0)
    3347             printf("%d status %d %g <= %g <=%g (orig %g, %g) farkas %g\n",
    3348                    iColumn,modelPtr_->getStatus(iColumn),columnLower[iColumn],
    3349                    modelPtr_->columnActivity_[iColumn],columnUpper[iColumn],
    3350                    originalLower[iColumn],originalUpper[iColumn],
    3351                    farkas[iColumn]);
    3352             double gap = originalUpper[iColumn]-originalLower[iColumn];
    3353             if (!gap)
    3354               continue;
    3355             if (gap==columnUpper[iColumn]-columnLower[iColumn])
    3356               nOriginal++;
    3357             if (columnUpper[iColumn]==columnLower[iColumn])
    3358               nFixed++;
    3359             if (fabs(farkas[iColumn])<1.0e-15) {
    3360               farkas[iColumn]=0.0;
    3361               continue;
    3362             }
    3363             // temp
    3364             if (gap>=20000.0&&false) {
    3365               // can't use
    3366               if (farkas[iColumn]<0.0) {
    3367                 assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
    3368                 // farkas is negative - relax lower bound all way
    3369                 relax +=
    3370                   farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
    3371               } else {
    3372                 assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
    3373                 // farkas is positive - relax upper bound all way
    3374                 relax +=
    3375                   farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
    3376               }
    3377               continue;
    3378             }
    3379             if (originalLower[iColumn]==columnLower[iColumn]) {
    3380               // may need to be careful if odd basic (due to local cut)
    3381               if (farkas[iColumn]>0.0/*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atUpperBound
     3204        if (numberColumns < 0)
     3205          debugMode = -numberColumns;
     3206        if ((debugMode & 4) != 0) {
     3207          int *tempC = new int[numberColumns];
     3208          double *temp = new double[numberColumns];
     3209          int n = 0;
     3210          for (int i = 0; i < numberColumns; i++) {
     3211            if (fabs(farkas[i]) > 1.0e-12) {
     3212              temp[n] = farkas[i];
     3213              tempC[n++] = i;
     3214            }
     3215          }
     3216          debugModel.addRow(n, tempC, temp, bSum, bSum);
     3217          delete[] tempC;
     3218          delete[] temp;
     3219        }
     3220        if ((debugMode & 2) != 0) {
     3221          ClpSimplex dual = *modelPtr_;
     3222          dual.setLogLevel(63);
     3223          dual.scaling(0);
     3224          dual.dual();
     3225          assert(dual.problemStatus_ == 1);
     3226          if (dual.ray_) {
     3227            double *farkas2 = dual.reducedCost_;
     3228            // Put nonzero bounds in farkas
     3229            const double *columnLower = dual.columnLower_;
     3230            const double *columnUpper = dual.columnUpper_;
     3231            for (int i = 0; i < numberColumns; i++) {
     3232              farkas2[i] = 0.0;
     3233              if (dual.getStatus(i) == ClpSimplex::atLowerBound || columnLower[i] == columnUpper[i]) {
     3234                farkas2[i] = columnLower[i];
     3235              } else if (dual.getStatus(i) == ClpSimplex::atUpperBound) {
     3236                farkas2[i] = columnUpper[i];
     3237              } else if (i == dual.sequenceOut_) {
     3238                if (dual.directionOut_ < 0) {
     3239                  // above upper bound
     3240                  farkas2[i] = columnUpper[i];
     3241                } else {
     3242                  // below lower bound
     3243                  farkas2[i] = columnLower[i];
     3244                }
     3245              } else if (columnLower[i] == columnUpper[i]) {
     3246                farkas2[i] = columnLower[i];
     3247              }
     3248            }
     3249            double *effectiveRhs2 = dual.rowActivity_;
     3250            const double *rowLower = dual.rowLower_;
     3251            const double *rowUpper = dual.rowUpper_;
     3252            int pivotRow = dual.spareIntArray_[3];
     3253            for (int i = 0; i < numberRows; i++) {
     3254              if (dual.getRowStatus(i) == ClpSimplex::atLowerBound || rowUpper[i] == rowLower[i] || dual.getRowStatus(i) == ClpSimplex::isFixed) {
     3255                effectiveRhs2[i] = rowLower[i];
     3256              } else if (dual.getRowStatus(i) == ClpSimplex::atUpperBound) {
     3257                effectiveRhs2[i] = rowUpper[i];
     3258              } else {
     3259                if (dual.getRowStatus(i) != ClpSimplex::basic) {
     3260                  assert(rowUpper[i] > 1.0e30 || rowLower[i] < -1.0e30); // eventually skip
     3261                  if (rowUpper[i] < 1.0e30)
     3262                    effectiveRhs2[i] = rowUpper[i];
     3263                  else
     3264                    effectiveRhs2[i] = rowLower[i];
     3265                }
     3266              }
     3267              if (dual.getRowStatus(i) == ClpSimplex::basic) {
     3268                effectiveRhs2[i] = 0.0;
     3269                // we should leave pivot row in and use direction for bound
     3270                if (fabs(dual.ray_[i]) > 1.0e-8) {
     3271                  printf("Basic slack value %g on %d - pivotRow %d\n", ray[i], i, pivotRow);
     3272                  if (i == pivotRow) {
     3273                    if (dual.directionOut_ < 0)
     3274                      effectiveRhs[i] = rowUpper[i];
     3275                    else
     3276                      effectiveRhs[i] = rowLower[i];
     3277                  } else {
     3278                    dual.ray_[i] = 0.0;
     3279                  }
     3280                }
     3281              }
     3282            }
     3283            dual.times(-1.0, farkas2, effectiveRhs2);
     3284            double bSum2 = 0.0;
     3285            for (int i = 0; i < numberRows; i++) {
     3286              bSum2 += effectiveRhs2[i] * dual.ray_[i];
     3287            }
     3288            printf("Alternate bSum %g\n", bSum2);
     3289            memset(farkas2, 0, numberColumns * sizeof(double));
     3290            dual.transposeTimes(-1.0, dual.ray_, farkas2);
     3291            int nBad = 0;
     3292            double largest = -1.0;
     3293            double smallest = 1.0e30;
     3294            for (int i = 0; i < numberColumns; i++) {
     3295              //if (fabs(farkas[i])>1.0e-12)
     3296              //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
     3297              if (fabs(farkas[i] - farkas2[i]) > 1.0e-7) {
     3298                nBad++;
     3299                largest = CoinMax(largest, fabs(farkas[i] - farkas2[i]));
     3300                smallest = CoinMin(smallest, fabs(farkas[i] - farkas2[i]));
     3301                //printf("%d ptr farkas %g dual farkas %g\n",i,farkas[i],farkas2[i]);
     3302              }
     3303            }
     3304            if (nBad)
     3305              printf("%d farkas difference %g to %g\n", nBad, smallest, largest);
     3306            dual.primal();
     3307            assert(dual.problemStatus_ == 1);
     3308            assert(!nBad);
     3309          }
     3310        }
     3311        const char *integerInformation = modelPtr_->integerType_;
     3312        assert(integerInformation);
     3313        int *conflict = new int[numberColumns];
     3314        double *sort = new double[numberColumns];
     3315        double relax = 0.0;
     3316        int nConflict = 0;
     3317        int nOriginal = 0;
     3318        int nFixed = 0;
     3319        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     3320          double thisRelax = 0.0;
     3321          if (integerInformation[iColumn]) {
     3322            if ((debugMode & 1) != 0)
     3323              printf("%d status %d %g <= %g <=%g (orig %g, %g) farkas %g\n",
     3324                iColumn, modelPtr_->getStatus(iColumn), columnLower[iColumn],
     3325                modelPtr_->columnActivity_[iColumn], columnUpper[iColumn],
     3326                originalLower[iColumn], originalUpper[iColumn],
     3327                farkas[iColumn]);
     3328            double gap = originalUpper[iColumn] - originalLower[iColumn];
     3329            if (!gap)
     3330              continue;
     3331            if (gap == columnUpper[iColumn] - columnLower[iColumn])
     3332              nOriginal++;
     3333            if (columnUpper[iColumn] == columnLower[iColumn])
     3334              nFixed++;
     3335            if (fabs(farkas[iColumn]) < 1.0e-15) {
     3336              farkas[iColumn] = 0.0;
     3337              continue;
     3338            }
     3339            // temp
     3340            if (gap >= 20000.0 && false) {
     3341              // can't use
     3342              if (farkas[iColumn] < 0.0) {
     3343                assert(originalLower[iColumn] - columnLower[iColumn] <= 0.0);
     3344                // farkas is negative - relax lower bound all way
     3345                relax += farkas[iColumn] * (originalLower[iColumn] - columnLower[iColumn]);
     3346              } else {
     3347                assert(originalUpper[iColumn] - columnUpper[iColumn] >= 0.0);
     3348                // farkas is positive - relax upper bound all way
     3349                relax += farkas[iColumn] * (originalUpper[iColumn] - columnUpper[iColumn]);
     3350              }
     3351              continue;
     3352            }
     3353            if (originalLower[iColumn] == columnLower[iColumn]) {
     3354              // may need to be careful if odd basic (due to local cut)
     3355              if (farkas[iColumn] > 0.0 /*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atUpperBound
    33823356                                        ||modelPtr_->getStatus(iColumn)==ClpSimplex::isFixed
    3383                                         ||iColumn==sequenceOut)*/) {
    3384                 // farkas is positive - add to list
    3385                 gap=originalUpper[iColumn]-columnUpper[iColumn];
    3386                 if (gap) {
    3387                   sort[nConflict]=-farkas[iColumn]*gap;
    3388                   conflict[nConflict++]=iColumn;
    3389                 }
    3390                 //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
    3391               }
    3392             } else if (originalUpper[iColumn]==columnUpper[iColumn]) {
    3393               // may need to be careful if odd basic (due to local cut)
    3394               if (farkas[iColumn]<0.0/*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atLowerBound
     3357                                        ||iColumn==sequenceOut)*/
     3358              ) {
     3359                // farkas is positive - add to list
     3360                gap = originalUpper[iColumn] - columnUpper[iColumn];
     3361                if (gap) {
     3362                  sort[nConflict] = -farkas[iColumn] * gap;
     3363                  conflict[nConflict++] = iColumn;
     3364                }
     3365                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
     3366              }
     3367            } else if (originalUpper[iColumn] == columnUpper[iColumn]) {
     3368              // may need to be careful if odd basic (due to local cut)
     3369              if (farkas[iColumn] < 0.0 /*&&(modelPtr_->getStatus(iColumn)==ClpSimplex::atLowerBound
    33953370                                        ||modelPtr_->getStatus(iColumn)==ClpSimplex::isFixed
    3396                                         ||iColumn==sequenceOut)*/) {
    3397                 // farkas is negative - add to list
    3398                 gap=columnLower[iColumn]-originalLower[iColumn];
    3399                 if (gap) {
    3400                   sort[nConflict]=farkas[iColumn]*gap;
    3401                   conflict[nConflict++]=iColumn;
    3402                 }
    3403                 //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
    3404               }
    3405             } else {
    3406               // can't use
    3407               if (farkas[iColumn]<0.0) {
    3408                 assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
    3409                 // farkas is negative - relax lower bound all way
    3410                 thisRelax =
    3411                   farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
    3412               } else {
    3413                 assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
    3414                 // farkas is positive - relax upper bound all way
    3415                 thisRelax =
    3416                   farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
    3417               }
    3418             }
    3419           } else {
    3420             // not integer - but may have been got at
    3421             double gap = originalUpper[iColumn]-originalLower[iColumn];
    3422             if (gap>columnUpper[iColumn]-columnLower[iColumn]) {
    3423               // can't use
    3424               if (farkas[iColumn]<0.0) {
    3425                 assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
    3426                 // farkas is negative - relax lower bound all way
    3427                 thisRelax =
    3428                   farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
    3429               } else {
    3430                 assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
    3431                 // farkas is positive - relax upper bound all way
    3432                 thisRelax =
    3433                   farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
    3434               }
    3435             }
    3436           }
    3437           assert (thisRelax>=0.0);
    3438           relax += thisRelax;
    3439         }
    3440         if (relax+bSum>-1.0e-4||!nConflict) {
    3441           if (relax+bSum>-1.0e-4) {
    3442 #if PRINT_CONFLICT>1 //ndef NDEBUG
    3443             printf("General integers relax bSum to %g\n",relax+bSum);
    3444 #endif
    3445           } else {
     3371                                        ||iColumn==sequenceOut)*/
     3372              ) {
     3373                // farkas is negative - add to list
     3374                gap = columnLower[iColumn] - originalLower[iColumn];
     3375                if (gap) {
     3376                  sort[nConflict] = farkas[iColumn] * gap;
     3377                  conflict[nConflict++] = iColumn;
     3378                }
     3379                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
     3380              }
     3381            } else {
     3382              // can't use
     3383              if (farkas[iColumn] < 0.0) {
     3384                assert(originalLower[iColumn] - columnLower[iColumn] <= 0.0);
     3385                // farkas is negative - relax lower bound all way
     3386                thisRelax = farkas[iColumn] * (originalLower[iColumn] - columnLower[iColumn]);
     3387              } else {
     3388                assert(originalUpper[iColumn] - columnUpper[iColumn] >= 0.0);
     3389                // farkas is positive - relax upper bound all way
     3390                thisRelax = farkas[iColumn] * (originalUpper[iColumn] - columnUpper[iColumn]);
     3391              }
     3392            }
     3393          } else {
     3394            // not integer - but may have been got at
     3395            double gap = originalUpper[iColumn] - originalLower[iColumn];
     3396            if (gap > columnUpper[iColumn] - columnLower[iColumn]) {
     3397              // can't use
     3398              if (farkas[iColumn] < 0.0) {
     3399                assert(originalLower[iColumn] - columnLower[iColumn] <= 0.0);
     3400                // farkas is negative - relax lower bound all way
     3401                thisRelax = farkas[iColumn] * (originalLower[iColumn] - columnLower[iColumn]);
     3402              } else {
     3403                assert(originalUpper[iColumn] - columnUpper[iColumn] >= 0.0);
     3404                // farkas is positive - relax upper bound all way
     3405                thisRelax = farkas[iColumn] * (originalUpper[iColumn] - columnUpper[iColumn]);
     3406              }
     3407            }
     3408          }
     3409          assert(thisRelax >= 0.0);
     3410          relax += thisRelax;
     3411        }
     3412        if (relax + bSum > -1.0e-4 || !nConflict) {
     3413          if (relax + bSum > -1.0e-4) {
     3414#if PRINT_CONFLICT > 1 //ndef NDEBUG
     3415            printf("General integers relax bSum to %g\n", relax + bSum);
     3416#endif
     3417          } else {
    34463418#if PRINT_CONFLICT
    3447             printf("All variables relaxed and still infeasible - what does this mean?\n");
    3448 #endif
    3449             int nR=0;
    3450             for (int i=0;i<numberRows;i++) {
    3451               if (fabs(ray[i])>1.0e-10)
    3452                 nR++;
    3453               else
    3454                 ray[i]=0.0;
    3455             }
    3456             int nC=0;
    3457             for (int i=0;i<numberColumns;i++) {
    3458               if (fabs(farkas[i])>1.0e-10)
    3459                 nC++;
    3460               else
    3461                 farkas[i]=0.0;
    3462             }
    3463             if (nR<3&&nC<5) {
    3464               printf("BAD %d nonzero rows, %d nonzero columns\n",nR,nC);
    3465             }
    3466           }
    3467         } else if (nConflict < 1000) {
    3468 #if PRINT_CONFLICT>1 //ndef NDEBUG
    3469           if (nConflict<5)
    3470             printf("BOUNDS violation bSum %g (relaxed %g) - %d at original bounds, %d fixed - %d in conflict\n",bSum,
    3471                    relax+bSum,nOriginal,nFixed,nConflict);
    3472 #endif
    3473           CoinSort_2(sort,sort+nConflict,conflict);
    3474           if ((debugMode&4)!=0) {
    3475             double * temp = new double[numberColumns];
    3476             int * tempC = new int[numberColumns];
    3477             int n=0;
    3478             for (int j=0;j<nConflict;j++) {
    3479               int i=conflict[j];
    3480               if (fabs(farkas[i])>1.0e-12) {
    3481                 temp[n]=farkas[i];
    3482                 tempC[n++]=i;
    3483               }
    3484             }
    3485             debugModel.addRow(n,tempC,temp,bSum,bSum);
    3486             delete [] tempC;
    3487             delete [] temp;
    3488           }
    3489           int nC=nConflict;
    3490           for (int i=0;i<nConflict;i++) {
    3491             int iColumn=conflict[i];
    3492             if (fabs(sort[i])!=fabs(farkas[iColumn])&&originalUpper[iColumn]==1.0)
    3493               printf("odd %d %g %d %g\n",i,sort[i],iColumn,farkas[iColumn]);
    3494           }
    3495           bSum+=relax;
    3496           double saveBsum = bSum;
    3497           // we can't use same values
    3498           double totalChange=0;
    3499           while (nConflict) {
    3500             double last = -sort[nConflict-1];
    3501             int kConflict=nConflict;
    3502             while (kConflict) {
    3503               double change = -sort[kConflict-1];
    3504               if (change>last+1.0e-5)
    3505                 break;
    3506               totalChange += change;
    3507               kConflict--;
    3508             }
    3509             if (bSum+totalChange>-1.0e-4)
    3510               break;
     3419            printf("All variables relaxed and still infeasible - what does this mean?\n");
     3420#endif
     3421            int nR = 0;
     3422            for (int i = 0; i < numberRows; i++) {
     3423              if (fabs(ray[i]) > 1.0e-10)
     3424                nR++;
     3425              else
     3426                ray[i] = 0.0;
     3427            }
     3428            int nC = 0;
     3429            for (int i = 0; i < numberColumns; i++) {
     3430              if (fabs(farkas[i]) > 1.0e-10)
     3431                nC++;
     3432              else
     3433                farkas[i] = 0.0;
     3434            }
     3435            if (nR < 3 && nC < 5) {
     3436              printf("BAD %d nonzero rows, %d nonzero columns\n", nR, nC);
     3437            }
     3438          }
     3439        } else if (nConflict < 1000) {
     3440#if PRINT_CONFLICT > 1 //ndef NDEBUG
     3441          if (nConflict < 5)
     3442            printf("BOUNDS violation bSum %g (relaxed %g) - %d at original bounds, %d fixed - %d in conflict\n", bSum,
     3443              relax + bSum, nOriginal, nFixed, nConflict);
     3444#endif
     3445          CoinSort_2(sort, sort + nConflict, conflict);
     3446          if ((debugMode & 4) != 0) {
     3447            double *temp = new double[numberColumns];
     3448            int *tempC = new int[numberColumns];
     3449            int n = 0;
     3450            for (int j = 0; j < nConflict; j++) {
     3451              int i = conflict[j];
     3452              if (fabs(farkas[i]) > 1.0e-12) {
     3453                temp[n] = farkas[i];
     3454                tempC[n++] = i;
     3455              }
     3456            }
     3457            debugModel.addRow(n, tempC, temp, bSum, bSum);
     3458            delete[] tempC;
     3459            delete[] temp;
     3460          }
     3461          int nC = nConflict;
     3462          for (int i = 0; i < nConflict; i++) {
     3463            int iColumn = conflict[i];
     3464            if (fabs(sort[i]) != fabs(farkas[iColumn]) && originalUpper[iColumn] == 1.0)
     3465              printf("odd %d %g %d %g\n", i, sort[i], iColumn, farkas[iColumn]);
     3466          }
     3467          bSum += relax;
     3468          double saveBsum = bSum;
     3469          // we can't use same values
     3470          double totalChange = 0;
     3471          while (nConflict) {
     3472            double last = -sort[nConflict - 1];
     3473            int kConflict = nConflict;
     3474            while (kConflict) {
     3475              double change = -sort[kConflict - 1];
     3476              if (change > last + 1.0e-5)
     3477                break;
     3478              totalChange += change;
     3479              kConflict--;
     3480            }
     3481            if (bSum + totalChange > -1.0e-4)
     3482              break;
    35113483#if 0
    35123484            //int iColumn=conflict[nConflict-1];
     
    35173489            bSum += change;
    35183490#else
    3519             nConflict=kConflict;
    3520             bSum += totalChange;
    3521 #endif
    3522           }
    3523           if (!nConflict) {
    3524             int nR=0;
    3525             for (int i=0;i<numberRows;i++) {
    3526               if (fabs(ray[i])>1.0e-10)
    3527                 nR++;
    3528               else
    3529                 ray[i]=0.0;
    3530             }
    3531             int nC=0;
    3532             for (int i=0;i<numberColumns;i++) {
    3533               if (fabs(farkas[i])>1.0e-10)
    3534                 nC++;
    3535               else
    3536                 farkas[i]=0.0;
    3537             }
     3491            nConflict = kConflict;
     3492            bSum += totalChange;
     3493#endif
     3494          }
     3495          if (!nConflict) {
     3496            int nR = 0;
     3497            for (int i = 0; i < numberRows; i++) {
     3498              if (fabs(ray[i]) > 1.0e-10)
     3499                nR++;
     3500              else
     3501                ray[i] = 0.0;
     3502            }
     3503            int nC = 0;
     3504            for (int i = 0; i < numberColumns; i++) {
     3505              if (fabs(farkas[i]) > 1.0e-10)
     3506                nC++;
     3507              else
     3508                farkas[i] = 0.0;
     3509            }
    35383510#if 1 //PRINT_CONFLICT>1 //ndef NDEBUG
    3539             {
    3540               printf("BAD2 - zero nConflict %d nonzero rows, %d nonzero columns\n",nR,nC);
    3541             }
    3542 #endif
    3543           }
    3544           // no point doing if no reduction (or big?) ?
    3545           if (nConflict<nC+1&&nConflict<100&&nConflict) {
    3546             cut=new OsiRowCut();
    3547             cut->setUb(COIN_DBL_MAX);
    3548             if (!typeCut) {
    3549               double lo=1.0;
    3550               for (int i=0;i<nConflict;i++) {
    3551                 int iColumn = conflict[i];
    3552                 if (originalLower[iColumn]==columnLower[iColumn]) {
    3553                   // must be at least one higher
    3554                   sort[i]=1.0;
    3555                   lo += originalLower[iColumn];
    3556                 } else {
    3557                   // must be at least one lower
    3558                   sort[i]=-1.0;
    3559                   lo -= originalUpper[iColumn];
    3560                 }
    3561               }
    3562               cut->setLb(lo);
    3563               cut->setRow(nConflict,conflict,sort);
     3511            {
     3512              printf("BAD2 - zero nConflict %d nonzero rows, %d nonzero columns\n", nR, nC);
     3513            }
     3514#endif
     3515          }
     3516          // no point doing if no reduction (or big?) ?
     3517          if (nConflict < nC + 1 && nConflict < 100 && nConflict) {
     3518            cut = new OsiRowCut();
     3519            cut->setUb(COIN_DBL_MAX);
     3520            if (!typeCut) {
     3521              double lo = 1.0;
     3522              for (int i = 0; i < nConflict; i++) {
     3523                int iColumn = conflict[i];
     3524                if (originalLower[iColumn] == columnLower[iColumn]) {
     3525                  // must be at least one higher
     3526                  sort[i] = 1.0;
     3527                  lo += originalLower[iColumn];
     3528                } else {
     3529                  // must be at least one lower
     3530                  sort[i] = -1.0;
     3531                  lo -= originalUpper[iColumn];
     3532                }
     3533              }
     3534              cut->setLb(lo);
     3535              cut->setRow(nConflict, conflict, sort);
    35643536#if PRINT_CONFLICT
    3565               printf("CUT has %d (started at %d) - final bSum %g\n",nConflict,nC,bSum);
    3566 #endif
    3567               if ((debugMode&4)!=0) {
    3568                 debugModel.addRow(nConflict,conflict,sort,lo,COIN_DBL_MAX);
    3569                 debugModel.writeMps("bad.mps");
    3570               }
    3571             } else {
    3572               // just save for use later
    3573               // first take off small
    3574               int nC2=nC;
    3575               while (nC2) {
    3576                 //int iColumn=conflict[nConflict-1];
    3577                 double change=-sort[nC2-1];
    3578 </