Changeset 640 for trunk/Cbc/examples

Timestamp:

Jun 26, 2007 5:17:15 AM (13 years ago)

Author:

forrest

Message:

trunk from branches/devel

Location:

trunk

Files:

• . (modified) (1 prop)
• Cbc/examples/CbcBranchLink.cpp (modified) (28 diffs)
• Cbc/examples/CbcBranchLink.hpp (modified) (4 diffs)
• Cbc/examples/CbcBranchUser.cpp (modified) (1 diff)
• Cbc/examples/CbcBranchUser.hpp (modified) (2 diffs)
• Cbc/examples/CbcCompareUser.cpp (modified) (2 diffs)
• Cbc/examples/Makefile.in (modified) (3 diffs)
• Cbc/examples/qmip2.cpp (modified) (2 diffs)

trunk

@@ -1 @@
-MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/trunk/ExternalsDirs/Cbc
-BuildTools    https://projects.coin-or.org/svn/BuildTools/stable/0.5
+MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/branches/devel/ExternalsDirs/Cbc
+BuildTools    https://projects.coin-or.org/svn/BuildTools/trunk
 ThirdParty/ASL https://projects.coin-or.org/svn/BuildTools/ThirdParty/ASL/stable/1.0
+ThirdParty/Blas https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.0
+ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.0
 Data/Netlib   https://projects.coin-or.org/svn/Data/stable/1.0/Netlib
 Data/Sample   https://projects.coin-or.org/svn/Data/stable/1.0/Sample

@@ -1 @@
-MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/trunk/ExternalsDirs/Cbc
-BuildTools    https://projects.coin-or.org/svn/BuildTools/stable/0.5
+MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/branches/devel/ExternalsDirs/Cbc
+BuildTools    https://projects.coin-or.org/svn/BuildTools/trunk
 ThirdParty/ASL https://projects.coin-or.org/svn/BuildTools/ThirdParty/ASL/stable/1.0
+ThirdParty/Blas https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.0
+ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.0
 Data/Netlib   https://projects.coin-or.org/svn/Data/stable/1.0/Netlib
 Data/Sample   https://projects.coin-or.org/svn/Data/stable/1.0/Sample

trunk/Cbc/examples/CbcBranchLink.cpp

@@ -15 +15 @@
 #include "CbcBranchLink.hpp"
 #include "CoinError.hpp"
+#include "CoinPackedMatrix.hpp"
 
 // Default Constructor 
@@ -22 +23 @@
     numberMembers_(0),
     numberLinks_(0),
-    first_(-1)
+    which_(NULL),
+    sosType_(1)
 {
 }
@@ -32 +34 @@
     numberMembers_(numberMembers),
     numberLinks_(numberLinks),
-    first_(first)
+    which_(NULL),
+    sosType_(1)
 {
   id_=identifier;
   if (numberMembers_) {
     weights_ = new double[numberMembers_];
+    which_ = new int[numberMembers_*numberLinks_];
     if (weights) {
       memcpy(weights_,weights,numberMembers_*sizeof(double));
@@ -50 +54 @@
       last=weights_[i];
     }
+    for (i=0;i<numberMembers_*numberLinks_;i++) {
+      which_[i]=first+i;
+    }
+  } else {
+    weights_ = NULL;
+  }
+}
+
+// Useful constructor (which are indices)
+CbcLink::CbcLink (CbcModel * model,  int numberMembers,
+           int numberLinks, int sosType, const int * which , const double * weights, int identifier)
+  : CbcObject(model),
+    numberMembers_(numberMembers),
+    numberLinks_(numberLinks),
+    which_(NULL),
+    sosType_(sosType)
+{
+  id_=identifier;
+  if (numberMembers_) {
+    weights_ = new double[numberMembers_];
+    which_ = new int[numberMembers_*numberLinks_];
+    if (weights) {
+      memcpy(weights_,weights,numberMembers_*sizeof(double));
+    } else {
+      for (int i=0;i<numberMembers_;i++)
+        weights_[i]=i;
+    }
+    // weights must be increasing
+    int i;
+    double last=-COIN_DBL_MAX;
+    for (i=0;i<numberMembers_;i++) {
+      assert (weights_[i]>last+1.0e-12);
+      last=weights_[i];
+    }
+    for (i=0;i<numberMembers_*numberLinks_;i++) {
+      which_[i]= which[i];
+    }
   } else {
     weights_ = NULL;
@@ -61 +102 @@
   numberMembers_ = rhs.numberMembers_;
   numberLinks_ = rhs.numberLinks_;
-  first_ = rhs.first_;
+  sosType_ = rhs.sosType_;
   if (numberMembers_) {
-    weights_ = new double[numberMembers_];
-    memcpy(weights_,rhs.weights_,numberMembers_*sizeof(double));
+    weights_ = CoinCopyOfArray(rhs.weights_,numberMembers_);
+    which_ = CoinCopyOfArray(rhs.which_,numberMembers_*numberLinks_);
   } else {
     weights_ = NULL;
+    which_ = NULL;
   }
 }
@@ -84 +126 @@
     CbcObject::operator=(rhs);
     delete [] weights_;
+    delete [] which_;
     numberMembers_ = rhs.numberMembers_;
     numberLinks_ = rhs.numberLinks_;
-    first_ = rhs.first_;
+    sosType_ = rhs.sosType_;
     if (numberMembers_) {
-      weights_ = new double[numberMembers_];
-      memcpy(weights_,rhs.weights_,numberMembers_*sizeof(double));
+      weights_ = CoinCopyOfArray(rhs.weights_,numberMembers_);
+      which_ = CoinCopyOfArray(rhs.which_,numberMembers_*numberLinks_);
     } else {
       weights_ = NULL;
+      which_ = NULL;
     }
   }
