Changeset 648

Timestamp:

Jul 3, 2005 12:40:47 PM (16 years ago)

Author:

forrest

Message:

stuff

Location:

trunk

Files:

• ClpMessage.cpp (modified) (1 diff)
• ClpModel.cpp (modified) (7 diffs)
• ClpSimplexOther.cpp (modified) (3 diffs)
• ClpSolve.cpp (modified) (1 diff)
• Makefile.Clp (modified) (1 diff)
• include/ClpSimplex.hpp (modified) (1 diff)
• include/ClpSimplexOther.hpp (modified) (1 diff)

trunk/ClpMessage.cpp

@@ -114 +114 @@
   language_=language;
   strcpy(source_,"Clp");
+  class_ = 1; //solver
   Clp_message * message = us_english;
 

trunk/ClpModel.cpp

@@ -1023 +1023 @@
   }
   numberColumns_ = newNumberColumns;
-  // for now gets rid of names
-  lengthNames_ = 0;
-  rowNames_ = std::vector<std::string> ();
-  columnNames_ = std::vector<std::string> ();
+  if (lengthNames_) {
+    // reduce row and column names vectors only if necessary
+    if (rowNames_.size() < (unsigned int)numberRows_)
+      rowNames_.resize(numberRows_);
+    if (columnNames_.size() < (unsigned int)numberColumns_)
+      columnNames_.resize(numberColumns_);
+  }
 }
 // Deletes rows
@@ -1068 +1071 @@
   }
 #if 1
+  // Now works if which out of order
   if (lengthNames_) {
-    int i, j, k;
-    for (k = 0, j = 0, i = 0; j < number && i < numberRows_; ++i) {
-      if (which[j] == i) {
-        ++j;
-      } else {
+    char * mark = new char [numberRows_];
+    memset(mark,0,numberRows_);
+    int i;
+    for (i=0;i<number;i++)
+      mark[which[i]]=1;
+    int k=0;
+    for ( i = 0; i < numberRows_; ++i) {
+      if (!mark[i]) 
         rowNames_[k++] = rowNames_[i];
-      }
-    }
-    for ( ; i < numberRows_; ++i) {
-      rowNames_[k++] = rowNames_[i];
     }
     rowNames_.erase(rowNames_.begin()+k, rowNames_.end());
+    delete [] mark;
   }
 #else
@@ -1153 +1157 @@
                             number, which, newSize,true);
 #if 1
+  // Now works if which out of order
   if (lengthNames_) {
-    int i, j, k;
-    for (k = 0, j = 0, i = 0; j < number && i < numberColumns_; ++i) {
-      if (which[j] == i) {
-        ++j;
-      } else {
+    printf("size of names %d\n",columnNames_.size());
+    char * mark = new char [numberColumns_];
+    memset(mark,0,numberColumns_);
+    int i;
+    for (i=0;i<number;i++)
+      mark[which[i]]=1;
+    int k=0;
+    for ( i = 0; i < numberColumns_; ++i) {
+      if (!mark[i]) 
         columnNames_[k++] = columnNames_[i];
-      }
-    }
-    for ( ; i < numberColumns_; ++i) {
-      columnNames_[k++] = columnNames_[i];
     }
     columnNames_.erase(columnNames_.begin()+k, columnNames_.end());
+    delete [] mark;
   }
 #else
@@ -1296 +1302 @@
   delete [] columnScale_;
   columnScale_ = NULL;
+  if (lengthNames_) {
+    rowNames_.resize(numberRows_);
+  }
 }
 // Add rows from a build object
@@ -1301 +1310 @@
 ClpModel::addRows(const CoinBuild & buildObject,bool tryPlusMinusOne,bool checkDuplicates)
 {
-  if (buildObject.numberElements()==0)
-    return 0;
   CoinAssertHint (buildObject.type()==0,"Looks as if both addRows and addCols being used"); // check correct
   int number = buildObject.numberRows();
@@ -1748 +1755 @@
   delete [] columnScale_;
   columnScale_ = NULL;
+  if (lengthNames_) {
+    columnNames_.resize(numberColumns_);
+  }
 }
 // Add columns from a build object
