Changeset 750 for trunk

Timestamp:

Aug 14, 2007 6:36:36 AM (14 years ago)

Author:

forrest

Message:

try and speed up feasibility pump

Location:

trunk/Cbc/src

Files:

• CbcHeuristicFPump.cpp (modified) (5 diffs)
• CbcModel.cpp (modified) (3 diffs)
• CbcModel.hpp (modified) (3 diffs)
• CbcSolver.cpp (modified) (29 diffs)

trunk/Cbc/src/CbcHeuristicFPump.cpp

@@ -491 +491 @@
           if (matched) break;
         }
+        int numberPerturbed=0;
         if (matched || numberPasses%100 == 0) {
           // perturbation
           sprintf(pumpPrint+strlen(pumpPrint)," perturbation applied");
           newLineNeeded=true;
+          double factorX[10]={0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,1.0};
+          double factor=1.0;
+          double target=-1.0;
+          double * randomX = new double [numberIntegers];
+          for (i=0;i<numberIntegers;i++) 
+            randomX[i] = max(0.0,CoinDrand48()-0.3);
+          for (int k=0;k<10;k++) {
+#ifdef COIN_DEVELOP
+            printf("kpass %d\n",k);
+#endif
+            int numberX[10]={0,0,0,0,0,0,0,0,0,0};
+            for (i=0;i<numberIntegers;i++) {
+              int iColumn = integerVariable[i];
+              double value = randomX[i];
+              double difference = fabs(solution[iColumn]-newSolution[iColumn]);
+              for (int j=0;j<10;j++) {
+                if (difference+value*factorX[j]>0.5) 
+                  numberX[j]++;
+              }
+            }
+            if (target<0.0) {
+              if (numberX[9]<=200)
+                break; // not very many changes
+              target=CoinMax(200.0,0.05*numberX[9]);
+            }
+            int iX=-1;
+            int iBand=-1;
+            for (i=0;i<10;i++) {
+#ifdef COIN_DEVELOP
+              printf("** %d changed at %g\n",numberX[i],factorX[i]);
+#endif
+              if (numberX[i]>=target&&numberX[i]<2.0*target&&iX<0)
+                iX=i;
+              if (iBand<0&&numberX[i]>target) {
+                iBand=i;
+                factor=factorX[i];
+              }
+            }
+            if (iX>=0) {
+              factor=factorX[iX];
+              break;
+            } else {
+              assert (iBand>=0);
+              double hi = factor;
+              double lo = (iBand>0) ? factorX[iBand-1] : 0.0;
+              double diff = (hi-lo)/9.0;
+              for (i=0;i<10;i++) {
+                factorX[i]=lo;
+                lo += diff;
+              }
+            }
+          }
           for (i=0;i<numberIntegers;i++) {
             int iColumn = integerVariable[i];
-            double value = max(0.0,CoinDrand48()-0.3);
+            double value = randomX[i];
             double difference = fabs(solution[iColumn]-newSolution[iColumn]);
-            if (difference+value>0.5) {
+            if (difference+value*factor>0.5) {
+              numberPerturbed++;
               if (newSolution[iColumn]<lower[iColumn]+primalTolerance) {
                 newSolution[iColumn] += 1.0;
@@ -513 +567 @@
             }
           }
+          delete [] randomX;
         } else {
           for (j=NUMBER_OLD-1;j>0;j--) {
@@ -523 +578 @@
         double offset=0.0;
         double costValue = (1.0-scaleFactor)*solver->getObjSense();
-        
+        int numberChanged=0;
+        const double * oldObjective = solver->getObjCoefficients();
         for (i=0;i<numberColumns;i++) {
           // below so we can keep original code and allow for objective
@@ -535 +591 @@
             continue;
           }
+          double newValue=0.0;
           if (newSolution[iColumn]<lower[iColumn]+primalTolerance) {
-            solver->setObjCoeff(iColumn,costValue+scaleFactor*saveObjective[iColumn]);
+            newValue = costValue+scaleFactor*saveObjective[iColumn];
           } else {
             if (newSolution[iColumn]>upper[iColumn]-primalTolerance) {
-              solver->setObjCoeff(iColumn,-costValue+scaleFactor*saveObjective[iColumn]);
-            } else {
-              solver->setObjCoeff(iColumn,0.0);
-            }
-          }
+              newValue = -costValue+scaleFactor*saveObjective[iColumn];
+            }
+          }
+          if (newValue!=oldObjective[iColumn])
+            numberChanged++;
+          solver->setObjCoeff(iColumn,newValue);
           offset += costValue*newSolution[iColumn];
         }
@@ -625 +683 @@
             solver->setWarmStart(&dummy);
           }
