Changeset 758

Timestamp:

Aug 16, 2007 6:34:37 AM (14 years ago)

Author:

forrest

Message:

fpump - make dj fixing optional

Location:

trunk/Cbc/src

Files:

• CbcHeuristicFPump.cpp (modified) (7 diffs)
• CbcHeuristicFPump.hpp (modified) (2 diffs)
• CbcModel.cpp (modified) (1 diff)
• CbcModel.hpp (modified) (1 diff)
• CbcSolver.cpp (modified) (4 diffs)

trunk/Cbc/src/CbcHeuristicFPump.cpp

@@ -34 +34 @@
    maximumRetries_(1),
    accumulate_(0),
+   fixOnReducedCosts_(1),
    roundExpensive_(false)
 {
@@ -54 +55 @@
    maximumRetries_(1),
    accumulate_(0),
+   fixOnReducedCosts_(1),
    roundExpensive_(roundExpensive)
 {
@@ -90 +92 @@
   else
     fprintf(fp,"4  heuristicFPump.setAccumulate(%d);\n",accumulate_);
+  if (fixOnReducedCosts_!=other.fixOnReducedCosts_)
+    fprintf(fp,"3  heuristicFPump.setFixOnReducedCosts(%d);\n",fixOnReducedCosts_);
+  else
+    fprintf(fp,"4  heuristicFPump.setFixOnReducedCosts(%d);\n",fixOnReducedCosts_);
   if (maximumTime_!=other.maximumTime_)
     fprintf(fp,"3  heuristicFPump.setMaximumTime(%g);\n",maximumTime_);
@@ -136 +142 @@
   maximumRetries_(rhs.maximumRetries_),
   accumulate_(rhs.accumulate_),
+  fixOnReducedCosts_(rhs.fixOnReducedCosts_),
   roundExpensive_(rhs.roundExpensive_)
 {
@@ -157 +164 @@
     maximumRetries_ = rhs.maximumRetries_;
     accumulate_ = rhs.accumulate_;
+    fixOnReducedCosts_ = rhs.fixOnReducedCosts_;
     roundExpensive_ = rhs.roundExpensive_;
   }
@@ -264 +272 @@
     if (gap>0.0) {
       gap += 100.0*tolerance;
-      model_->solver()->reducedCostFix(gap);
+      int nFix=model_->solver()->reducedCostFix(gap);
+      printf("dj fixing fixed %d variables\n",nFix);
     }
   }
@@ -308 +317 @@
       double tolerance;
       solver->getDblParam(OsiDualTolerance,tolerance) ;
-      if (gap>0.0) {
+      if (gap>0.0&&(fixOnReducedCosts_==1||(numberTries==1&&fixOnReducedCosts_==2))) {
         gap += 100.0*tolerance;
-        solver->reducedCostFix(gap);
+        int nFix=solver->reducedCostFix(gap);
+        if (nFix) {
+          sprintf(pumpPrint,"Reduced cost fixing fixed %d variables on pass %d",nFix,numberTries);
+          model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
+            << pumpPrint
+            <<CoinMessageEol;
+          pumpPrint[0]='\0';
+        }
       }
     }

trunk/Cbc/src/CbcHeuristicFPump.hpp

@@ -120 +120 @@
   inline int accumulate() const
   { return accumulate_;}
+  /**  Set whether to fix variables on known solution
+       0 - do not fix
+       1 - fix integers on reduced costs
+       2 - fix integers on reduced costs but only on entry
+  */
+  inline void setFixOnReducedCosts(int value)
+  { fixOnReducedCosts_=value;}
+  /// Get reduced cost option
+  inline int fixOnReducedCosts() const
+  { return fixOnReducedCosts_;}
 
 protected:
@@ -155 +165 @@
   */
   int accumulate_;
+  /**  Set whether to fix variables on known solution
+       0 - do not fix
+       1 - fix integers on reduced costs
+       2 - fix integers on reduced costs but only on entry
+  */
+  int fixOnReducedCosts_;
   /// If true round to expensive
   bool roundExpensive_;

trunk/Cbc/src/CbcModel.cpp

@@ -9872 +9872 @@
   memcpy(bestSolution_,solution,numberColumns*sizeof(double));
 }
-// Do heuristics at root
+/* Do heuristics at root.
+   0 - don't delete
+   1 - delete
+      2 - just delete - don't even use
+*/
 void 
-CbcModel::doHeuristicsAtRoot(bool deleteHeuristicsAfterwards)
+CbcModel::doHeuristicsAtRoot(int 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!=2) {
+    if (deleteHeuristicsAfterwards) {
+      assert (!usedInSolution_);
+      usedInSolution_ = new int [numberColumns];
+      CoinZeroN(usedInSolution_,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
+    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
+        }
       }
     }

trunk/Cbc/src/CbcModel.hpp

@@ -1634 +1634 @@
   /// Fill in useful estimates
   void pseudoShadow(double * down, double * up);
-  /// Do heuristics at root
-  void doHeuristicsAtRoot(bool deleteHeuristicsAfterwards=false);
+  /** Do heuristics at root.
+      0 - don't delete
+      1 - delete
+      2 - just delete - don't even use
+  */
+  void doHeuristicsAtRoot(int deleteHeuristicsAfterwards=0);
   /// Get the hotstart solution 
   inline const double * hotstartSolution() const

trunk/Cbc/src/CbcSolver.cpp

@@ -1526 +1526 @@
     }
     heuristic4.setHeuristicName("feasibility pump");
+    //#define ROLF
+#ifdef ROLF    
+    CbcHeuristicFPump pump(*model);
+    pump.setMaximumTime(60);
+    pump.setMaximumPasses(100);
+    pump.setMaximumRetries(1);
+    pump.setFixOnReducedCosts(0);
+    pump.setHeuristicName("Feasibility pump");
+    pump.setFractionSmall(1.0);
+    pump.setWhen(13);
+    model->addHeuristic(&pump);
+#else
     model->addHeuristic(&heuristic4);
+#endif
   }
   if (useRounding>=type) {
@@ -1563 +1576 @@
     // clean copy
     CbcModel model2(*model);
+    // But get rid of heuristics in model
+    model->doHeuristicsAtRoot(2);
     if (logLevel<=1)
       model2.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
@@ -1573 +1588 @@
     bool cleanModel = !model2.numberIntegers()&&!model2.numberObjects();
     model2.findIntegers(false);
-    model2.doHeuristicsAtRoot(true);
+    model2.doHeuristicsAtRoot(1);
     if (cleanModel)
       model2.zapIntegerInformation(false);
@@ -3630 +3645 @@
                 if (!solver2)
                   break;
+                if (model.bestSolution()) {
+                  // need to redo - in case no better found in BAB
+                  // just get integer part right
+                  const int * originalColumns = process.originalColumns();
+                  int numberColumns = solver2->getNumCols();
+                  double * bestSolution = babModel->bestSolution();
+                  const double * oldBestSolution = model.bestSolution();
+                  for (int i=0;i<numberColumns;i++) {
+                    int jColumn = originalColumns[i];
+                    bestSolution[i]=oldBestSolution[jColumn];
+                  }
+                }
                 //solver2->resolve();
                 if (preProcess==2) {