Changeset 692 for trunk

Timestamp:

Jul 16, 2007 4:20:32 PM (13 years ago)

Author:

forrest

Message:

changes so OsiIntegers? have pseudocosts updated on branch

Location:

trunk/Cbc/src

Files:

• CbcLinked.cpp (modified) (6 diffs)
• CbcLinked.hpp (modified) (1 diff)
• CbcModel.cpp (modified) (1 diff)

trunk/Cbc/src/CbcLinked.cpp

@@ -5712 +5712 @@
   double tolerance = info->primalTolerance_;
   double direction = info->direction_;
+  bool infeasible=false;
   if (xyRow_>=0) {
     assert (!boundType_);
@@ -5721 +5722 @@
     // if move makes infeasible then make at least default
     double newValue = activity[xyRow_] + movement*coefficient_;
-    if (newValue>upper[xyRow_]+tolerance||newValue<lower[xyRow_]-tolerance) 
+    if (newValue>upper[xyRow_]+tolerance||newValue<lower[xyRow_]-tolerance) {
       infeasibility_ += fabs(movement*coefficient_)*CoinMax(fabs(valueP),info->defaultDual_);
+      infeasible=true;
+    }
   } else {
     // objective
@@ -5737 +5740 @@
     // if move makes infeasible then make at least default
     double newValue = activity[iRow] + movement*multiplier_[i];
-    if (newValue>upper[iRow]+tolerance||newValue<lower[iRow]-tolerance) 
+    if (newValue>upper[iRow]+tolerance||newValue<lower[iRow]-tolerance) {
       infeasibility_ += fabs(movement*multiplier_[i])*CoinMax(fabs(valueP),info->defaultDual_);
-  }
-  if (infeasibility_<1.0e-7)
-    infeasibility_=0.0;
+      infeasible=true;
+    }
+  }
+  if (infeasibility_<info->integerTolerance_) {
+    if (!infeasible)
+      infeasibility_=0.0;
+    else
+      infeasibility_ = info->integerTolerance_;
+  }
   otherInfeasibility_ = CoinMax(1.0e-12,infeasibility_*10.0);
+}
+// Gets sum of movements to correct value
+double 
+OsiBiLinear::getMovement(const OsiBranchingInformation * info)
+{
+  // order is LxLy, LxUy, UxLy and UxUy
+  double xB[2];
+  double yB[2];
+  xB[0]=info->lower_[xColumn_];
+  xB[1]=info->upper_[xColumn_];
+  yB[0]=info->lower_[yColumn_];
+  yB[1]=info->upper_[yColumn_];
+  double x = info->solution_[xColumn_];
+  x = CoinMax(x,xB[0]);
+  x = CoinMin(x,xB[1]);
+  double y = info->solution_[yColumn_];
+  y = CoinMax(y,yB[0]);
+  y = CoinMin(y,yB[1]);
+  int j;
+  double xyTrue = x*y;
+  double xyLambda = 0.0;
+  if ((branchingStrategy_&4)==0) {
+    for (j=0;j<4;j++) {
+      int iX = j>>1;
+      int iY = j&1;
+      xyLambda += xB[iX]*yB[iY]*info->solution_[firstLambda_+j];
+    }
+  } else {
+    if (xyRow_>=0) {
+      const double * element = info->elementByColumn_;
+      const int * row = info->row_;
+      const CoinBigIndex * columnStart = info->columnStart_;
+      const int * columnLength = info->columnLength_;
+      for (j=0;j<4;j++) {
+        int iColumn = firstLambda_+j;
+        int iStart = columnStart[iColumn];
+        int iEnd = iStart + columnLength[iColumn];
+        int k=iStart;
+        double sol = info->solution_[iColumn];
+        for (;k<iEnd;k++) {
+          if (xyRow_==row[k])
+            xyLambda += element[k]*sol;
+        }
+      }
+    } else {
+      // objective
+      const double * objective = info->objective_;
+      for (j=0;j<4;j++) {
+        int iColumn = firstLambda_+j;
+        double sol = info->solution_[iColumn];
+        xyLambda += objective[iColumn]*sol;
+      }
+    }
+    xyLambda /= coefficient_;
+  }
+  // If we move to xy then we move by coefficient * (xyTrue-xyLambda) on row xyRow_
+  double movement = xyTrue-xyLambda;
+  const double * activity = info->rowActivity_;
+  const double * lower = info->rowLower_;
+  const double * upper = info->rowUpper_;
+  double tolerance = info->primalTolerance_;
+  double  infeasibility=0.0;
+  if (xyRow_>=0) {
+    assert (!boundType_);
+    // if move makes infeasible
+    double newValue = activity[xyRow_] + movement*coefficient_;
+    if (newValue>upper[xyRow_]+tolerance)
+      infeasibility += newValue-upper[xyRow_];
+    else if (newValue<lower[xyRow_]-tolerance)
+      infeasibility += lower[xyRow_]-newValue;
+  } else {
+    // objective
+    assert (movement>-1.0e-7);
+    infeasibility += movement;
+  }
+  for (int i=0;i<numberExtraRows_;i++) {
+    int iRow = extraRow_[i];
+    // if move makes infeasible
+    double newValue = activity[iRow] + movement*multiplier_[i];
+    if (newValue>upper[iRow]+tolerance)
+      infeasibility += newValue-upper[iRow];
+    else if (newValue<lower[iRow]-tolerance)
+      infeasibility += lower[iRow]-newValue;
+  }
+  return infeasibility;
 }
 // This looks at solution and sets bounds to contain solution
