Changeset 1439 for trunk

Timestamp:

Sep 29, 2009 11:42:05 AM (10 years ago)

Author:

forrest

Message:

minor changes

Location:

trunk/Clp/src

Files:

• ClpPredictorCorrector.cpp (modified) (1 diff)
• ClpSimplex.cpp (modified) (1 diff)
• ClpSimplexNonlinear.cpp (modified) (1 diff)
• ClpSolve.cpp (modified) (1 diff)
• Idiot.cpp (modified) (6 diffs)

trunk/Clp/src/ClpPredictorCorrector.cpp

@@ -960 +960 @@
   deleteWorkingData();
 #if KEEP_GOING_IF_FIXED<10
-#ifndef NDEBUG
+#if 0 //ndef NDEBUG
   {
     static int kk=0;

trunk/Clp/src/ClpSimplex.cpp

@@ -611 +611 @@
       if (!numberBasic) {
         //printf("no errors on basic - going to all slack - numberOut %d\n",numberOut);
+#if 0
         allSlackBasis(true);
         CoinIotaN(pivotVariable_,numberRows_,numberColumns_);
+#else
+        // allow
+        numberOut=0;
+#endif
       } 
       CoinSort_2(save, save + numberOut, sort);

trunk/Clp/src/ClpSimplexNonlinear.cpp

@@ -51 +51 @@
     // for moment only if no scaling
     // May be faster if switched off - but can't see why
-    if (!quadraticObj->fullMatrix()&&!rowScale_&&objectiveScale_==1.0) {
+    if (!quadraticObj->fullMatrix()&&(!rowScale_&&!scalingFlag_)&&objectiveScale_==1.0) {
       saveObjective = objective_;
       objective_=new ClpQuadraticObjective(*quadraticObj,1);

trunk/Clp/src/ClpSolve.cpp

@@ -2214 +2214 @@
       }
     }
-    if (method==ClpSolve::useBarrier) {
+    if (method==ClpSolve::useBarrier||barrierStatus<0) {
       if (maxIts&&barrierStatus<4&&!quadraticObj) {
         //printf("***** crossover - needs more thought on difficult models\n");

trunk/Clp/src/Idiot.cpp

@@ -175 +175 @@
         if (iCol>=0) {
           // may want to carry on - because of cost?
-          while (cost[iCol]<0&&rowValue<rowUpper[i]) {
+          while (iCol>=0&&cost[iCol]<0&&rowValue<rowUpper[i]) {
             // want to increase
             double distance = rowUpper[i]-rowValue;
@@ -241 +241 @@
         if (iCol>=0) {
           // may want to carry on - because of cost?
-          while (cost[iCol]<0&&rowValue>rowLower[i]) {
+          while (iCol>=0&&cost[iCol]<0&&rowValue>rowLower[i]) {
             // want to increase
             double distance = -(rowLower[i]-rowValue);
@@ -1314 +1314 @@
     int * negSlack = posSlack+nrows;
     int * nextSlack = negSlack + nrows;
+#if 1
+    // Array for sorting out slack values
+    double * ratio = new double [ncols];
+    int * which = new int [ncols];
+    for (i=0;i<nrows;i++) {
+      if (posSlack[i]>=0||negSlack[i]>=0) {
+        int iCol;
+        int nPlus=0;
+        int nMinus=0;
+        bool possible=true;
+        // Get sum
+        double sum=0.0;
+        iCol =posSlack[i];
+        while (iCol>=0) {
+          double value = element[columnStart[iCol]];
+          sum += value*colsol[iCol];
+          if (lower[iCol]) {
+            possible=false;
+            break;
+          } else {
+            nPlus++;
+          }
+          iCol=nextSlack[iCol];
+        }
+        iCol =negSlack[i];
+        while (iCol>=0) {
+          double value = -element[columnStart[iCol]];
+          sum -= value*colsol[iCol];
+          if (lower[iCol]) {
+            possible=false;
+            break;
+          } else {
+            nMinus++;
+          }
+          iCol=nextSlack[iCol];
+        }
+        //printf("%d plus, %d minus",nPlus,nMinus);
+        //printf("\n");
+        if ((rowsol[i]-rowlower[i]<1.0e-7||
+             rowupper[i]-rowsol[i]<1.0e-7)&&
+            nPlus+nMinus<2) 
+          possible=false;
+        if (possible) {
+          // Amount contributed by other varaibles
+          sum = rowsol[i]-sum;
+          double lo = rowlower[i];
+          if (lo>-1.0e20)
+            lo -=sum;
+          double up = rowupper[i];
+          if (up<1.0e20)
+            up -= sum;
+          //printf("row bounds %g %g\n",lo,up);
+          if (0) {
+            double sum=0.0;
+            double x=0.0;
+            for (int k=0;k<ncols;k++) {
+              CoinBigIndex j;
+              double value=colsol[k];
+              x+=value*cost[k];
+              for (j=columnStart[k];j<columnStart[k]+columnLength[k];j++) {
+                int irow=row[j];
+                if (irow==i)
+                  sum += element[j]*value;
+              }
+            }
+            printf("Before sum %g <= %g <= %g cost %.18g\n",
+                   rowlower[i],sum,rowupper[i],x);
+          }
+          // set all to zero
+          iCol =posSlack[i];
+          while (iCol>=0) {
+            colsol[iCol]=0.0;
+            iCol=nextSlack[iCol];
+          }
+          iCol =negSlack[i];
+          while (iCol>=0) {
+            colsol[iCol]=0.0;
+            iCol=nextSlack[iCol];
+          }
+          {
+            int iCol;
+            iCol =posSlack[i];
+            while (iCol>=0) {
+              //printf("col %d el %g sol %g bounds %g %g cost %g\n",
+              //     iCol,element[columnStart[iCol]],
+              //     colsol[iCol],lower[iCol],upper[iCol],cost[iCol]);
+              iCol = nextSlack[iCol];
+            }
+            iCol =negSlack[i];
+            while (iCol>=0) {
+              //printf("col %d el %g sol %g bounds %g %g cost %g\n",
+              //     iCol,element[columnStart[iCol]],
+              //     colsol[iCol],lower[iCol],upper[iCol],cost[iCol]);
+              iCol = nextSlack[iCol];
+            }
+          }
+          //printf("now what?\n");
+          int n=0;
+          bool basic=false;
+          if (lo>0.0) {
+            // Add in positive
+            iCol =posSlack[i];
+            while (iCol>=0) {
+              double value = element[columnStart[iCol]];
+              ratio[n]=cost[iCol]/value;
+              which[n++]=iCol;
+              iCol=nextSlack[iCol];
+            }
+            CoinSort_2(ratio,ratio+n,which);
+            for (int i=0;i<n;i++) {
+              iCol=which[i];
+              double value=element[columnStart[iCol]];
+              if (lo>=upper[iCol]*value) {
+                value *=upper[iCol];
+                sum+=value;
+                lo-=value;
+                colsol[iCol]=upper[iCol];
+              } else {
+                value = lo/value;
+                sum += lo;
+                lo=0.0;
+                colsol[iCol]=value;
+                model_->setColumnStatus(iCol,ClpSimplex::basic);
+                basic=true;
+              }
+              if (lo<1.0e-7)
+                break;
+            }
+          } else if (up<0.0) {
+            // Use lo so coding is more similar
+            lo=-up;
+            // Add in negative
+            iCol =negSlack[i];
+            while (iCol>=0) {
+              double value = -element[columnStart[iCol]];
+              ratio[n]=cost[iCol]/value;
+              which[n++]=iCol;
+              iCol=nextSlack[iCol];
+            }
+            CoinSort_2(ratio,ratio+n,which);
+            for (int i=0;i<n;i++) {
+              iCol=which[i];
+              double value=-element[columnStart[iCol]];
+              if (lo>=upper[iCol]*value) {
+                value *=upper[iCol];
+                sum+=value;
+                lo-=value;
+                colsol[iCol]=upper[iCol];
+              } else {
+                value = lo/value;
+                sum += lo;
+                lo=0.0;
+                colsol[iCol]=value;
+                model_->setColumnStatus(iCol,ClpSimplex::basic);
+                basic=true;
+              }
+              if (lo<1.0e-7)
+                break;
+            }
+          }
+          if (0) {
+            double sum2=0.0;
+            double x=0.0;
+            for (int k=0;k<ncols;k++) {
+              CoinBigIndex j;
+              double value=colsol[k];
+              x+=value*cost[k];
+              for (j=columnStart[k];j<columnStart[k]+columnLength[k];j++) {
+                int irow=row[j];
+                if (irow==i)
+                  sum2 += element[j]*value;
+              }
+            }
+            printf("after sum %g <= %g <= %g cost %.18g (sum = %g)\n",
+                   rowlower[i],sum2,rowupper[i],x,sum);
+          }
+          rowsol[i]=sum;
+          if (basic) {
+            if (fabs(rowsol[i]-rowlower[i])<fabs(rowsol[i]-rowupper[i]))
+              model_->setRowStatus(i,ClpSimplex::atLowerBound);
+            else
+              model_->setRowStatus(i,ClpSimplex::atUpperBound);
+          }
+        } else {
+          int n=0;
+          int iCol;
+          iCol =posSlack[i];
+          while (iCol>=0) {
+            if (colsol[iCol]>lower[iCol]+1.0e-8&&
+                colsol[iCol]<upper[iCol]-1.0e-8) {
+              model_->setColumnStatus(iCol,ClpSimplex::basic);
+              n++;
+            }
+            iCol = nextSlack[iCol];
+          }
+          iCol =negSlack[i];
+          while (iCol>=0) {
+            if (colsol[iCol]>lower[iCol]+1.0e-8&&
+                colsol[iCol]<upper[iCol]-1.0e-8) {
+              model_->setColumnStatus(iCol,ClpSimplex::basic);
+              n++;
+            }
+            iCol = nextSlack[iCol];
+          }
+          if (n) {
+            if (fabs(rowsol[i]-rowlower[i])<fabs(rowsol[i]-rowupper[i]))
+              model_->setRowStatus(i,ClpSimplex::atLowerBound);
+            else
+              model_->setRowStatus(i,ClpSimplex::atUpperBound);
+#ifdef CLP_INVESTIGATE
+            if (n>1)
+              printf("%d basic on row %d!\n",n,i);
+#endif
+          }
+        }
+      }
+    }
+    delete [] ratio;
+    delete [] which;
+#else
     for (i=0;i<nrows;i++) {
       int n=0;
       int iCol;
       iCol =posSlack[i];
-      if (iCol>=0) {
+      while (iCol>=0) {
         if (colsol[iCol]>lower[iCol]+1.0e-8&&
             colsol[iCol]<upper[iCol]-1.0e-8) {
@@ -1324 +1544 @@
           n++;
         }
-        while (nextSlack[iCol]>=0) {
-          iCol = nextSlack[iCol];
-          if (colsol[iCol]>lower[iCol]+1.0e-8&&
-              colsol[iCol]<upper[iCol]-1.0e-8) {
-            model_->setColumnStatus(iCol,ClpSimplex::basic);
-            n++;
-          }
-        }
+        iCol = nextSlack[iCol];
       }
       iCol =negSlack[i];
-      if (iCol>=0) {
+      while (iCol>=0) {
         if (colsol[iCol]>lower[iCol]+1.0e-8&&
             colsol[iCol]<upper[iCol]-1.0e-8) {
@@ -1340 +1553 @@
           n++;
         }
-        while (nextSlack[iCol]>=0) {
-          iCol = nextSlack[iCol];
-          if (colsol[iCol]>lower[iCol]+1.0e-8&&
-              colsol[iCol]<upper[iCol]-1.0e-8) {
-            model_->setColumnStatus(iCol,ClpSimplex::basic);
-            n++;
-          }
-        }
+        iCol = nextSlack[iCol];
       }
       if (n) {
@@ -1354 +1560 @@
         else
           model_->setRowStatus(i,ClpSimplex::atUpperBound);
+#ifdef CLP_INVESTIGATE
         if (n>1)
           printf("%d basic on row %d!\n",n,i);
-      }
-    }
+#endif
+      }
+    }
+#endif
   }
   double maxmin;