@@ -101 +145 @@
 {
   delete [] weights_;
+  delete [] which_;
 }
 
@@ -112 +157 @@
   OsiSolverInterface * solver = model_->solver();
   const double * solution = model_->testSolution();
-  const double * lower = solver->getColLower();
+  //const double * lower = solver->getColLower();
   const double * upper = solver->getColUpper();
   double integerTolerance = 
@@ -121 +166 @@
   // check bounds etc
   double lastWeight=-1.0e100;
-  int base=first_;
+  int base=0;
   for (j=0;j<numberMembers_;j++) {
     for (int k=0;k<numberLinks_;k++) {
-      int iColumn = base+k;
-      if (lower[iColumn])
-        throw CoinError("Non zero lower bound in CBCLink","infeasibility","CbcLink");
+      int iColumn = which_[base+k];
+      //if (lower[iColumn])
+      //throw CoinError("Non zero lower bound in CBCLink","infeasibility","CbcLink");
       if (lastWeight>=weights_[j]-1.0e-7)
         throw CoinError("Weights too close together in CBCLink","infeasibility","CbcLink");
@@ -141 +186 @@
 #endif
         } 
-        weight += weights_[j]*CoinMin(value,upper[iColumn]);
+        value = CoinMin(value,upper[iColumn]);
+        weight += weights_[j]*value;
         if (firstNonZero<0)
           firstNonZero=j;
@@ -149 +195 @@
     base += numberLinks_;
   }
+  double valueInfeasibility;
   preferredWay=1;