+#ifdef COIN_DEVELOP
+          printf("%d perturbed out of %d columns (%d changed)\n",numberPerturbed,numberColumns,numberChanged);
+#endif
+          bool takeHint;
+          OsiHintStrength strength;
+          solver->getHintParam(OsiDoDualInResolve,takeHint,strength);
+          if (numberPerturbed>numberColumns)
+            solver->setHintParam(OsiDoDualInResolve,true); // dual may be better
           solver->resolve();
+          solver->setHintParam(OsiDoDualInResolve,takeHint);
+#ifdef COIN_DEVELOP
+          printf("took %d iterations\n",solver->getIterationCount());
+#endif
           assert (solver->isProvenOptimal());
           // in case very dubious solver

trunk/Cbc/src/CbcModel.cpp

@@ -940 +940 @@
 */
   bestObjective_ = CoinMin(bestObjective_,1.0e50) ;
-  numberSolutions_ = 0 ;
-  stateOfSearch_=0;
-  numberHeuristicSolutions_ = 0 ;
+  if (!bestSolution_) {
+    numberSolutions_ = 0 ;
+    numberHeuristicSolutions_ = 0 ;
+  } 
+  stateOfSearch_ = 0; 
   // Everything is minimization
   { 
@@ -1086 +1088 @@
   numberDJFixed_=0.0;
   // Do heuristics
-  {
-    double * newSolution = new double [numberColumns] ;
-    double heuristicValue = getCutoff() ;
-    int found = -1; // no solution found
-
-    currentPassNumber_ = 1; // so root heuristics will run
-    int i;
-    for (i = 0;i<numberHeuristics_;i++) {
-      // see if heuristic will do anything
-      double saveValue = heuristicValue ;
-      int ifSol = heuristic_[i]->solution(heuristicValue,
-                                          newSolution);
-      if (ifSol>0) {
-        // better solution found
-        found = i ;
-        incrementUsed(newSolution);
-        // increment number of solutions so other heuristics can test
-        numberSolutions_++;
-        numberHeuristicSolutions_++;
-      } else {
-        heuristicValue = saveValue ;
-      }
-    }
-    currentPassNumber_ = 0;
-    /*
-      Did any of the heuristics turn up a new solution? Record it before we free
-      the vector.
-    */
-    if (found >= 0) { 
-      // For compiler error on terra cluster!
-      if (found<numberHeuristics_)
-        lastHeuristic_ = heuristic_[found];
-      else
-        lastHeuristic_ = heuristic_[0];
-      setBestSolution(CBC_ROUNDING,heuristicValue,newSolution) ;
-      CbcTreeLocal * tree 
-          = dynamic_cast<CbcTreeLocal *> (tree_);
-      if (tree)
-        tree->passInSolution(bestSolution_,heuristicValue);
-      for (i = 0;i<numberHeuristics_;i++) {
-        // delete FPump
-        CbcHeuristicFPump * pump 
-          = dynamic_cast<CbcHeuristicFPump *> (heuristic_[i]);
-        if (pump) {
-          delete pump;
-          numberHeuristics_ --;
-          for (int j=i;j<numberHeuristics_;j++)
-            heuristic_[j] = heuristic_[j+1];
-        }
-      }
-      if (eventHandler) {
-        if (!eventHandler->event(CbcEventHandler::solution)) {
-          eventHappened_=true; // exit
-        }
-      }
-    }
-    delete [] newSolution ;
-  } 
+  doHeuristicsAtRoot();
   statistics_ = NULL;
   // Do on switch
@@ -9922 +9867 @@
   memcpy(bestSolution_,solution,numberColumns*sizeof(double));
 }