@@ -1753 +1763 @@
 ClpModel::addColumns(const CoinBuild & buildObject,bool tryPlusMinusOne,bool checkDuplicates)
 {
-  if (buildObject.numberElements()==0)
-    return 0;
   CoinAssertHint (buildObject.type()==1,"Looks as if both addRows and addCols being used"); // check correct
   int number = buildObject.numberColumns();

trunk/ClpSimplexOther.cpp

@@ -205 +205 @@
                                  double & costDecrease, int & sequenceDecrease, double & alphaDecrease)
 {
-  double acceptablePivot = 1.0e-7;
+  double acceptablePivot = 1.0e-9;
   double * work;
   int number;
@@ -2023 +2023 @@
   int returnCode = -1;
   double saveSumDual = sumDualInfeasibilities_; // so we know to be careful
-  //double useTheta = startingTheta;
+  double useTheta = startingTheta;
   double * primalChange = new double[numberRows_];
   double * dualChange = new double[numberColumns_];
   int numberTotal = numberColumns_+numberRows_;
-
+  int iSequence;
+  // See if bounds
+  int type=0;
+  for (iSequence=0;iSequence<numberTotal;iSequence++) {
+    if (changeLower[iSequence]||changeUpper[iSequence]) {
+      type=1;
+      break;
+    }
+  }
+  // See if objective
+  for (iSequence=0;iSequence<numberTotal;iSequence++) {
+    if (changeObjective[iSequence]) {
+      type |= 2;
+      break;
+    }
+  }
+  assert (type);
   while (problemStatus_==-1) {
-
+    double increaseTheta = CoinMin(endingTheta-useTheta,1.0e50);
+    
     // Get theta for bounds - we know can't crossover
-    // get change 
-    int iSequence;
-    for (iSequence=0;iSequence<numberTotal;iSequence++) {
-      primalChange[iSequence]=0.0;
-      switch(getStatus(iSequence)) {
-        
-      case basic:
-      case isFree:
-      case superBasic:
-        break;
-      case isFixed:
-      case atUpperBound:
-        primalChange[iSequence]=changeUpper[iSequence];
-        break;
-      case atLowerBound:
-        primalChange[iSequence]=changeLower[iSequence];
-        break;
-      }
-    }
-    // use rowActivity
-    memset(rowActivity_,0,numberRows_*sizeof(double));
-    times(1.0,primalChange,rowActivity_);
-    
+    int pivotType = nextTheta(type,increaseTheta,primalChange,dualChange,
+                              changeLower,changeUpper,changeObjective);
+    if (pivotType)
+      abort();
     // choose row to go out
     // dualRow will go to virtual row pivot choice algorithm
@@ -2497 +2495 @@
   return returnCode;
 }
+// Computes next theta and says if objective or bounds (0= bounds, 1 objective, -1 none)
+int 
+ClpSimplexOther::nextTheta(int type, double maxTheta, double * primalChange, double * dualChange,
+                           const double * changeLower, const double * changeUpper,
+                           const double * changeObjective)
+{
+  int numberTotal = numberColumns_+numberRows_;
+  int iSequence;
+  int iRow;
+  theta_=maxTheta;
+  bool toLower=false;
+  if ((type&1)!=0) {
+    // get change 
+    for (iSequence=0;iSequence<numberTotal;iSequence++) {
+      primalChange[iSequence]=0.0;
+      switch(getStatus(iSequence)) {
+        
+      case basic:
+      case isFree:
+      case superBasic:
+        break;
+      case isFixed:
+      case atUpperBound:
+        primalChange[iSequence]=changeUpper[iSequence];
+        break;
+      case atLowerBound:
+        primalChange[iSequence]=changeLower[iSequence];
+        break;
+      }
+    }
+    // use array
+    double * array = rowArray_[1]->denseVector();
+    times(1.0,primalChange,array);
+    int * index = rowArray_[1]->getIndices();
+    int number=0;
+    for (iRow=0;iRow<numberRows_;iRow++) {
+      double value = array[iRow];
+      if (value) {
+        array[iRow]=value;
+        index[number++]=iRow;
+      }
+    }
+    // ftran it
+    rowArray_[1]->setNumElements(number);
+    factorization_->updateColumn(rowArray_[0],rowArray_[1]);
+    number=rowArray_[1]->getNumElements();
+    pivotRow_=-1;
+    for (iRow=0;iRow<number;iRow++) {
+      int iPivot = index[iRow];
+      iSequence = pivotVariable_[iPivot];
+      // solution value will be sol - theta*alpha
+      // bounds will be bounds + change *theta
+      double currentSolution = solution_[iSequence];
+      double currentLower = lower_[iSequence];
+      double currentUpper = upper_[iSequence];
+      double alpha = array[iPivot];
+      assert (currentSolution>=currentLower-primalTolerance_);
+      assert (currentSolution<=currentUpper+primalTolerance_);
+      double thetaCoefficient;
+      double hitsLower = COIN_DBL_MAX;
+      thetaCoefficient = changeLower[iSequence]+alpha;
+      if (fabs(thetaCoefficient)>1.0e-8)
+        hitsLower = (currentSolution-currentLower)/thetaCoefficient;
+      if (hitsLower<0.0) {
+        // does not hit - but should we check further
+        hitsLower=COIN_DBL_MAX;
+      }
+      double hitsUpper = COIN_DBL_MAX;
+      thetaCoefficient = changeUpper[iSequence]+alpha;
+      if (fabs(thetaCoefficient)>1.0e-8)
+        hitsUpper = (currentSolution-currentUpper)/thetaCoefficient;
+      if (hitsUpper<0.0) {
+        // does not hit - but should we check further
+        hitsUpper=COIN_DBL_MAX;
+      }
+      if (CoinMin(hitsLower,hitsUpper)<theta_) {
+        theta_ = CoinMin(hitsLower,hitsUpper);
+        toLower = hitsLower<hitsUpper;
+        pivotRow_=iPivot;
+      }
+    }
+  }
+  if ((type&2)!=0) {
+    abort();
+  }
+  if (pivotRow_>=0) {
+    sequenceOut_ = pivotVariable_[pivotRow_];
+    valueOut_ = solution_[sequenceOut_];
+    lowerOut_ = lower_[sequenceOut_];
+    upperOut_ = upper_[sequenceOut_];
+    if (!toLower) {
+      directionOut_ = -1;
+      dualOut_ = valueOut_ - upperOut_;
+    } else if (valueOut_<lowerOut_) {
+      directionOut_ = 1;
+      dualOut_ = lowerOut_ - valueOut_;
+    }
+    return 0;
+  } else {
+    return -1;
+  }
+}

trunk/ClpSolve.cpp

@@ -376 +376 @@
     saveSignal = signal(SIGINT,signal_handler);
   }