-  if (lastNonZero-firstNonZero>=1) {
+  if (lastNonZero-firstNonZero>=sosType_) {
     // find where to branch
     assert (sum>0.0);
     weight /= sum;
-    double value = lastNonZero-firstNonZero+1;
-    value *= 0.5/((double) numberMembers_);
-    return value;
+    valueInfeasibility = lastNonZero-firstNonZero+1;
+    valueInfeasibility *= 0.5/((double) numberMembers_);
+    //#define DISTANCE
+#ifdef DISTANCE
+    assert (sosType_==1); // code up
+    /* may still be satisfied.
+       For LOS type 2 we might wish to move coding around
+       and keep initial info in model_ for speed
+    */
+    int iWhere;
+    bool possible=false;
+    for (iWhere=firstNonZero;iWhere<=lastNonZero;iWhere++) {
+      if (fabs(weight-weights_[iWhere])<1.0e-8) {
+        possible=true;
+        break;
+      }
+    }
+    if (possible) {
+      // One could move some of this (+ arrays) into model_
+      const CoinPackedMatrix * matrix = solver->getMatrixByCol();
+      const double * element = matrix->getMutableElements();
+      const int * row = matrix->getIndices();
+      const CoinBigIndex * columnStart = matrix->getVectorStarts();
+      const int * columnLength = matrix->getVectorLengths();
+      const double * rowSolution = solver->getRowActivity();
+      const double * rowLower = solver->getRowLower();
+      const double * rowUpper = solver->getRowUpper();
+      int numberRows = matrix->getNumRows();
+      double * array = new double [numberRows];
+      CoinZeroN(array,numberRows);
+      int * which = new int [numberRows];
+      int n=0;
+      int base=numberLinks_*firstNonZero;
+      for (j=firstNonZero;j<=lastNonZero;j++) {
+        for (int k=0;k<numberLinks_;k++) {
+          int iColumn = which_[base+k];
+          double value = CoinMax(0.0,solution[iColumn]);
+          if (value>integerTolerance&&upper[iColumn]) {
+            value = CoinMin(value,upper[iColumn]);
+            for (int j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
+              int iRow = row[j];
+              double a = array[iRow];
+              if (a) {
+                a += value*element[j];
+                if (!a)
+                  a = 1.0e-100;
+              } else {
+                which[n++]=iRow;
+                a=value*element[j];
+                assert (a);
+              }
+              array[iRow]=a;
+            }
+          }
+        }
+        base += numberLinks_;
+      }
+      base=numberLinks_*iWhere;
+      for (int k=0;k<numberLinks_;k++) {
+        int iColumn = which_[base+k];
+        const double value = 1.0;
+        for (int j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
+          int iRow = row[j];
+          double a = array[iRow];
+          if (a) {
+            a -= value*element[j];
+            if (!a)
+              a = 1.0e-100;
+          } else {
+            which[n++]=iRow;
+            a=-value*element[j];
+            assert (a);
+          }
+          array[iRow]=a;
+        }
+      }
+      for (j=0;j<n;j++) {
+        int iRow = which[j];
+        // moving to point will increase row solution by this
+        double distance = array[iRow];
+        if (distance>1.0e-8) {
+          if (distance+rowSolution[iRow]>rowUpper[iRow]+1.0e-8) {
+            possible=false;
+            break;
+          }
+        } else if (distance<-1.0e-8) {
+          if (distance+rowSolution[iRow]<rowLower[iRow]-1.0e-8) {
+            possible=false;
+            break;
+          } 
+        }
+      }
+      for (j=0;j<n;j++)
+        array[which[j]]=0.0;
+      delete [] array;
+      delete [] which;
+      if (possible) {
+        valueInfeasibility=0.0;
+        printf("possible %d %d %d\n",firstNonZero,lastNonZero,iWhere);
+      }
+    }
+#endif
   } else {
-    return 0.0; // satisfied
-  }
+    valueInfeasibility = 0.0; // satisfied
+  }
+  return valueInfeasibility;
 }
 
@@ -177 +324 @@
   double sum =0.0;
 