+// Do heuristics at root
+void 
+CbcModel::doHeuristicsAtRoot(bool deleteHeuristicsAfterwards)
+{
+  int numberColumns = getNumCols() ;
+  if (deleteHeuristicsAfterwards) {
+    assert (!usedInSolution_);
+    usedInSolution_ = new int [numberColumns];
+    CoinZeroN(usedInSolution_,numberColumns);
+  }
+  double * newSolution = new double [numberColumns] ;
+  double heuristicValue = getCutoff() ;
+  int found = -1; // no solution found
+  CbcEventHandler *eventHandler = getEventHandler() ;
+  if (eventHandler)
+    eventHandler->setModel(this);
+  
+  currentPassNumber_ = 1; // so root heuristics will run
+  int i;
+  for (i = 0;i<numberHeuristics_;i++) {
+    // see if heuristic will do anything
+    double saveValue = heuristicValue ;
+    int ifSol = heuristic_[i]->solution(heuristicValue,
+                                        newSolution);
+    if (ifSol>0) {
+      // better solution found
+      found = i ;
+      incrementUsed(newSolution);
+      // increment number of solutions so other heuristics can test
+      numberSolutions_++;
+      numberHeuristicSolutions_++;
+    } else {
+      heuristicValue = saveValue ;
+    }
+  }
+  currentPassNumber_ = 0;
+  /*
+    Did any of the heuristics turn up a new solution? Record it before we free
+    the vector.
+  */
+  if (found >= 0) { 
+    // For compiler error on terra cluster!
+    if (found<numberHeuristics_)
+      lastHeuristic_ = heuristic_[found];
+    else
+      lastHeuristic_ = heuristic_[0];
+    setBestSolution(CBC_ROUNDING,heuristicValue,newSolution) ;
+    CbcTreeLocal * tree 
+      = dynamic_cast<CbcTreeLocal *> (tree_);
+    if (tree)
+      tree->passInSolution(bestSolution_,heuristicValue);
+    if (eventHandler) {
+      if (!eventHandler->event(CbcEventHandler::solution)) {
+        eventHappened_=true; // exit
+      }
+    }
+  }
+  if (!deleteHeuristicsAfterwards) {
+    for (i = 0;i<numberHeuristics_;i++) {
+      // delete FPump
+      CbcHeuristicFPump * pump 
+        = dynamic_cast<CbcHeuristicFPump *> (heuristic_[i]);
+      if (pump) {
+        delete pump;
+        numberHeuristics_ --;
+        for (int j=i;j<numberHeuristics_;j++)
+          heuristic_[j] = heuristic_[j+1];
+      }
+    }
+  } else {
+    // delete all
+    for (i = 0;i<numberHeuristics_;i++) 
+      delete heuristic_[i];
+    numberHeuristics_=0;
+    delete [] heuristic_;
+    heuristic_=NULL;
+    delete [] usedInSolution_;
+    usedInSolution_ = NULL;
+  }
+  delete [] newSolution ;
+}
+// Zap integer information in problem (may leave object info)
+void 
+CbcModel::zapIntegerInformation(bool leaveObjects)
+{
+  numberIntegers_ = 0; 
+  delete [] integerVariable_; 
+  integerVariable_ = NULL;
+  if (!leaveObjects&&ownObjects_) {
+    int i;
+    for (i=0;i<numberObjects_;i++) 
+      delete object_[i];
+    delete [] object_;
+    numberObjects_=0;
+    object_=NULL;
+  }
+}
 // Create C++ lines to get to current state
 void 

trunk/Cbc/src/CbcModel.hpp

@@ -1106 +1106 @@
   /// Get number of heuristic solutions
   inline int getNumberHeuristicSolutions() const { return numberHeuristicSolutions_;}
+  /// Set number of heuristic solutions
+  inline void setNumberHeuristicSolutions(int value) { numberHeuristicSolutions_=value;}
 
   /// Set objective function sense (1 for min (default), -1 for max,)
@@ -1507 +1509 @@
     { return continuousSolver_;}
 
+    /// Create solver with continuous state
+    inline void createContinuousSolver()
+    { continuousSolver_ = solver_->clone();}
+    /// Clear solver with continuous state
+    inline void clearContinuousSolver()
+    { delete continuousSolver_; continuousSolver_ = NULL;}
+
   /// A copy of the solver, taken at constructor or by saveReferenceSolver
   inline OsiSolverInterface * referenceSolver() const
@@ -1619 +1628 @@
   */
   void convertToDynamic();
+  /// Zap integer information in problem (may leave object info)
+  void zapIntegerInformation(bool leaveObjects=true);
   /// Use cliques for pseudocost information - return nonzero if infeasible
   int cliquePseudoCosts(int doStatistics);
   /// Fill in useful estimates
   void pseudoShadow(double * down, double * up);
-
+  /// Do heuristics at root
+  void doHeuristicsAtRoot(bool deleteHeuristicsAfterwards=false);
   /// Get the hotstart solution 
   inline const double * hotstartSolution() const