+  // If no status array - set up basis
+  if (!status_)
+    allSlackBasis();
   ClpPresolve pinfo;
   pinfo.setSubstitution(options.substitution());

trunk/Makefile.Clp

@@ -7 +7 @@
 # between then specify the exact level you want, e.g., -O1 or -O2
 OptLevel := -g
-OptLevel := -O1
+#OptLevel := -O1
 
 LIBNAME := Clp

trunk/include/ClpSimplex.hpp

@@ -210 +210 @@
   */
   int dual(int ifValuesPass=0, int startFinishOptions=0);
-  /// For debug
+  // If using Debug
   int dualDebug(int ifValuesPass=0, int startFinishOptions=0);
   /** Primal algorithm - see ClpSimplexPrimal.hpp for method.

trunk/include/ClpSimplexOther.hpp

@@ -102 +102 @@
                       const double * changeLower, const double * changeUpper,
                       const double * changeObjective);
+  /** Computes next theta and says if objective or bounds (0= bounds, 1 objective, -1 none).
+      theta is in theta_.
+      type 1 bounds, 2 objective, 3 both.
+  */
+  int nextTheta(int type, double maxTheta, double * primalChange, double * dualChange,
+                      const double * changeLower, const double * changeUpper,
+                      const double * changeObjective);
   /** 
       Row array has row part of pivot row