-  int base=first_;
+  int base=0;
   for (j=0;j<numberMembers_;j++) {
     for (int k=0;k<numberLinks_;k++) {
-      int iColumn = base+k;
+      int iColumn = which_[base+k];
       double value = CoinMax(0.0,solution[iColumn]);
       sum += value;
@@ -192 +339 @@
     base += numberLinks_;
   }
-  assert (lastNonZero-firstNonZero==0) ;
-  base=first_;
+#ifdef DISTANCE
+  if (lastNonZero-firstNonZero>sosType_-1) {
+    /* may still be satisfied.
+       For LOS type 2 we might wish to move coding around
+       and keep initial info in model_ for speed
+    */
+    int iWhere;
+    bool possible=false;
+    for (iWhere=firstNonZero;iWhere<=lastNonZero;iWhere++) {
+      if (fabs(weight-weights_[iWhere])<1.0e-8) {
+        possible=true;
+        break;
+      }
+    }
+    if (possible) {
+      // One could move some of this (+ arrays) into model_
+      const CoinPackedMatrix * matrix = solver->getMatrixByCol();
+      const double * element = matrix->getMutableElements();
+      const int * row = matrix->getIndices();
+      const CoinBigIndex * columnStart = matrix->getVectorStarts();
+      const int * columnLength = matrix->getVectorLengths();
+      const double * rowSolution = solver->getRowActivity();
+      const double * rowLower = solver->getRowLower();
+      const double * rowUpper = solver->getRowUpper();
+      int numberRows = matrix->getNumRows();
+      double * array = new double [numberRows];
+      CoinZeroN(array,numberRows);
+      int * which = new int [numberRows];
+      int n=0;
+      int base=numberLinks_*firstNonZero;
+      for (j=firstNonZero;j<=lastNonZero;j++) {
+        for (int k=0;k<numberLinks_;k++) {
+          int iColumn = which_[base+k];
+          double value = CoinMax(0.0,solution[iColumn]);
+          if (value>integerTolerance&&upper[iColumn]) {
+            value = CoinMin(value,upper[iColumn]);
+            for (int j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
+              int iRow = row[j];
+              double a = array[iRow];
+              if (a) {
+                a += value*element[j];
+                if (!a)
+                  a = 1.0e-100;
+              } else {
+                which[n++]=iRow;
+                a=value*element[j];
+                assert (a);
+              }
+              array[iRow]=a;
+            }
+          }
+        }
+        base += numberLinks_;
+      }
+      base=numberLinks_*iWhere;
+      for (int k=0;k<numberLinks_;k++) {
+        int iColumn = which_[base+k];
+        const double value = 1.0;
+        for (int j=columnStart[iColumn];j<columnStart[iColumn]+columnLength[iColumn];j++) {
+          int iRow = row[j];
+          double a = array[iRow];
+          if (a) {
+            a -= value*element[j];
+            if (!a)
+              a = 1.0e-100;
+          } else {
+            which[n++]=iRow;
+            a=-value*element[j];
+            assert (a);
+          }
+          array[iRow]=a;
+        }
+      }
+      for (j=0;j<n;j++) {
+        int iRow = which[j];
+        // moving to point will increase row solution by this
+        double distance = array[iRow];
+        if (distance>1.0e-8) {
+          if (distance+rowSolution[iRow]>rowUpper[iRow]+1.0e-8) {
+            possible=false;
+            break;
+          }
+        } else if (distance<-1.0e-8) {
+          if (distance+rowSolution[iRow]<rowLower[iRow]-1.0e-8) {
+            possible=false;
+            break;
+          } 
+        }
+      }
+      for (j=0;j<n;j++)
+        array[which[j]]=0.0;
+      delete [] array;
+      delete [] which;
+      if (possible) {
+        printf("possible feas region %d %d %d\n",firstNonZero,lastNonZero,iWhere);
+        firstNonZero=iWhere;
+        lastNonZero=iWhere;
+      }
+    }
+  }
+#else
+  assert (lastNonZero-firstNonZero<sosType_) ;
+#endif
+  base=0;
   for (j=0;j<firstNonZero;j++) {
     for (int k=0;k<numberLinks_;k++) {
-      int iColumn = base+k;
+      int iColumn = which_[base+k];
       solver->setColUpper(iColumn,0.0);
     }
@@ -205 +454 @@
   for (j=lastNonZero+1;j<numberMembers_;j++) {
     for (int k=0;k<numberLinks_;k++) {
-      int iColumn = base+k;
+      int iColumn = which_[base+k];
       solver->setColUpper(iColumn,0.0);
     }
@@ -229 +478 @@
   double weight = 0.0;
   double sum =0.0;
-  int base=first_;
+  int base=0;
   for (j=0;j<numberMembers_;j++) {
     for (int k=0;k<numberLinks_;k++) {
-      int iColumn = base+k;
+      int iColumn = which_[base+k];
       if (upper[iColumn]) {
         double value = CoinMax(0.0,solution[iColumn]);
@@ -249 +498 @@
     base += numberLinks_;
   }
-  assert (lastNonZero-firstNonZero>=1) ;
+  assert (lastNonZero-firstNonZero>=sosType_) ;
   // find where to branch
   assert (sum>0.0);
@@ -258 +507 @@
     if (weight<weights_[iWhere+1])
       break;
-  separator = 0.5 *(weights_[iWhere]+weights_[iWhere+1]);
+  if (sosType_==1) {
+    // SOS 1
+    separator = 0.5 *(weights_[iWhere]+weights_[iWhere+1]);
+  } else {
+    // SOS 2
+    if (iWhere==firstNonFixed)
+      iWhere++;;
+    if (iWhere==lastNonFixed-1)
+      iWhere = lastNonFixed-2;
+    separator = weights_[iWhere+1];
+  }
   // create object
   CbcBranchingObject * branch;
@@ -305 +564 @@
 }
 double
-CbcLinkBranchingObject::branch(bool normalBranch)
-{
-  if (model_->messageHandler()->logLevel()>2&&normalBranch)
-    print(normalBranch);
-  numberBranchesLeft_--;
+CbcLinkBranchingObject::branch()
+{
+  decrementNumberBranchesLeft();
   int numberMembers = set_->numberMembers();
   int numberLinks = set_->numberLinks();
   const double * weights = set_->weights();
+  const int * which = set_->which();
   OsiSolverInterface * solver = model_->solver();
   //const double * lower = solver->getColLower();
@@ -324 +582 @@
     }
     assert (i<numberMembers);
-    int base=set_->first()+i*numberLinks;;
+    int base=i*numberLinks;;
     for (;i<numberMembers;i++) {
       for (int k=0;k<numberLinks;k++) {
-        int iColumn = base+k;
+        int iColumn = which[base+k];
         solver->setColUpper(iColumn,0.0);
       }
@@ -335 +593 @@
   } else {
     int i;
-    int base=set_->first();
+    int base=0;
     for ( i=0;i<numberMembers;i++) { 
       if (weights[i] >= separator_) {
@@ -341 +599 @@
       } else {
         for (int k=0;k<numberLinks;k++) {
-          int iColumn = base+k;
+          int iColumn = which[base+k];
           solver->setColUpper(iColumn,0.0);
         }
@@ -354 +612 @@
 // Print what would happen  
 void
-CbcLinkBranchingObject::print(bool normalBranch)
+CbcLinkBranchingObject::print()
 {
   int numberMembers = set_->numberMembers();
   int numberLinks = set_->numberLinks();
   const double * weights = set_->weights();
+  const int * which = set_->which();
   OsiSolverInterface * solver = model_->solver();
   const double * upper = solver->getColUpper();
@@ -366 +625 @@
   int numberOther=0;
   int i;
-  int base=set_->first();
+  int base=0;
   for ( i=0;i<numberMembers;i++) {
     for (int k=0;k<numberLinks;k++) {
-      int iColumn = base+k;
+      int iColumn = which[base+k];
       double bound = upper[iColumn];
       if (bound) {
@@ -379 +638 @@
   }
   // *** for way - up means fix all those in down section
-  base=set_->first();
+  base=0;
   if (way_<0) {
     printf("SOS Down");
     for ( i=0;i<numberMembers;i++) {
+      if (weights[i] > separator_) 
+        break;
       for (int k=0;k<numberLinks;k++) {
-        int iColumn = base+k;
+        int iColumn = which[base+k];
         double bound = upper[iColumn];
-        if (weights[i] > separator_)
-          break;
-        else if (bound)
+        if (bound)
           numberOther++;
       }
@@ -396 +655 @@
     for (;i<numberMembers;i++) {
       for (int k=0;k<numberLinks;k++) {
-        int iColumn = base+k;
+        int iColumn = which[base+k];
         double bound = upper[iColumn];
         if (bound)
@@ -406 +665 @@
     printf("SOS Up");
     for ( i=0;i<numberMembers;i++) {
+      if (weights[i] >= separator_)
+        break;
       for (int k=0;k<numberLinks;k++) {
-        int iColumn = base+k;
+        int iColumn = which[base+k];
         double bound = upper[iColumn];
-        if (weights[i] >= separator_)
-          break;
-        else if (bound)
+        if (bound)
           numberFixed++;
       }
@@ -419 +678 @@
     for (;i<numberMembers;i++) {
       for (int k=0;k<numberLinks;k++) {
-        int iColumn = base+k;
+        int iColumn = which[base+k];
         double bound = upper[iColumn];
         if (bound)
@@ -428 +687 @@
   }
   assert ((numberFixed%numberLinks)==0);
-  assert ((numberFixed%numberOther)==0);
+  assert ((numberOther%numberLinks)==0);
   printf(" - at %g, free range %d (%g) => %d (%g), %d would be fixed, %d other way\n",
          separator_,first,weights[first],last,weights[last],numberFixed/numberLinks,

trunk/Cbc/examples/CbcBranchLink.hpp

@@ -21 +21 @@
       apart from k*numberLink to (k+1)*numberLink-1 where k is 0 through
       numberInSet-1.  The length of weights array is numberInSet.
-      For this simple version the variables in matrix are the numberInSet*numberLink
+      For this constructor the variables in matrix are the numberInSet*numberLink
       starting at first. If weights null then 0,1,2..
   */
   CbcLink (CbcModel * model, int numberMembers,
            int numberLinks, int first,
+           const double * weights, int setNumber);
+  /** Useful constructor - A valid solution is if all variables are zero
+      apart from k*numberLink to (k+1)*numberLink-1 where k is 0 through
+      numberInSet-1.  The length of weights array is numberInSet.
+      For this constructor the variables are given by list - grouped.
+      If weights null then 0,1,2..
+  */
+  CbcLink (CbcModel * model, int numberMembers,
+           int numberLinks, int typeSOS, const int * which,
            const double * weights, int setNumber);
   
@@ -56 +65 @@
   {return numberLinks_;};
 
-  /// First variable in matrix
-  inline int first() const
-  {return first_;};
+  /// Which variables
+  inline const int * which() const
+  {return which_;};
 
   /** Array of weights */
@@ -74 +83 @@
   /// Number of links
    int numberLinks_;
-  /// First member
-  int first_;
+  /// Members
+  int * which_;
+  /// Type 1 or 2
+  int sosType_;
 };
 /** Branching object for Special ordered sets
@@ -107 +118 @@
   
   /// Does next branch and updates state
-  virtual double branch(bool normalBranch=false);
+  virtual double branch();
 
   /** \brief Print something about branch - only if log level high
   */
-  virtual void print(bool normalBranch);
+  virtual void print();
 private:
   /// data

trunk/Cbc/examples/CbcBranchUser.cpp

@@ -323 +323 @@
   return whichObject;
 }
+/** Default Constructor
+
+  Equivalent to an unspecified binary variable.
+*/
+CbcSimpleIntegerFixed::CbcSimpleIntegerFixed ()
+  : CbcSimpleInteger()
+{
+}
+
+/** Useful constructor
+
+  Loads actual upper & lower bounds for the specified variable.
+*/
+CbcSimpleIntegerFixed::CbcSimpleIntegerFixed (CbcModel * model,
+                                    int iColumn, double breakEven)
+  : CbcSimpleInteger(model,iColumn,breakEven)
+{
+}
+// Constructor from simple
+CbcSimpleIntegerFixed::CbcSimpleIntegerFixed (const CbcSimpleInteger & rhs)
+  : CbcSimpleInteger(rhs)
+{
+}
+
+// Copy constructor 
+CbcSimpleIntegerFixed::CbcSimpleIntegerFixed ( const CbcSimpleIntegerFixed & rhs)
+  :CbcSimpleInteger(rhs)
+
+{
+}
+
+// Clone
+CbcObject *
+CbcSimpleIntegerFixed::clone() const
+{
+  return new CbcSimpleIntegerFixed(*this);
+}
+
+// Assignment operator 
+CbcSimpleIntegerFixed & 
+CbcSimpleIntegerFixed::operator=( const CbcSimpleIntegerFixed& rhs)
+{
+  if (this!=&rhs) {
+    CbcSimpleInteger::operator=(rhs);
+  }
+  return *this;
+}
+
+// Destructor 
+CbcSimpleIntegerFixed::~CbcSimpleIntegerFixed ()
+{
+}
+
+// Infeasibility - large is 0.5
+double 
+CbcSimpleIntegerFixed::infeasibility(int & preferredWay) const
+{
+  OsiSolverInterface * solver = model_->solver();
+  const double * solution = model_->testSolution();
+  const double * lower = solver->getColLower();
+  const double * upper = solver->getColUpper();
+  double value = solution[columnNumber_];
+  value = CoinMax(value, lower[columnNumber_]);
+  value = CoinMin(value, upper[columnNumber_]);
+  /*printf("%d %g %g %g %g\n",columnNumber_,value,lower[columnNumber_],
+    solution[columnNumber_],upper[columnNumber_]);*/
+  double nearest = floor(value+(1.0-breakEven_));
+  assert (breakEven_>0.0&&breakEven_<1.0);
+  double integerTolerance = 
+    model_->getDblParam(CbcModel::CbcIntegerTolerance);
+  if (nearest>value) 
+    preferredWay=1;
+  else
+    preferredWay=-1;
+  if (preferredWay_)
+    preferredWay=preferredWay_;
+  double weight = fabs(value-nearest);
+  // normalize so weight is 0.5 at break even
+  if (nearest<value)
+    weight = (0.5/breakEven_)*weight;
+  else
+    weight = (0.5/(1.0-breakEven_))*weight;
+  if (fabs(value-nearest)<=integerTolerance) {
+    if (upper[columnNumber_]==lower[columnNumber_])
+      return 0.0;
+    else
+      return 1.0e-5;
+  } else {
+    return weight;
+  }
+}
+// Creates a branching object
+CbcBranchingObject * 
+CbcSimpleIntegerFixed::createBranch(OsiSolverInterface * solver,
+                                            const OsiBranchingInformation * info, int way)  
+{
+  const double * solution = model_->testSolution();
+  const double * lower = solver->getColLower();
+  const double * upper = solver->getColUpper();
+  double value = solution[columnNumber_];
+  value = CoinMax(value, lower[columnNumber_]);
+  value = CoinMin(value, upper[columnNumber_]);
+  assert (upper[columnNumber_]>lower[columnNumber_]);
+  if (!model_->hotstartSolution()) {
+    double nearest = floor(value+0.5);
+    double integerTolerance = 
+    model_->getDblParam(CbcModel::CbcIntegerTolerance);
+    if (fabs(value-nearest)<integerTolerance) {
+      // adjust value
+      if (nearest!=upper[columnNumber_])
+        value = nearest+2.0*integerTolerance;
+      else
+        value = nearest-2.0*integerTolerance;
+    }
+  } else {
+    const double * hotstartSolution = model_->hotstartSolution();
+    double targetValue = hotstartSolution[columnNumber_];
+    if (way>0)
+      value = targetValue-0.1;
+    else
+      value = targetValue+0.1;
+  }
+  CbcBranchingObject * branch = new CbcIntegerBranchingObject(model_,columnNumber_,way,
+                                             value);
+  branch->setOriginalObject(this);
+  return branch;
+}

trunk/Cbc/examples/CbcBranchUser.hpp

@@ -5 +5 @@
 
 #include "CbcBranchBase.hpp"
+#include "CbcBranchActual.hpp"
 
 /** Branching decision user class */
@@ -55 +56 @@
 };
 
+/// Define a single integer class where branching is forced until fixed
+
+
+class CbcSimpleIntegerFixed : public CbcSimpleInteger {
+
+public:
+
+  // Default Constructor 
+  CbcSimpleIntegerFixed ();
+
+  // Useful constructor - passed integer index and model index
+  CbcSimpleIntegerFixed (CbcModel * model, int iColumn, double breakEven=0.5);
+  
+  // Constructor from simple
+  CbcSimpleIntegerFixed (const CbcSimpleInteger & simple);
+  
+  // Copy constructor 
+  CbcSimpleIntegerFixed ( const CbcSimpleIntegerFixed &);
+   
+  /// Clone
+  virtual CbcObject * clone() const;
+
+  // Assignment operator 
+  CbcSimpleIntegerFixed & operator=( const CbcSimpleIntegerFixed& rhs);
+
+  // Destructor 
+  ~CbcSimpleIntegerFixed ();
+  
+  /// Infeasibility - large is 0.5
+  virtual double infeasibility(int & preferredWay) const;
+
+  /** Creates a branching object
+
+    The preferred direction is set by \p way, -1 for down, +1 for up.
+  */
+  //virtual CbcBranchingObject * createBranch(int way) ;
+  /** Create a branching object and indicate which way to branch first.
+      
+      The branching object has to know how to create branches (fix
+      variables, etc.)
+  */
+  virtual CbcBranchingObject * createBranch(OsiSolverInterface * solver,
+                                            const OsiBranchingInformation * info, int way) ;
+
+protected:
+  /// data
+};
+
 #endif

trunk/Cbc/examples/CbcCompareUser.cpp

@@ -82 +82 @@
 {
 }
-
+// For moment go to default
+#if 0
 // Returns true if y better than x
 bool 
@@ -179 +180 @@
   }
 }
+#else
+
+// Returns true if y better than x
+bool 
+CbcCompareUser::test (CbcNode * x, CbcNode * y)
+{
+  if (weight_==-1.0&&(y->depth()>7||x->depth()>7)) {
+    // 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 {
+      int testX = x->depth();
+      int testY = y->depth();
+      if (testX!=testY)
+        return testX < testY;
+      else
+        return equalityTest(x,y); // so ties will be broken in consistent manner
+    }
+  } else {
+    // after solution
+    double weight = CoinMax(weight_,0.0);
+    double testX =  x->objectiveValue()+ weight*x->numberUnsatisfied();
+    double testY = y->objectiveValue() + weight*y->numberUnsatisfied();
+    if (testX!=testY)
+      return testX > testY;
+    else
+      return equalityTest(x,y); // so ties will be broken in consistent manner
+  }
+}
+// This allows method to change behavior as it is called
+// after each solution
+void 
+CbcCompareUser::newSolution(CbcModel * model,
+                               double objectiveAtContinuous,
+                               int numberInfeasibilitiesAtContinuous) 
+{
+  if (model->getSolutionCount()==model->getNumberHeuristicSolutions()&&
+      model->getSolutionCount()<5&&model->getNodeCount()<500)
+    return; // solution was got by rounding
+  // set to get close to this solution
+  double costPerInteger = 
+    (model->getObjValue()-objectiveAtContinuous)/
+    ((double) numberInfeasibilitiesAtContinuous);
+  weight_ = 0.95*costPerInteger;
+  saveWeight_ = 0.95*weight_;
+  numberSolutions_++;
+  if (numberSolutions_>5)
+    weight_ =0.0; // this searches on objective
+}
+// This allows method to change behavior 
+bool 
+CbcCompareUser::every1000Nodes(CbcModel * model, int numberNodes)
+{
+  double saveWeight=weight_;
+  int numberNodes1000 = numberNodes/1000;
+  if (numberNodes>10000) {
+    weight_ =0.0; // this searches on objective
+    // but try a bit of other stuff
+    if ((numberNodes1000%4)==1)
+      weight_=saveWeight_;
+  } 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) {
+    int n1 = model->solver()->getNumRows()+model->solver()->getNumCols();
+    int n2 = model->numberObjects();
+    double size = n1*0.1 + n2*2.0;
+    // set weight to reduce size most of time
+    if (treeSize_*size>5.0e7)
+      weight_=-1.0;
+    else if ((numberNodes1000%4)==0&&treeSize_*size>1.0e6)
+      weight_=-1.0;
+    else if ((numberNodes1000%4)==1)
+      weight_=0.0;
+    else
+      weight_=saveWeight_;
+  }
+  return (weight_!=saveWeight);
+}
+// Returns true if wants code to do scan with alternate criterion
+bool 
+CbcCompareUser::fullScan() const
+{
+  return false;
+}
+// This is alternate test function
+bool 
+CbcCompareUser::alternateTest (CbcNode * x, CbcNode * y)
+{
+  // not used
+  abort();
+  return false;
+}
+#endif

trunk/Cbc/examples/Makefile.in

@@ -23 +23 @@
         CbcSolver2.@OBJEXT@ \
         CbcSolver3.@OBJEXT@ \
+        CbcSolverLink.@OBJEXT@ \
+        ClpDynamicInterface.@OBJEXT@ \
         ClpQuadInterface.@OBJEXT@ \
+        CoinWarmStartBasisDynamic.@OBJEXT@ \
         CbcBranchFollow2.@OBJEXT@ \
+        CbcBranchLotsizeSimple.@OBJEXT@ \
         CbcBranchUser.@OBJEXT@ \
         CbcBranchLink.@OBJEXT@
@@ -81 +85 @@
         driver2.@OBJEXT@ driver2@EXEEXT@ \
         driver.@OBJEXT@ driver@EXEEXT@ \
+        dynamic.@OBJEXT@ dynamic@EXEEXT@ \
         fast0507b.@OBJEXT@ fast0507b@EXEEXT@ \
         fast0507.@OBJEXT@ fast0507@EXEEXT@ \
@@ -111 +116 @@
 
 clean:
-        rm -rf $(CLEANFILES)
+        rm -rf $(CLEANFILES) $(OBJS)
 
 .cpp.o:

trunk/Cbc/examples/qmip2.cpp

@@ -188 +188 @@
   // This clones solver 
   CbcModel model(solver1);
-  // Add stored cuts
-  model.addCutGenerator(&stored,-1,"Stored");
+  // Add stored cuts (making sure at all depths)
+  model.addCutGenerator(&stored,1,"Stored",true,false,false,-100,1,-1);
   /*  You need the next few lines -
       a) so that cut generator will always be called again if it generated cuts
       b) it is known that matrix is not enough to define problem so do cuts even
          if it looks integer feasible at continuous optimum.
-      c) a solution found ny strong branching will be ignored.
+      c) a solution found by strong branching will be ignored.
+      d) don't recompute a solution once found
   */
   // Make sure cut generator called correctly (a)
@@ -205 +206 @@
   CbcFeasibilityNoStrong noStrong;
   model.setProblemFeasibility(noStrong);
+  // Say don't recompute solution d)
+  model.setSpecialOptions(4);
   
   double time1 = CoinCpuTime();

@@ -1 @@
-MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/trunk/ExternalsDirs/Cbc
-BuildTools    https://projects.coin-or.org/svn/BuildTools/stable/0.5
+MSVisualStudio   https://projects.coin-or.org/svn/MSVisualStudio/branches/devel/ExternalsDirs/Cbc
+BuildTools    https://projects.coin-or.org/svn/BuildTools/trunk
 ThirdParty/ASL https://projects.coin-or.org/svn/BuildTools/ThirdParty/ASL/stable/1.0
+ThirdParty/Blas https://projects.coin-or.org/svn/BuildTools/ThirdParty/Blas/stable/1.0
+ThirdParty/Lapack https://projects.coin-or.org/svn/BuildTools/ThirdParty/Lapack/stable/1.0
 Data/Netlib   https://projects.coin-or.org/svn/Data/stable/1.0/Netlib
 Data/Sample   https://projects.coin-or.org/svn/Data/stable/1.0/Sample