trunk/Cbc/src/CbcSolver.cpp

@@ -40 +40 @@
 #include "OsiRowCutDebugger.hpp"
 #include "OsiChooseVariable.hpp"
+#include "OsiAuxInfo.hpp"
 //#define USER_HAS_FAKE_CLP
 //#define USER_HAS_FAKE_CBC
@@ -1431 +1432 @@
   parameters[whichParam(COMBINE,numberParameters,parameters)].setCurrentOption("on");
   parameters[whichParam(RINS,numberParameters,parameters)].setCurrentOption("off");
+  parameters[whichParam(LOCALTREE,numberParameters,parameters)].setCurrentOption("off");
   parameters[whichParam(COSTSTRATEGY,numberParameters,parameters)].setCurrentOption("off");
 }
+/* 1 - add heuristics to model
+   2 - do heuristics (and set cutoff and best solution)
+   3 - for miplib test so skip some
+*/
+static int doHeuristics(CbcModel * model,int type) 
+{
+  bool anyToDo=false;
+  int logLevel = parameters[whichParam(LOGLEVEL,numberParameters,parameters)].intValue();
+  int useFpump = parameters[whichParam(FPUMP,numberParameters,parameters)].currentOptionAsInteger();
+  int useRounding = parameters[whichParam(ROUNDING,numberParameters,parameters)].currentOptionAsInteger();
+  int useGreedy = parameters[whichParam(GREEDY,numberParameters,parameters)].currentOptionAsInteger();
+  int useCombine = parameters[whichParam(COMBINE,numberParameters,parameters)].currentOptionAsInteger();
+  int useRINS = parameters[whichParam(RINS,numberParameters,parameters)].currentOptionAsInteger();
+  // FPump done first as it only works if no solution
+  int kType = (type<3) ? type : 1;
+  if (useFpump>=kType) {
+    anyToDo=true;
+    CbcHeuristicFPump heuristic4(*model);
+    heuristic4.setFractionSmall(0.6);
+    heuristic4.setMaximumPasses(parameters[whichParam(FPUMPITS,numberParameters,parameters)].intValue());
+    int pumpTune=parameters[whichParam(FPUMPTUNE,numberParameters,parameters)].intValue();
+    if (pumpTune>0) {
+      /*
+        >=10000000 for using obj
+        >=1000000 use as accumulate switch
+        >=1000 use index+1 as number of large loops
+        >=100 use 0.05 objvalue as increment
+        >=10 use +0.1 objvalue for cutoff (add)
+        1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds
+        4 and static continuous, 5 as 3 but no internal integers
+        6 as 3 but all slack basis!
+      */
+      double value = model->solver()->getObjSense()*model->solver()->getObjValue();
+      int w = pumpTune/10;
+      int c = w % 10;
+      w /= 10;
+      int i = w % 10;
+      w /= 10;
+      int r = w;
+      int accumulate = r/1000;
+      r -= 1000*accumulate;
+      if (accumulate>=10) {
+        int which = accumulate/10;
+        accumulate -= 10*which;
+        which--;
+        // weights and factors
+        double weight[]={0.1,0.1,0.5,0.5,1.0,1.0,5.0,5.0};
+        double factor[] = {0.1,0.5,0.1,0.5,0.1,0.5,0.1,0.5};
+        heuristic4.setInitialWeight(weight[which]);
+        heuristic4.setWeightFactor(factor[which]);
+      }
+      // fake cutoff
+      if (logLevel>1)
+        printf("Setting ");
+      if (c) {
+        double cutoff;
+        model->solver()->getDblParam(OsiDualObjectiveLimit,cutoff);
+        cutoff = CoinMin(cutoff,value + 0.1*fabs(value)*c);
+        double dextra1 = parameters[whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();
+        if (dextra1)
+          cutoff=dextra1;
+        heuristic4.setFakeCutoff(cutoff);
+        if (logLevel>1)
+          printf("fake cutoff of %g ",cutoff);
+      }
+      if (i||r) {
+        // also set increment
+        double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12);
+        double dextra2 = parameters[whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();
+        if (dextra2)
+          increment = dextra2;
+        heuristic4.setAbsoluteIncrement(increment);
+        heuristic4.setAccumulate(accumulate);
+        heuristic4.setMaximumRetries(r+1);
+        if (logLevel>1) {
+          if (i) 
+            printf("increment of %g ",heuristic4.absoluteIncrement());
+          if (accumulate) 
+            printf("accumulate of %d ",accumulate);
+          printf("%d retries ",r+2);
+        }
+      }
+      pumpTune = pumpTune%100;
+      if (logLevel>1)
+        printf("and setting when to %d\n",pumpTune+10);
+      if (pumpTune==6)
+        pumpTune =13;
+      heuristic4.setWhen(pumpTune+10);
+    }
+    heuristic4.setHeuristicName("feasibility pump");
+    model->addHeuristic(&heuristic4);
+  }
+  if (useRounding>=type) {
+    CbcRounding heuristic1(*model);
+    heuristic1.setHeuristicName("rounding");
+    model->addHeuristic(&heuristic1) ;
+    anyToDo=true;
+  }
+  if (useCombine>=type) {
+    CbcHeuristicLocal heuristic2(*model);
+    heuristic2.setHeuristicName("combine solutions");
+    heuristic2.setFractionSmall(0.6);
+    heuristic2.setSearchType(1);
+    model->addHeuristic(&heuristic2);
+    anyToDo=true;
+  }
+  if (useGreedy>=type) {
+    CbcHeuristicGreedyCover heuristic3(*model);
+    heuristic3.setHeuristicName("greedy cover");
+    CbcHeuristicGreedyEquality heuristic3a(*model);
+    heuristic3a.setHeuristicName("greedy equality");
+    model->addHeuristic(&heuristic3);
+    model->addHeuristic(&heuristic3a);
+    anyToDo=true;
+  }
+  if (useRINS>=kType) {
+    CbcHeuristicRINS heuristic5(*model);
+    heuristic5.setHeuristicName("RINS");
+    heuristic5.setFractionSmall(0.6);
+    model->addHeuristic(&heuristic5) ;
+    anyToDo=true;
+  }
+  if (type==2&&anyToDo) {
+    // Do heuristics
+    // clean copy
+    CbcModel model2(*model);
+    if (logLevel<=1)
+      model2.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
+    OsiBabSolver defaultC;
+    //solver_->setAuxiliaryInfo(&defaultC);
+    model2.passInSolverCharacteristics(&defaultC);
+    // Save bounds
+    int numberColumns = model2.solver()->getNumCols();
+    model2.createContinuousSolver();
+    bool cleanModel = !model2.numberIntegers()&&!model2.numberObjects();
+    model2.findIntegers(false);
+    model2.doHeuristicsAtRoot(true);
+    if (cleanModel)
+      model2.zapIntegerInformation(false);
+    if (model2.bestSolution()) {
+      double value = model2.getMinimizationObjValue();
+      model->setCutoff(value);
+      model->setBestSolution(model2.bestSolution(),numberColumns,value);
+      model->setSolutionCount(1);
+      model->setNumberHeuristicSolutions(1);
+    }
+    return 0;
+  } else {
+    return 0;
+  }
+} 
 /* Meaning of whereFrom:
    1 after initial solve by dualsimplex etc
@@ -1439 +1592 @@
    4 just after branchAndBound (before postprocessing)
    5 after postprocessing
+   6 after a user called heuristic phase
 */
 int CbcMain1 (int argc, const char *argv[],
@@ -1476 +1630 @@
   }
   CbcModel * babModel = NULL;
+  double time0;
   {
     double time1 = CoinCpuTime(),time2;
+    time0=time1;
     bool goodModel=(originalSolver->getNumCols()) ? true : false;
 
@@ -1811 +1967 @@
     bool storedCuts = false;
 
-    bool useRounding=true;
-    bool useFpump=true;
-    bool useGreedy=true;
-    bool useCombine=true;
-    bool useLocalTree=false;
-    bool useRINS=false;
     int useCosts=0;
     // don't use input solution
@@ -1857 +2007 @@
       // next command
       field=CoinReadGetCommand(argc,argv);
+      // Reset time
+      time1 = CoinCpuTime();
       // adjust field if has odd trailing characters
       char temp [200];
@@ -2120 +2272 @@
                 cutPassInTree = value;
               else if (parameters[iParam].type()==FPUMPITS)
-                { useFpump = true;parameters[iParam].setIntValue(value);}
+                { parameters[iParam].setIntValue(value);}
               else if (parameters[iParam].type()==STRONGBRANCHING||
                        parameters[iParam].type()==NUMBERBEFORE)
@@ -2314 +2466 @@
             case ROUNDING:
               defaultSettings=false; // user knows what she is doing
-              useRounding = action;
               break;
             case FPUMP:
               defaultSettings=false; // user knows what she is doing
-              useFpump=action;
               break;
             case RINS:
-              useRINS=action;
               break;
             case CUTSSTRATEGY:
@@ -2349 +2498 @@
               break;
             case HEURISTICSTRATEGY:
-              useRounding = action;
-              useGreedy = action;
-              useCombine = action;
-              //useLocalTree = action;
-              useFpump=action;
               parameters[whichParam(ROUNDING,numberParameters,parameters)].setCurrentOption(action);
               parameters[whichParam(GREEDY,numberParameters,parameters)].setCurrentOption(action);
@@ -2362 +2506 @@
             case GREEDY:
               defaultSettings=false; // user knows what she is doing
-              useGreedy = action;
               break;
             case COMBINE:
               defaultSettings=false; // user knows what she is doing
-              useCombine = action;
               break;
             case LOCALTREE:
               defaultSettings=false; // user knows what she is doing
-              useLocalTree = action;
               break;
             case COSTSTRATEGY:
@@ -2440 +2581 @@
                 //printf("dualize %d\n",dualize);
                 model2 = ((ClpSimplexOther *) model2)->dualOfModel();
-                sprintf(generalPrint,"Dual of model has %d rows and %d columns\n",
+                sprintf(generalPrint,"Dual of model has %d rows and %d columns",
                        model2->numberRows(),model2->numberColumns());
                 generalMessageHandler->message(CLP_GENERAL,generalMessages)
@@ -2458 +2599 @@
                   if (preSolve<=100) {
                     presolveType=ClpSolve::presolveNumber;
-                    sprintf(generalPrint,"Doing %d presolve passes - picking up non-costed slacks\n",
+                    sprintf(generalPrint,"Doing %d presolve passes - picking up non-costed slacks",
                            preSolve);
                     generalMessageHandler->message(CLP_GENERAL,generalMessages)
@@ -2467 +2608 @@
                     preSolve -=100;
                     presolveType=ClpSolve::presolveNumberCost;
-                    sprintf(generalPrint,"Doing %d presolve passes - picking up costed slacks\n",
+                    sprintf(generalPrint,"Doing %d presolve passes - picking up costed slacks",
                            preSolve);
                     generalMessageHandler->message(CLP_GENERAL,generalMessages)
@@ -2815 +2956 @@
               int nOut = numberRows-clpSolver->getNumRows();
               if (nOut&&!noPrinting)
-                sprintf(generalPrint,"%d rows eliminated\n",nOut);
+                sprintf(generalPrint,"%d rows eliminated",nOut);
               generalMessageHandler->message(CLP_GENERAL,generalMessages)
                 << generalPrint
@@ -2842 +2983 @@
             } else {
               std::cout<<"** Current model not valid"<<std::endl;
+            }
+            break;
+          case DOHEURISTIC:
+            if (goodModel) {
+              // Actually do heuristics
+              doHeuristics(&model,2);
+              if (model.bestSolution()) {
+                model.setProblemStatus(1);
+                model.setSecondaryStatus(6);
+              }
+              int returnCode=callBack(&model,6);
+              if (returnCode) {
+                // exit if user wants
+                delete babModel;
+                return returnCode;
+              }
             }
             break;
@@ -3409 +3566 @@
                     solver2->setHintParam(OsiDoInBranchAndCut,false,OsiHintDo) ;
                 }
-                babModel->setOriginalColumns(process.originalColumns());
 #ifdef COIN_HAS_ASL
                 if (!solver2&&usingAmpl) {
@@ -3423 +3579 @@
                 if (!noPrinting) {
                   if (!solver2) {
-                    sprintf(generalPrint,"Pre-processing says infeasible or unbounded\n");
+                    sprintf(generalPrint,"Pre-processing says infeasible or unbounded");
                     generalMessageHandler->message(CLP_GENERAL,generalMessages)
                       << generalPrint
@@ -3459 +3615 @@
                 solver2 = solver2->clone();
                 babModel->assignSolver(solver2);
+                babModel->setOriginalColumns(process.originalColumns());
                 babModel->initialSolve();
                 babModel->setMaximumSeconds(timeLeft-(CoinCpuTime()-time1));
@@ -3598 +3755 @@
                 delete [] dsort;
               }
-              // FPump done first as it only works if no solution
-              CbcHeuristicFPump heuristic4(*babModel);
-              heuristic4.setFractionSmall(0.6);
-              if (useFpump) {
-                heuristic4.setMaximumPasses(parameters[whichParam(FPUMPITS,numberParameters,parameters)].intValue());
-                int pumpTune=parameters[whichParam(FPUMPTUNE,numberParameters,parameters)].intValue();
-                if (pumpTune>0) {
-                  /*
-                    >=10000000 for using obj
-                    >=1000000 use as accumulate switch
-                    >=1000 use index+1 as number of large loops
-                    >=100 use 0.05 objvalue as increment
-                    >=10 use +0.1 objvalue for cutoff (add)
-                    1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds
-                    4 and static continuous, 5 as 3 but no internal integers
-                    6 as 3 but all slack basis!
-                  */
-                  int logLevel = parameters[log].intValue();
-                  double value = babModel->solver()->getObjSense()*babModel->solver()->getObjValue();
-                  int w = pumpTune/10;
-                  int c = w % 10;
-                  w /= 10;
-                  int i = w % 10;
-                  w /= 10;
-                  int r = w;
-                  int accumulate = r/1000;
-                  r -= 1000*accumulate;
-                  if (accumulate>=10) {
-                    int which = accumulate/10;
-                    accumulate -= 10*which;
-                    which--;
-                    // weights and factors
-                    double weight[]={0.1,0.1,0.5,0.5,1.0,1.0,5.0,5.0};
-                    double factor[] = {0.1,0.5,0.1,0.5,0.1,0.5,0.1,0.5};
-                    heuristic4.setInitialWeight(weight[which]);
-                    heuristic4.setWeightFactor(factor[which]);
-                  }
-                  // fake cutoff
-                  if (logLevel>1)
-                    printf("Setting ");
-                  if (c) {
-                    double cutoff;
-                    babModel->solver()->getDblParam(OsiDualObjectiveLimit,cutoff);
-                    cutoff = CoinMin(cutoff,value + 0.1*fabs(value)*c);
-                    double dextra1 = parameters[whichParam(DEXTRA1,numberParameters,parameters)].doubleValue();
-                    if (dextra1)
-                      cutoff=dextra1;
-                    heuristic4.setFakeCutoff(cutoff);
-                    if (logLevel>1)
-                      printf("fake cutoff of %g ",cutoff);
-                  }
-                  if (i||r) {
-                    // also set increment
-                    double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12);
-                    double dextra2 = parameters[whichParam(DEXTRA2,numberParameters,parameters)].doubleValue();
-                    if (dextra2)
-                      increment = dextra2;
-                    heuristic4.setAbsoluteIncrement(increment);
-                    heuristic4.setAccumulate(accumulate);
-                    heuristic4.setMaximumRetries(r+1);
-                    if (logLevel>1) {
-                      if (i) 
-                        printf("increment of %g ",heuristic4.absoluteIncrement());
-                      if (accumulate) 
-                        printf("accumulate of %d ",accumulate);
-                      printf("%d retries ",r+2);
-                    }
-                  }
-                  pumpTune = pumpTune%100;
-                  if (logLevel>1)
-                    printf("and setting when to %d\n",pumpTune+10);
-                  if (pumpTune==6)
-                    pumpTune =13;
-                  heuristic4.setWhen(pumpTune+10);
-                }
-                heuristic4.setHeuristicName("feasibility pump");
-                babModel->addHeuristic(&heuristic4);
-              }
+              // Set up heuristics
+              doHeuristics(babModel,(!miplib) ? 1 : 3);
               if (!miplib) {
-                CbcRounding heuristic1(*babModel);
-                heuristic1.setHeuristicName("rounding");
-                if (useRounding)
-                  babModel->addHeuristic(&heuristic1) ;
-                CbcHeuristicLocal heuristic2(*babModel);
-                heuristic2.setHeuristicName("combine solutions");
-                heuristic2.setFractionSmall(0.6);
-                heuristic2.setSearchType(1);
-                if (useCombine)
-                  babModel->addHeuristic(&heuristic2);
-                CbcHeuristicGreedyCover heuristic3(*babModel);
-                heuristic3.setHeuristicName("greedy cover");
-                CbcHeuristicGreedyEquality heuristic3a(*babModel);
-                heuristic3a.setHeuristicName("greedy equality");
-                if (useGreedy) {
-                  babModel->addHeuristic(&heuristic3);
-                  babModel->addHeuristic(&heuristic3a);
-                }
-                if (useLocalTree) {
+                if(parameters[whichParam(LOCALTREE,numberParameters,parameters)].currentOptionAsInteger()) {
                   CbcTreeLocal localTree(babModel,NULL,10,0,0,10000,2000);
                   babModel->passInTreeHandler(localTree);
                 }
               }
-              CbcHeuristicRINS heuristic5(*babModel);
-              heuristic5.setHeuristicName("RINS");
-              heuristic5.setFractionSmall(0.6);
-              if (useRINS)
-                babModel->addHeuristic(&heuristic5) ;
               if (type==MIPLIB) {
                 if (babModel->numberStrong()==5&&babModel->numberBeforeTrust()==5) 
@@ -3843 +3901 @@
               int mipOptions = parameters[whichParam(MIPOPTIONS,numberParameters,parameters)].intValue()%10000;
               if (mipOptions!=(1)) {
-                sprintf(generalPrint,"mip options %d\n",mipOptions);
+                sprintf(generalPrint,"mip options %d",mipOptions);
                 generalMessageHandler->message(CLP_GENERAL,generalMessages)
                   << generalPrint
@@ -3864 +3922 @@
                 int moreMipOptions = parameters[whichParam(MOREMIPOPTIONS,numberParameters,parameters)].intValue();
                 if (moreMipOptions>=0) {
-                  sprintf(generalPrint,"more mip options %d\n",moreMipOptions);
+                  sprintf(generalPrint,"more mip options %d",moreMipOptions);
                   generalMessageHandler->message(CLP_GENERAL,generalMessages)
                     << generalPrint
@@ -3995 +4053 @@
                       }
                       babModel->setNumberObjects(n);
+                      babModel->zapIntegerInformation();
                     }
                     int nMissing=0;
@@ -4048 +4107 @@
                     }
                     if (nMissing) {
-                      sprintf(generalPrint,"%d SOS variables vanished due to pre processing? - check validity?\n",nMissing);
+                      sprintf(generalPrint,"%d SOS variables vanished due to pre processing? - check validity?",nMissing);
                       generalMessageHandler->message(CLP_GENERAL,generalMessages)
                         << generalPrint
@@ -4109 +4168 @@
                         delete [] back;
                         if (nMissing) {
-                          sprintf(generalPrint,"%d SOS variables vanished due to pre processing? - check validity?\n",nMissing);
+                          sprintf(generalPrint,"%d SOS variables vanished due to pre processing? - check validity?",nMissing);
                           generalMessageHandler->message(CLP_GENERAL,generalMessages)
                             << generalPrint
@@ -4278 +4337 @@
                         delete [] back;
                         if (nMissing) {
-                          sprintf(generalPrint,"%d SOS variables vanished due to pre processing? - check validity?\n",nMissing);
+                          sprintf(generalPrint,"%d SOS variables vanished due to pre processing? - check validity?",nMissing);
                           generalMessageHandler->message(CLP_GENERAL,generalMessages)
                             << generalPrint
@@ -4450 +4509 @@
                 }
                 if (testOsiOptions>=0) {
-                  sprintf(generalPrint,"Testing OsiObject options %d\n",testOsiOptions);
+                  sprintf(generalPrint,"Testing OsiObject options %d",testOsiOptions);
                   generalMessageHandler->message(CLP_GENERAL,generalMessages)
                     << generalPrint
@@ -4765 +4824 @@
                     babModel->makeGlobalCut(rowCutPointer);
                   }
-                }
+                }  
                 // If defaults then increase trust for small models
                 if (!strongChanged) {
@@ -5350 +5409 @@
                 if (dualize) {
                   model2 = ((ClpSimplexOther *) model2)->dualOfModel();
-                  sprintf(generalPrint,"Dual of model has %d rows and %d columns\n",
+                  sprintf(generalPrint,"Dual of model has %d rows and %d columns",
                          model2->numberRows(),model2->numberColumns());
                   generalMessageHandler->message(CLP_GENERAL,generalMessages)
@@ -6610 +6669 @@
   #endif
   model.solver()->setWarmStart(NULL);
+  sprintf(generalPrint,"Total time %.2f",CoinCpuTime()-time0);
+  generalMessageHandler->message(CLP_GENERAL,generalMessages)
+    << generalPrint
+    <<CoinMessageEol;
   return 0;
 }