Changeset 97

Timestamp:

Mar 31, 2005 4:42:42 PM (16 years ago)

Author:

forrest

Message:

for OsiCbc?

Location:

trunk

Files:

• CbcBranchActual.cpp (modified) (3 diffs)
• CbcCompareActual.cpp (modified) (7 diffs)
• CbcModel.cpp (modified) (12 diffs)
• CbcStrategy.cpp (added)
• include/CbcCompareActual.hpp (modified) (2 diffs)
• include/CbcModel.hpp (modified) (5 diffs)
• include/CbcStrategy.hpp (added)

trunk/CbcBranchActual.cpp

@@ -2189 +2189 @@
   //printf("way %d\n",way);
   // create object
+  //printf("would fix %d down and %d up\n",nDown,nUp);
   CbcBranchingObject * branch
      = new CbcFixingBranchingObject(model_,way,
@@ -2270 +2271 @@
     printf("Down Fix ");
 #endif
+    //printf("Down Fix %d\n",numberDown_);
     for (i=0;i<numberDown_;i++) {
       int iColumn = downList_[i];
@@ -2282 +2284 @@
     printf("Up Fix ");
 #endif
+    //printf("Up Fix %d\n",numberUp_);
     for (i=0;i<numberUp_;i++) {
       int iColumn = upList_[i];

trunk/CbcCompareActual.cpp

@@ -113 +113 @@
   : CbcCompareBase(),
     weight_(-1.0),
+    saveWeight_(0.0),
     numberSolutions_(0),
     treeSize_(0)
@@ -123 +124 @@
   : CbcCompareBase(),
     weight_(weight) ,
+    saveWeight_(0.0),
     numberSolutions_(0),
     treeSize_(0)
@@ -136 +138 @@
 {
   weight_=rhs.weight_;
+  saveWeight_ = rhs.saveWeight_;
   numberSolutions_=rhs.numberSolutions_;
   treeSize_ = rhs.treeSize_;
@@ -154 +157 @@
     CbcCompareBase::operator=(rhs);
     weight_=rhs.weight_;
+    saveWeight_ = rhs.saveWeight_;
     numberSolutions_=rhs.numberSolutions_;
     treeSize_ = rhs.treeSize_;
@@ -169 +173 @@
 CbcCompareDefault::test (CbcNode * x, CbcNode * y)
 {
+#if 0
+  // was
   if (weight_<0.0||treeSize_>100000) {
     // before solution
@@ -185 +191 @@
       y->objectiveValue() + weight_*y->numberUnsatisfied();
   }
+#else
+  if (weight_==-1.0) {
+    // before solution
+    /* printf("x %d %d %g, y %d %d %g\n",
+       x->numberUnsatisfied(),x->depth(),x->objectiveValue(),
+       y->numberUnsatisfied(),y->depth(),y->objectiveValue()); */
+    if (x->numberUnsatisfied() > y->numberUnsatisfied())
+      return true;
+    else if (x->numberUnsatisfied() < y->numberUnsatisfied())
+      return false;
+    else
+      return x->depth() < y->depth();
+  } else {
+    // after solution
+    double weight = CoinMax(weight_,0.0);
+    return x->objectiveValue()+ weight*x->numberUnsatisfied() > 
+      y->objectiveValue() + weight*y->numberUnsatisfied();
+  }
+#endif
 }
 // This allows method to change behavior as it is called
@@ -208 +233 @@
 CbcCompareDefault::every1000Nodes(CbcModel * model, int numberNodes)
 {
+#if 0
+  // was
   if (numberNodes>10000)
     weight_ =0.0; // this searches on objective
   // get size of tree
   treeSize_ = model->tree()->size();
+#else
+  if (numberNodes>10000)
+    weight_ =0.0; // this searches on objective
+  else if (numberNodes==1000&&weight_==-2.0)
+    weight_=-1.0; // Go to depth first
+  // get size of tree
+  treeSize_ = model->tree()->size();
+  if (treeSize_>10000) {
+    // set weight to reduce size most of time
+    if (treeSize_>20000)
+      weight_=-1.0;
+    else if ((numberNodes%4000)!=0)
+      weight_=-1.0;
+    else
+      weight_=saveWeight_;
+  }
+#endif
   return numberNodes==11000; // resort if first time
 }

trunk/CbcModel.cpp

@@ -19 +19 @@
 #include "CbcHeuristic.hpp"
 #include "CbcModel.hpp"
+#include "CbcStrategy.hpp"
 #include "CbcMessage.hpp"
 #include "OsiRowCut.hpp"
@@ -376 +377 @@
 
 {
+  // Set up strategies
+  if (strategy_) {
+    strategy_->setupCutGenerators(*this);
+    strategy_->setupHeuristics(*this);
+    strategy_->setupPrinting(*this);
+    strategy_->setupOther(*this);
+  }
 # ifdef CBC_DEBUG
   std::string problemName ;
@@ -489 +497 @@
   (problems which require further exploration).
 */
-  CbcCompareObjective compareObjective ;
-  CbcCompareDepth compareDepth ;
-  CbcCompareDefault compareDefault ;
-  if (!nodeCompare_)
-    tree_->setComparison(compareDefault) ;
-  else
-    tree_->setComparison(*nodeCompare_) ;
+  tree_->setComparison(*nodeCompare_) ;
 /*
   Used to record the path from a node to the root of the search tree, so that
@@ -728 +730 @@
       // Do from deepest
       tree_->cleanTree(this, getCutoff(),bestPossibleObjective_) ;
-      if (!nodeCompare_) {
-        if (!compareDefault.getWeight()) {
-          // set to get close to this
-          double costPerInteger = 
-            (bestObjective_-continuousObjective_)/
-            ((double) continuousInfeasibilities_) ;
-          compareDefault.setWeight(0.98*costPerInteger) ;
-          /*printf("Setting weight per infeasibility to %g\n",
-            0.98*costPerInteger);*/
-        }
-        tree_->setComparison(compareDefault) ;
-        //tree_->setComparison(compareObjective) ;
-      } else {
-        nodeCompare_->newSolution(this) ;
-        nodeCompare_->newSolution(this,continuousObjective_,
-                                  continuousInfeasibilities_) ;
-        tree_->setComparison(*nodeCompare_) ;
-      }
+      nodeCompare_->newSolution(this) ;
+      nodeCompare_->newSolution(this,continuousObjective_,
+                                continuousInfeasibilities_) ;
+      tree_->setComparison(*nodeCompare_) ;
       if (tree_->empty())
         break; // finished
@@ -756 +744 @@
     + print a summary line to let the user know we're working
 */
-    if ((numberNodes_%1000) == 0&&nodeCompare_) {
+    if ((numberNodes_%1000) == 0) {
       bool redoTree=nodeCompare_->every1000Nodes(this, numberNodes_) ;
       // redo tree if wanted
@@ -1297 +1285 @@
   dblParam_[CbcMaximumSeconds] = 1.0e100;
   dblParam_[CbcStartSeconds] = 0.0;
-  nodeCompare_=NULL;
+  nodeCompare_=new CbcCompareDefault();;
   tree_= new CbcTree();
   branchingMethod_=NULL;
+  strategy_=NULL;
+  parentModel_=NULL;
   appData_=NULL;
   handler_ = new CoinMessageHandler();
@@ -1371 +1361 @@
   dblParam_[CbcStartSeconds] = 0.0;
 
-  nodeCompare_=NULL;
+  nodeCompare_=new CbcCompareDefault();;
   tree_= new CbcTree();
   branchingMethod_=NULL;
+  strategy_=NULL;
+  parentModel_=NULL;
   appData_=NULL;
   handler_ = new CoinMessageHandler();
@@ -1576 +1568 @@
     originalColumns_=NULL;
   }
-  nodeCompare_=rhs.nodeCompare_;
+  nodeCompare_=rhs.nodeCompare_->clone();
   tree_= rhs.tree_->clone();
   branchingMethod_=rhs.branchingMethod_;
+  if (rhs.strategy_)
+    strategy_=rhs.strategy_->clone();
+  else
+    strategy_=NULL;
+  parentModel_=rhs.parentModel_;
   appData_=rhs.appData_;
   messages_ = rhs.messages_;
@@ -1786 +1783 @@
       originalColumns_=NULL;
     }
-    nodeCompare_=rhs.nodeCompare_;
+    nodeCompare_=rhs.nodeCompare_->clone();
     delete tree_;
     tree_= rhs.tree_->clone();
     branchingMethod_=rhs.branchingMethod_;
+    delete strategy_;
+    if (rhs.strategy_)
+      strategy_=rhs.strategy_->clone();
+    else
+      strategy_=NULL;
+    parentModel_=rhs.parentModel_;
     appData_=rhs.appData_;
 
@@ -1865 +1868 @@
   delete [] heuristic_;
   heuristic_=NULL;
+  delete nodeCompare_;
+  nodeCompare_=NULL;
   delete [] addedCuts_;
   addedCuts_=NULL;
@@ -1879 +1884 @@
   delete [] originalColumns_;
   originalColumns_=NULL;
+  delete strategy_;
 }
 // Are there a numerical difficulties?
@@ -5323 +5329 @@
   return CoinMin(bestPossibleObjective_,bestObjective_) * solver_->getObjSense() ;
 }
+// Make given rows (L or G) into global cuts and remove from lp
+void 
+CbcModel::makeGlobalCuts(int number,const int * which)
+{
+  const double * rowLower = solver_->getRowLower();
+  const double * rowUpper = solver_->getRowUpper();
+
+  int numberRows = solver_->getNumRows();
+
+  // Row copy
+  const double * elementByRow = solver_->getMatrixByRow()->getElements();
+  const int * column = solver_->getMatrixByRow()->getIndices();
+  const CoinBigIndex * rowStart = solver_->getMatrixByRow()->getVectorStarts();
+  const int * rowLength = solver_->getMatrixByRow()->getVectorLengths();
+
+  // Not all rows may be good so we need new array
+  int * whichDelete = new int[numberRows];
+  int nDelete=0;
+  for (int i=0;i<number;i++) {
+    int iRow = which[i];
+    if (iRow>=0&&iRow<numberRows) {
+      if (rowLower[iRow]<-1.0e20||rowUpper[iRow]>1.0e20) {
+        whichDelete[nDelete++]=iRow;
+        OsiRowCut  thisCut;
+        thisCut.setLb(rowLower[iRow]);
+        thisCut.setUb(rowUpper[iRow]);
+        int start = rowStart[iRow];
+        thisCut.setRow(rowLength[iRow],column+start,elementByRow+start);
+        globalCuts_.insert(thisCut) ;
+      }
+    }
+  }
+  if (nDelete)
+    solver_->deleteRows(nDelete,whichDelete);
+  delete [] whichDelete;
+}
+void 
+CbcModel::setNodeComparison(CbcCompareBase * compare)
+{ 
+  delete nodeCompare_;
+  nodeCompare_ = compare->clone();
+}
+void 
+CbcModel::setNodeComparison(CbcCompareBase & compare)
+{ 
+  delete nodeCompare_;
+  nodeCompare_ = compare.clone();
+}
+// Set the strategy. Clones
+void 
+CbcModel::setStrategy(CbcStrategy & strategy)
+{
+  delete strategy_;
+  strategy_ = strategy.clone();
+}

trunk/include/CbcCompareActual.hpp

@@ -88 +88 @@
   virtual bool every1000Nodes(CbcModel * model,int numberNodes);
 
+  /* if weight == -1.0 then depth first (before solution)
+     if -2.0 then do breadth first just for first 1000 nodes
+  */
   inline double getWeight() const
   { return weight_;};
@@ -95 +98 @@
   // Weight for each infeasibility
   double weight_;
+  // Weight for each infeasibility - computed from solution
+  double saveWeight_;
   // Number of solutions
   int numberSolutions_;

trunk/include/CbcModel.hpp

@@ -24 +24 @@
 class CbcObject;
 class CbcTree;
+class CbcStrategy;
 
 //#############################################################################
@@ -221 +222 @@
     */
     bool resolve();
+  /// Make given rows (L or G) into global cuts and remove from lp
+  void makeGlobalCuts(int numberRows,const int * which); 
   //@}
 
@@ -850 +853 @@
   inline CbcCompareBase * nodeComparison() const
   { return nodeCompare_;};
-  inline void setNodeComparison(CbcCompareBase * compare)
-  { nodeCompare_ = compare;};
-  inline void setNodeComparison(CbcCompareBase & compare)
-  { nodeCompare_ = &compare;};
+  void setNodeComparison(CbcCompareBase * compare);
+  void setNodeComparison(CbcCompareBase & compare);
   //@}
 
@@ -1009 +1010 @@
                        int whatDepth=-1, int whatDepthInSub=-1);
 //@}
+  /** \name Strategy and sub models
+  
+    See the CbcStrategy class for additional information.
+  */
+  //@{
+
+  /// Get the current strategy
+  inline CbcStrategy * strategy() const
+  { return strategy_;};
+  /// Set the strategy. Clones
+  void setStrategy(CbcStrategy & strategy);
+  /// Get the current parent model
+  inline CbcModel * parentModel() const
+  { return parentModel_;};
+  /// Set the parent model
+  inline void setParentModel(CbcModel & parentModel)
+  { parentModel_ = &parentModel;};
+  //@}
+
 
   /** \name Heuristics and priorities */
@@ -1277 +1297 @@
   /// Variable selection function
   CbcBranchDecision * branchingMethod_;
+  /// Strategy
+  CbcStrategy * strategy_;
+  /// Parent model
+  CbcModel * parentModel_;
   /** Whether to automatically do presolve before branch and bound.
       0 - no