@@ -7889 +7983 @@
   numberObjects_=numberObjectsToUse_;
   // Use shadow prices
-  info->defaultDual_=0.0;
+  //info->defaultDual_=0.0;
   int numberUnsatisfied=OsiChooseStrong::setupList ( info, initialize);
   solver->setNumberObjects(numberObjects);
@@ -7910 +8004 @@
 OsiChooseStrongSubset::chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables)
 {
-  int numberObjects = solver->numberObjects();
-  solver->setNumberObjects(numberObjectsToUse_);
-  numberObjects_=numberObjectsToUse_;
+  //int numberObjects = solver->numberObjects();
+  //solver->setNumberObjects(numberObjectsToUse_);
+  //numberObjects_=numberObjectsToUse_;
   // Use shadow prices
-  info->defaultDual_=0.0;
+  //info->defaultDual_=0.0;
   int returnCode=OsiChooseStrong::chooseVariable(solver,info,fixVariables);
-  solver->setNumberObjects(numberObjects);
-  numberObjects_=numberObjects;
+  //solver->setNumberObjects(numberObjects);
+  //numberObjects_=numberObjects;
   return returnCode;
 }
@@ -8023 +8117 @@
     OsiBiLinear * obj = dynamic_cast<OsiBiLinear *> (objects_[i]);
     assert (obj);
-    obj->getPseudoShadow(info);
-    infeasibility_ += objects_[i]->infeasibility();
+    //obj->getPseudoShadow(info);
+    //infeasibility_ += objects_[i]->infeasibility(info,whichWay);
+    infeasibility_ += obj->getMovement(info);
   }
   bool satisfied=false;
   whichWay=-1;
-  if (infeasibility_<=info->integerTolerance_) {
+  if (!infeasibility_) {
     otherInfeasibility_ = 1.0;
     satisfied=true;

trunk/Cbc/src/CbcLinked.hpp

@@ -844 +844 @@
   /// Sets infeasibility and other when pseudo shadow prices
   void getPseudoShadow(const OsiBranchingInformation * info);
+  /// Gets sum of movements to correct value
+  double getMovement(const OsiBranchingInformation * info);
 
 protected:

trunk/Cbc/src/CbcModel.cpp

@@ -4495 +4495 @@
       addUpdateInformation(update);
     } else {
-      branchingMethod_->updateInformation(solver_,node);
+      OsiTwoWayBranchingObject * obj = dynamic_cast<OsiTwoWayBranchingObject *> (bobj);
+      if (obj) {
+        const OsiObject * object = obj->originalObject();
+        // have to compute object number as not saved
+        int iObject;
+        int iColumn = object->columnNumber();
+        for (iObject = 0 ; iObject < numberObjects_ ; iObject++) {
+          if (object_[iColumn]->columnNumber()==iColumn)
+            break;
+        }
+        assert (iObject<numberObjects_);
+        int branch = obj->firstBranch();
+        if (obj->branchIndex()==2)
+          branch = 1-branch;
+        assert (branch==0||branch==1);
+        double originalValue=node->objectiveValue();
+        double objectiveValue = solver_->getObjValue()*solver_->getObjSense();
+        double changeInObjective = CoinMax(0.0,objectiveValue-originalValue);
+        int iStatus = (feasible) ? 0 : 0;
+        double value = obj->value();
+        if (branch)
+          value = ceil(value)-value;
+        else
+          value = value -floor(value);
+        branchingMethod_->chooseMethod()->updateInformation(iObject,branch,changeInObjective,
+                                                            value,iStatus);
+      }
     }
   }