Changeset 2280

Timestamp:

Jun 14, 2016 10:39:54 AM (3 years ago)

Author:

forrest

Message:

allow heuristics to see if integers are 'optional'

Location:

trunk/Cbc/src

Files:

• CbcHeuristic.cpp (modified) (11 diffs)
• CbcHeuristic.hpp (modified) (2 diffs)
• CbcHeuristicDive.cpp (modified) (18 diffs)
• CbcHeuristicDiveCoefficient.cpp (modified) (1 diff)
• CbcHeuristicDiveFractional.cpp (modified) (1 diff)
• CbcHeuristicDiveGuided.cpp (modified) (1 diff)
• CbcHeuristicDiveLineSearch.cpp (modified) (1 diff)
• CbcHeuristicDivePseudoCost.cpp (modified) (2 diffs)
• CbcHeuristicDiveVectorLength.cpp (modified) (1 diff)
• CbcHeuristicFPump.cpp (modified) (31 diffs)
• CbcHeuristicFPump.hpp (modified) (3 diffs)
• CbcHeuristicGreedy.cpp (modified) (9 diffs)
• CbcHeuristicLocal.cpp (modified) (17 diffs)
• CbcHeuristicRINS.cpp (modified) (5 diffs)
• CbcSolver.cpp (modified) (4 diffs)
• CbcSolverHeuristics.cpp (modified) (1 diff)
• CbcSymmetry.hpp (modified) (1 diff)

trunk/Cbc/src/CbcHeuristic.cpp

@@ -1251 +1251 @@
                     OsiSolverInterface * solver3 = solver2->clone();
                     for (int i = 0; i < numberColumns; i++) {
-                        if (solver3->isInteger(i)) {
+                        if (isHeuristicInteger(solver3,i)) {
                             int k = which[i];
                             double value = inputSolution_[k];
@@ -1267 +1267 @@
                         OsiSolverInterface * solver4 = solver2->clone();
                         for (int i = 0; i < numberColumns; i++) {
-                            if (solver4->isInteger(i)) {
+                            if (isHeuristicInteger(solver4,i)) {
                                 int k = which[i];
                                 double value = floor(inputSolution_[k] + 0.5);
@@ -1283 +1283 @@
                             const double * solution = solver4->getColSolution();
                             for (int i = 0; i < numberColumns; i++) {
-                                if (solver4->isInteger(i)) {
+                                if (isHeuristicInteger(solver4,i)) {
                                     double value = floor(solution[i] + 0.5);
                                     if (fabs(value - solution[i]) > 1.0e-6)
@@ -1494 +1494 @@
             bool good = true;
             for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                if (solverC->isInteger(iColumn)) {
+                if (isHeuristicInteger(solverC,iColumn)) {
                     if (lower[iColumn] > lowerC[iColumn] &&
                             upper[iColumn] < upperC[iColumn]) {
@@ -1509 +1509 @@
                 int n = 0;
                 for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                    if (solverC->isInteger(iColumn)) {
+                    if (isHeuristicInteger(solverC,iColumn)) {
                         if (lower[iColumn] == upperC[iColumn]) {
                             rhs += lower[iColumn];
@@ -2075 +2075 @@
 
     double penalty = 0.0;
-    const char * integerType = model_->integerType();
     // see if feasible - just using singletons
     for (i = 0; i < numberRows; i++) {
@@ -2110 +2109 @@
                             double distance = absInfeasibility / absElement;
                             double thisCost = -direction * objective[iColumn] * distance;
-                            if (integerType[iColumn]) {
+                            if (isHeuristicInteger(solver,iColumn)) {
                                 distance = ceil(distance - useTolerance);
                                 if (currentValue - distance >= lowerValue - useTolerance) {
@@ -2135 +2134 @@
                             double distance = absInfeasibility / absElement;
                             double thisCost = direction * objective[iColumn] * distance;
-                            if (integerType[iColumn]) {
+                            if (isHeuristicInteger(solver,iColumn)) {
                                 distance = ceil(distance - 1.0e-7);
                                 assert (currentValue - distance <= upperValue + useTolerance);
@@ -2171 +2170 @@
         int iColumn;
         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
-            if (integerType[iColumn])
+            if (isHeuristicInteger(solver,iColumn))
                 continue;
             double currentValue = newSolution[iColumn];
@@ -2320 +2319 @@
             numberPasses++;
             for (iColumn = 0; iColumn < numberColumns; iColumn++) {
-                bool isInteger = (integerType[iColumn] != 0);
+                bool isInteger = isHeuristicInteger(solver,iColumn);
                 double currentValue = newSolution[iColumn];
                 double lowerValue = lower[iColumn];
@@ -2652 +2651 @@
         int nCandidate = 0;
         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
-            bool isInteger = (integerType[iColumn] != 0);
+            bool isInteger = isHeuristicInteger(solver,iColumn);
             if (isInteger) {
                 double currentValue = newSolution[iColumn];

trunk/Cbc/src/CbcHeuristic.hpp

@@ -17 +17 @@
 
 class CbcModel;
-
+#ifdef COIN_HAS_CLP
+#include "OsiClpSolverInterface.hpp"
+#endif
 //#############################################################################
 
@@ -302 +304 @@
         return numCouldRun_;
     }
+    /// Is it integer for heuristics?
+#ifdef COIN_HAS_CLP
+  inline bool isHeuristicInteger(const OsiSolverInterface * solver, int iColumn) const
+  {
+    const OsiClpSolverInterface * clpSolver
+    = dynamic_cast<const OsiClpSolverInterface *> (solver);
+    if (clpSolver)
+        return clpSolver->isHeuristicInteger(iColumn);
+      else
+        return solver->isInteger(iColumn);
+  }
+#else
+  inline bool isHeuristicInteger(const OsiSolverInterface * solver, int iColumn)
+  { return solver->isInteger(iColumn);}
+#endif
     /*! \brief Clone, but ...
 

trunk/Cbc/src/CbcHeuristicDive.cpp

@@ -9 +9 @@
 #endif
 
-#include "CbcHeuristicDive.hpp"
 #include "CbcStrategy.hpp"
 #include "CbcModel.hpp"
@@ -20 +19 @@
 #include "OsiClpSolverInterface.hpp"
 #endif
+#include "CbcHeuristicDive.hpp"
 
 //#define DIVE_FIX_BINARY_VARIABLES
@@ -389 +389 @@
         random[i] = randomNumberGenerator_.randomDouble() + 0.3;
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         back[iColumn]=i;
         double value = newSolution[iColumn];
@@ -433 +435 @@
             for (int i = 0; i < numberIntegers; i++) {
                 int iColumn = integerVariable[i];
+                if (!isHeuristicInteger(solver,iColumn))
+                  continue;
                 double value = newSolution[iColumn];
                 if (fabs(floor(value + 0.5) - value) > integerTolerance) {
@@ -456 +460 @@
                   for (int i = 0; i < numberIntegers; i++) {
                     int iColumn = integerVariable[i];
+                    if (!isHeuristicInteger(solver,iColumn))
+                      continue;
                     double value = newSolution[iColumn];
                     if (fabs(floor(value + 0.5) - value) > integerTolerance) {
@@ -476 +482 @@
                   for (i = 0; i < numberIntegers; i++) {
                     int iColumn = integerVariable[i];
+                    if (!isHeuristicInteger(solver,iColumn))
+                      continue;
                     double value = newSolution[bestColumn];
                     if (fabs(floor(value + 0.5) - value) > integerTolerance) {
@@ -620 +628 @@
             for (int i = 0; i < numberIntegers; i++) {
                 int iColumn = integerVariable[i];
+                if (!isHeuristicInteger(solver,iColumn))
+                  continue;
                 if (upper[iColumn] > lower[iColumn]) {
                     numberFree++;
@@ -659 +669 @@
             for (int i = 0; i < numberIntegers; i++) {
                 int iColumn = integerVariable[i];
+                if (!isHeuristicInteger(solver,iColumn))
+                  continue;
                 if (upper[iColumn] > lower[iColumn]) {
                     if (priority_) {
@@ -787 +799 @@
             for (int i = 0; i < numberIntegers; i++) {
               int iColumn = integerVariable[i];
+              if (!isHeuristicInteger(solver,iColumn))
+                continue;
               double value = newSolution[iColumn];
               double away = fabs(floor(value + 0.5) - value);
@@ -931 +945 @@
         for (int i = 0; i < numberIntegers; i++) {
             int iColumn = integerVariable[i];
+            if (!isHeuristicInteger(solver,iColumn))
+              continue;
             double value = newSolution[iColumn];
             double away = fabs(floor(value + 0.5) - value);
@@ -1066 +1082 @@
       for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double value = newSolution[iColumn];
         if (fabs(floor(value + 0.5) - value) > integerTolerance) {
@@ -1279 +1297 @@
     const int * row = matrix_.getIndices();
     const CoinBigIndex * columnStart = matrix_.getVectorStarts();
+    OsiSolverInterface * solver = model_->solver();
     const int * columnLength = matrix_.getVectorLengths();
-    const double * rowLower = model_->solver()->getRowLower();
-    const double * rowUpper = model_->solver()->getRowUpper();
+    const double * rowLower = solver->getRowLower();
+    const double * rowUpper = solver->getRowUpper();
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         int down = 0;
         int up = 0;
@@ -1329 +1350 @@
     const int numberRows = matrixByRow_.getNumRows();
     const int numberCols = matrixByRow_.getNumCols();
-
-    const double * lower = model_->solver()->getColLower();
-    const double * upper = model_->solver()->getColUpper();
-    const double * rowLower = model_->solver()->getRowLower();
-    const double * rowUpper = model_->solver()->getRowUpper();
+    
+    OsiSolverInterface * solver = model_->solver();
+    const double * lower = solver->getColLower();
+    const double * upper = solver->getColUpper();
+    const double * rowLower = solver->getRowLower();
+    const double * rowUpper = solver->getRowUpper();
 
     //  const char * integerType = model_->integerType();
@@ -1340 +1362 @@
     //  const int numberIntegers = model_->numberIntegers();
     //  const int * integerVariable = model_->integerVariable();
-    const double * objective = model_->solver()->getObjCoefficients();
+    const double * objective = solver->getObjCoefficients();
 
     // vector to store the row number of variable bound rows
@@ -1353 +1375 @@
         for (int k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
             int iColumn = column[k];
-            if (model_->solver()->isInteger(iColumn) &&
+            if (isHeuristicInteger(solver,iColumn) &&
                     lower[iColumn] == 0.0 && upper[iColumn] == 1.0 &&
                     objective[iColumn] == 0.0 &&
@@ -1359 +1381 @@
                     positiveBinary < 0)
                 positiveBinary = iColumn;
-            else if (model_->solver()->isInteger(iColumn) &&
+            else if (isHeuristicInteger(solver,iColumn) &&
                      lower[iColumn] == 0.0 && upper[iColumn] == 1.0 &&
                      objective[iColumn] == 0.0 &&
@@ -1464 +1486 @@
     for (int i = 0 ; i < numberIntegers ; i++) {
         int iColumn = integerVariable[i] ;
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double djValue = direction * reducedCost[iColumn] ;
         if (upper[iColumn] - lower[iColumn] > integerTolerance) {
@@ -1547 +1571 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         if (upper[iColumn] > lower[iColumn]) {
             numberFree++;

trunk/Cbc/src/CbcHeuristicDiveCoefficient.cpp

@@ -86 +86 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double value = newSolution[iColumn];
         double fraction = value - floor(value);

trunk/Cbc/src/CbcHeuristicDiveFractional.cpp

@@ -81 +81 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double value = newSolution[iColumn];
         double fraction = value - floor(value);

trunk/Cbc/src/CbcHeuristicDiveGuided.cpp

@@ -93 +93 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double value = newSolution[iColumn];
         double fraction = value - floor(value);

trunk/Cbc/src/CbcHeuristicDiveLineSearch.cpp

@@ -84 +84 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double rootValue = rootNodeLPSol[iColumn];
         double value = newSolution[iColumn];

trunk/Cbc/src/CbcHeuristicDivePseudoCost.cpp

@@ -89 +89 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double rootValue = rootNodeLPSol[iColumn];
         double value = newSolution[iColumn];
@@ -218 +220 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         if (upper[iColumn] > lower[iColumn]) {
             numberFree++;

trunk/Cbc/src/CbcHeuristicDiveVectorLength.cpp

@@ -85 +85 @@
     for (int i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         double value = newSolution[iColumn];
         double fraction = value - floor(value);

trunk/Cbc/src/CbcHeuristicFPump.cpp

@@ -216 +216 @@
 // Returns 1 if solution, 0 if not
 int
-CbcHeuristicFPump::solution(double & solutionValue,
+CbcHeuristicFPump::solutionInternal(double & solutionValue,
                             double * betterSolution)
 {
@@ -286 +286 @@
     double cutoff;
     model_->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
+    double realCutoff=cutoff;
+    bool secondMajorPass=false;
     double direction = model_->solver()->getObjSense();
     cutoff *= direction;
@@ -336 +338 @@
         assert(integerObject || integerObject2);
 #endif
+#ifdef COIN_HAS_CLP
+        if (!isHeuristicInteger(model_->solver(),iColumn))
+          continue;
+#endif
         double value = initialSolution[iColumn];
         double nearest = floor(value + 0.5);
@@ -370 +376 @@
         for (i = 0; i < numberIntegers; i++) {
             int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+            if (!isHeuristicInteger(model_->solver(),iColumn))
+              continue;
+#endif
             if (upper[iColumn] - lower[iColumn] < 1.000001)
                 integerVariable[j++] = iColumn;
@@ -476 +486 @@
     double artificialFactor = 0.00001;
     // also try rounding!
-    double * roundingSolution = new double[numberColumns];
-    double roundingObjective = solutionValue;
+    double * roundingSolution = new double[2*numberColumns];
+    double roundingObjective = realCutoff;
     CbcRounding roundingHeuristic(*model_);
     int dualPass = 0;
@@ -807 +817 @@
                 randomNumberGenerator_.setSeed(987654321);
             }
+#ifdef COIN_HAS_CLP
+            {
+              OsiClpSolverInterface * clpSolver
+                = dynamic_cast<OsiClpSolverInterface *> (clonedSolver);
+              //printf("real cutoff %g fake %g - second pass %c\n",realCutoff,cutoff,
+              //     secondMajorPass ? 'Y' : 'N');
+              if (clpSolver && (((accumulate_&16) != 0) || 
+                                ((accumulate_&8)!=0 && secondMajorPass))) {
+                // try rounding heuristic
+                OsiSolverInterface * saveSolver = model_->swapSolver(clonedSolver);
+                ClpSimplex * simplex = clpSolver->getModelPtr();
+                double * solverSolution = simplex->primalColumnSolution();
+                memcpy(solverSolution,solution,numberColumns*sizeof(double));
+                // Compute using dot product
+                double newSolutionValue = -saveOffset;
+                for (  i = 0 ; i < numberColumns ; i++ )
+                  newSolutionValue += saveObjective[i] * solution[i];
+                simplex->setObjectiveValue(newSolutionValue);
+                clpSolver->setObjective(saveObjective);
+                CbcRounding heuristic1(*model_);
+                heuristic1.setHeuristicName("rounding in feaspump!");
+                heuristic1.setWhen(1);
+                newSolutionValue=realCutoff;
+                int ifSolR = heuristic1.solution(newSolutionValue,
+                                                 roundingSolution+numberColumns);
+                model_->swapSolver(saveSolver);
+                if (ifSolR&&newSolutionValue<roundingObjective) {
+                  roundingObjective=newSolutionValue;
+                  //printf("rounding obj of %g?\n", roundingObjective);
+                  memcpy(roundingSolution,roundingSolution+numberColumns,
+                         numberColumns*sizeof(double));
+                }
+              }
+            }
+#endif
             returnCode = rounds(solver, newSolution,/*saveObjective,*/
                                 numberIntegers, integerVariable,
@@ -817 +862 @@
             }
             numberPasses++;
+            if (roundingObjective<realCutoff) {
+              if (returnCode) {
+                newSolutionValue = -saveOffset;
+                for (  i = 0 ; i < numberColumns ; i++ )
+                    newSolutionValue += saveObjective[i] * newSolution[i];
+              } else {
+                newSolutionValue = COIN_DBL_MAX;
+              }
+              if (roundingObjective<newSolutionValue&&false) {
+                returnCode=1;
+                memcpy(newSolution,roundingSolution,
+                       numberColumns*sizeof(double));
+              }
+            }
             if (returnCode) {
                 // SOLUTION IS INTEGER
@@ -841 +900 @@
                         for (i = 0; i < numberIntegersOrig; i++) {
                             int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+                            if (!isHeuristicInteger(solver,iColumn))
+                              continue;
+#endif
                             double value = floor(newSolution[iColumn] + 0.5);
                             if (solver->isBinary(iColumn)) {
@@ -932 +995 @@
                                 }
                                 newSolutionValue += objective[iColumn] * newSolution[iColumn];
-                                if (solver->isInteger(iColumn)) {
+                                if (isHeuristicInteger(solver,iColumn)) {
                                   double intValue = floor(value+0.5);
                                   if (fabs(value-intValue)>largestAway) {
@@ -993 +1056 @@
                                     model_->setBestSolution(saveOldSolution, numberColumns, saveObjectiveValue);
                                 delete [] saveOldSolution;
+                                realCutoff = model_->getMinimizationObjValue();
                             }
                             if (action == 0 || model_->maximumSecondsReached()) {
@@ -1156 +1220 @@
                         continue;
                     // deal with fixed variables (i.e., upper=lower)
-                    if (fabs(lower[iColumn] - upper[iColumn]) < primalTolerance || !solver->isInteger(iColumn)) {
+                    if (fabs(lower[iColumn] - upper[iColumn]) < primalTolerance || !isHeuristicInteger(solver,iColumn)) {
                         //if (lower[iColumn] > 1. - primalTolerance) solver->setObjCoeff(iColumn,-costValue);
                         //else                                       solver->setObjCoeff(iColumn,costValue);
@@ -1318 +1382 @@
                                 for (i = 0; i < numberIntegersOrig; i++) {
                                     int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+                                    if (!isHeuristicInteger(solver,iColumn))
+                                      continue;
+#endif
 #ifdef RAND_RAND
                                     if (nChanged > numberChanged)
@@ -1341 +1409 @@
                                     for (i = 0; i < numberIntegersOrig; i++) {
                                         int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+                                        if (!isHeuristicInteger(solver,iColumn))
+                                          continue;
+#endif
                                         if (objective[iColumn] > 0.0) {
                                             if (basis->getStructStatus(iColumn) ==
@@ -1395 +1467 @@
                         const double * newSolution = solver->getColSolution();
                         for (int iColumn = 0 ; iColumn < numberColumns ; iColumn++ ) {
-                            if (solver->isInteger(iColumn)) {
+                            if (isHeuristicInteger(solver,iColumn)) {
                                 double value = newSolution[iColumn];
                                 double nearest = floor(value + 0.5);
@@ -1459 +1531 @@
                             for (  i = 0 ; i < numberColumns ; i++ ) {
                                 double value = newSolution[i];
-                                if (solver->isInteger(i)) {
+                                if (isHeuristicInteger(solver,i)) {
                                     double nearest = floor(value + 0.5);
                                     if (fabs(value - nearest) > 1.0e-6) {
@@ -1672 +1744 @@
                         const double * newSolution = solver->getColSolution();
                         for (  i = 0 ; i < numberColumns ; i++ ) {
-                            if (solver->isInteger(i)) {
+                            if (isHeuristicInteger(solver,i)) {
                                 double value = newSolution[i];
                                 double nearest = floor(value + 0.5);
@@ -1740 +1812 @@
                     for (i = 0; i < numberIntegersOrig; i++) {
                         int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+                        if (!isHeuristicInteger(solver,iColumn))
+                          continue;
+#endif
                         if (objective[iColumn] > 0.0)
                             closestSolution[i] = 0;
@@ -1857 +1933 @@
             solutionValue = roundingObjective;
             newSolutionValue = solutionValue;
+            realCutoff=solutionValue-1.0e-5;
             memcpy(betterSolution, roundingSolution, numberColumns*sizeof(double));
             solutionFound = true;
@@ -1903 +1980 @@
                 for (i = 0; i < numberIntegersOrig; i++) {
                     int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+                    if (!isHeuristicInteger(newSolver,iColumn))
+                      continue;
+#endif
                     //const OsiObject * object = model_->object(i);
                     //double originalLower;
@@ -1934 +2015 @@
                 if (fixContinuous) {
                     for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                        if (!newSolver->isInteger(iColumn) && usedColumn[iColumn] <= allowedPass) {
+                        if (!isHeuristicInteger(newSolver,iColumn) && usedColumn[iColumn] <= allowedPass) {
                             double value = lastSolution[iColumn];
                             if (value < colLower[iColumn] + 1.0e-8) {
@@ -2042 +2123 @@
                     const double * obj = newSolver->getObjCoefficients();
                     for (int i = 0 ; i < numberColumns ; i++ ) {
-                        if (newSolver->isInteger(i)) {
+                        if (isHeuristicInteger(newSolver,i)) {
                             double value = newSolution[i];
                             double nearest = floor(value + 0.5);
@@ -2067 +2148 @@
                         for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
                             double value = newSolution[iColumn];
-                            if (newSolver->isInteger(iColumn)) {
+                            if (isHeuristicInteger(newSolver,iColumn)) {
                                 value = floor(newSolution[iColumn] + 0.5);
                                 newSolver->setColLower(iColumn, value);
@@ -2150 +2231 @@
                                     const double * solution = newSolver->getColSolution();
                                     for (int  i = 0 ; i < numberColumns ; i++ ) {
-                                        if (newSolver->isInteger(i)) {
+                                        if (isHeuristicInteger(newSolver,i)) {
                                             double value = solution[i];
                                             double nearest = floor(value + 0.5);
@@ -2192 +2273 @@
                         const double * upper = model_->solver()->getColUpper();
                         for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                            if (newSolver->isInteger(iColumn)) {
+                            if (isHeuristicInteger(newSolver,iColumn)) {
                                 double value = floor(newSolution[iColumn] + 0.5);
                                 newSolver->setColLower(iColumn, value);
@@ -2253 +2334 @@
         if (solutionFound) finalReturnCode = 1;
         cutoff = CoinMin(cutoff, solutionValue - model_->getCutoffIncrement());
+        realCutoff = cutoff;
         if (numberTries >= maximumRetries_ || !solutionFound || exitAll || cutoff < continuousObjectiveValue + 1.0e-7) {
             break;
@@ -2272 +2354 @@
                 break;
             sprintf(pumpPrint, "Round again with cutoff of %g", cutoff);
+            secondMajorPass=true;
             model_->messageHandler()->message(CBC_FPUMP1, model_->messages())
             << pumpPrint
@@ -2301 +2384 @@
         for (i = 0; i < numberIntegersOrig; i++) {
             int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+            if (!isHeuristicInteger(newSolver,iColumn))
+              continue;
+#endif
             int direction = closestSolution[i];
             closestSolution[i] = iColumn;
@@ -2383 +2470 @@
 
 /**************************END MAIN PROCEDURE ***********************************/
+/* If general integers then adds variables to turn into binaries round
+   solution
+*/
+int 
+CbcHeuristicFPump::solution(double & objectiveValue, double * newSolution)
+{
+  double * newSolution2=NULL;
+  double objective2=COIN_DBL_MAX;
+  int returnCode2=0;
+  int oddGeneral = (accumulate_&(32|64|128))>>5;
+  if (oddGeneral) {
+    int maxAround=2;
+    bool fixSatisfied=false;
+    // clone solver and modify
+    OsiSolverInterface * solver = cloneBut(2); // wasmodel_->solver()->clone();
+    double cutoff;
+    model_->solver()->getDblParam(OsiDualObjectiveLimit, cutoff);
+    int numberColumns = model_->getNumCols();
+    int numberIntegers = model_->numberIntegers();
+    const int * integerVariableOrig = model_->integerVariable();
+    int general = 0;
+    int nAdd=0;
+    const double * lower = solver->getColLower();
+    const double * upper = solver->getColUpper();
+    const double * initialSolution = solver->getColSolution();
+    // we may be being clever so make sure solver lines up wuth model
+    for (int i = 0; i < numberColumns; i++) 
+      solver->setContinuous(i);
+    for (int i = 0; i < numberIntegers; i++) {
+      int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+      if (!isHeuristicInteger(solver,iColumn))
+        continue;
+#endif
+      double value = initialSolution[iColumn];
+      double nearest = floor(value + 0.5);
+      if (upper[iColumn] - lower[iColumn] > 1.000001) {
+        if (fabs(value-nearest)<1.0e-6&&fixSatisfied) {
+          solver->setColLower(iColumn,nearest);
+          solver->setColUpper(iColumn,nearest);
+        } else {
+          general++;
+          int up=static_cast<int>(upper[iColumn]);
+          int lo=static_cast<int>(lower[iColumn]);
+          int near=static_cast<int>(nearest);
+          up = CoinMin(up,near+maxAround);
+          lo = CoinMax(lo,near-maxAround);
+          solver->setColLower(iColumn,lo);
+          solver->setColUpper(iColumn,up);
+          int n=up-lo;
+          // 1 - 1, 2,3 - 2, 4567 - 3
+          while (n) {
+            nAdd++;
+            n = n>>1;
+          }
+        }
+      } else {
+        solver->setInteger(iColumn);
+      }
+    }
+    if (!general) {
+      delete solver;
+    }
+    if (general) {
+      CbcModel * saveModel = model_;
+      int * addStart = new int[nAdd+1];
+      memset(addStart,0,(nAdd+1)*sizeof(int));
+      int * addIndex = new int[general+nAdd];
+      double * addElement = new double[general+nAdd];
+      double * addLower = new double[nAdd];
+      double * addUpper = new double[nAdd];
+      for (int i=0;i<nAdd;i++) {
+        addLower[i]=0.0;
+        addUpper[i]=1.0;
+      }
+      solver->addCols(nAdd, addStart, NULL, NULL, addLower, addUpper, NULL);
+      lower = solver->getColLower();
+      upper = solver->getColUpper();
+      // now rows
+      nAdd = 0;
+      int nEl = 0;
+      int nAddRow = 0;
+      for (int i = 0; i < numberIntegers; i++) {
+        int iColumn = integerVariableOrig[i];
+#ifdef COIN_HAS_CLP
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
+#endif
+        if (upper[iColumn] - lower[iColumn] > 1.000001) {
+          int up=static_cast<int>(upper[iColumn]);
+          int lo=static_cast<int>(lower[iColumn]);
+          addLower[nAddRow] = lo;
+          addUpper[nAddRow] = lo;
+          addIndex[nEl] = iColumn;
+          addElement[nEl++] = 1.0;
+          int n=up-lo;
+          // 1 - 1, 2,3 - 2, 4567 - 3
+          int el=1;
+          while (n) {
+            addIndex[nEl] = numberColumns+nAdd;
+            addElement[nEl++] = -el;
+            nAdd++;
+            n = n>>1;
+            el = el<<1;
+          }
+          nAddRow++;
+          addStart[nAddRow]=nEl;
+        }
+      }
+      for (int i=0;i<nAdd;i++)
+        solver->setInteger(i+numberColumns);
+      solver->addRows(nAddRow, addStart, addIndex, addElement, addLower, addUpper);
+      delete [] addStart;
+      delete [] addIndex;
+      delete [] addElement;
+      delete [] addLower;
+      delete [] addUpper;
+      solver->resolve();
+      solver->writeMps("test");
+      // new CbcModel
+      model_=new CbcModel(*solver);
+      model_->findIntegers(true);
+      // set cutoff
+      solver->setDblParam(OsiDualObjectiveLimit, cutoff);
+      model_->setCutoff(cutoff);
+      newSolution2 = new double [numberColumns+nAdd]; 
+      objective2=objectiveValue;
+      returnCode2=solutionInternal(objective2,newSolution2);
+      delete solver;
+      delete model_;
+      model_=saveModel;
+    }
+  }
+  int returnCode=solutionInternal(objectiveValue,newSolution);
+  if (returnCode2&&false) {
+    int numberColumns=model_->getNumCols();
+    memcpy(newSolution,newSolution2,numberColumns*sizeof(double));
+  }
+  delete [] newSolution2;
+  return returnCode;
+}
 
 // update model
@@ -2433 +2661 @@
                 for (CoinBigIndex k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
                     int iColumn = column[k];
-                    if (elementByRow[k] != 1.0 || !solver->isInteger(iColumn)) {
+                    if (elementByRow[k] != 1.0 || !isHeuristicInteger(solver,iColumn)) {
                         cover = false;
                         break;
@@ -2479 +2707 @@
             for (CoinBigIndex k = rowStart[i]; k < rowStart[i] + rowLength[i]; k++) {
                 int iColumn = column[k];
-                if (elementByRow[k] != 1.0 || !solver->isInteger(iColumn)) {
+                if (elementByRow[k] != 1.0 || !isHeuristicInteger(solver,iColumn)) {
                     cover = false;
                     break;
@@ -2700 +2928 @@
             // First improve by moving continuous ones
             for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                if (!solver->isInteger(iColumn)) {
+                if (!isHeuristicInteger(solver,iColumn)) {
                     double solValue = solution[iColumn];
                     double thetaUp = columnUpper[iColumn] - solValue;

trunk/Cbc/src/CbcHeuristicFPump.hpp

@@ -65 +65 @@
     virtual int solution(double & objectiveValue,
                          double * newSolution);
-
+    /** If general integers then adds variables to turn into binaries round
+      solution
+    */
+    int solutionGeneral(double & objectiveValue, double * newSolution,
+                        int maxAround=1,bool fixSatisfied=false);
     /// Set maximum Time (default off) - also sets starttime to current
     void setMaximumTime(double value);
@@ -249 +253 @@
          reuse - refers to initial solve after adding in new "cut"
          If we add 8 then can run after initial cuts (if no solution)
+         16 - extra rounding
+         32,64,128 - create binaries for general 
     */
     int accumulate_;
@@ -271 +277 @@
                /*bool roundExpensive=false,*/
                double downValue = 0.5, int *flip = 0);
+    /// Does real work
+  int solutionInternal(double & objectiveValue, double * newSolution);
     /* note for eagle eyed readers.
        when_ can now be exotic -

trunk/Cbc/src/CbcHeuristicGreedy.cpp

@@ -172 +172 @@
         CoinBigIndex j;
         double value = solution[iColumn];
-        if (solver->isInteger(iColumn)) {
+        if (isHeuristicInteger(solver,iColumn)) {
             // Round down integer
             if (fabs(floor(value + 0.5) - value) < integerTolerance) {
@@ -201 +201 @@
             CoinBigIndex j;
             double value = solution[iColumn];
-            if (solver->isInteger(iColumn)) {
+            if (isHeuristicInteger(solver,iColumn)) {
                 // but round up if no activity
                 if (roundup && value >= 0.499999 && !newSolution[iColumn]) {
@@ -246 +246 @@
             double value = newSolution[iColumn];
             double cost = direction * objective[iColumn];
-            if (solver->isInteger(iColumn)) {
+            if (isHeuristicInteger(solver,iColumn)) {
                 // use current upper or original upper
                 if (value + 0.99 < originalUpper[iColumn]) {
@@ -593 +593 @@
         CoinBigIndex j;
         double value = solution[iColumn];
-        if (solver->isInteger(iColumn)) {
+        if (isHeuristicInteger(solver,iColumn)) {
             // Round down integer
             if (fabs(floor(value + 0.5) - value) < integerTolerance) {
@@ -623 +623 @@
             CoinBigIndex j;
             double value = solution[iColumn];
-            if (solver->isInteger(iColumn)) {
+            if (isHeuristicInteger(solver,iColumn)) {
                 // but round up if no activity
                 if (roundup && value >= 0.6 && !newSolution[iColumn]) {
@@ -669 +669 @@
             double value = newSolution[iColumn];
             double cost = direction * objective[iColumn];
-            if (solver->isInteger(iColumn)) {
+            if (isHeuristicInteger(solver,iColumn)) {
                 // use current upper or original upper
                 if (value + 0.9999 < originalUpper[iColumn]) {
@@ -750 +750 @@
         OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
         for (iColumn = 0; iColumn < numberColumns; iColumn++) {
-            if (newSolver->isInteger(iColumn))
+            if (isHeuristicInteger(newSolver,iColumn))
                 newSolver->setColLower(iColumn, newSolution[iColumn]);
         }
@@ -1036 +1036 @@
         int nSOS=0;
         int iSOS=-1;
-        if (!solver->isInteger(iColumn))
+        if (!isHeuristicInteger(solver,iColumn))
           good = false;
         for (j = columnStart[iColumn];
@@ -1862 +1862 @@
             CoinBigIndex j;
             int nSOS=0;
-            if (!solver->isInteger(iColumn))
+            if (!isHeuristicInteger(solver,iColumn))
               good = false;
             for (j = columnStart[iColumn];

trunk/Cbc/src/CbcHeuristicLocal.cpp

@@ -182 +182 @@
     for (i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(newSolver,iColumn))
+          continue;
         const OsiObject * object = model_->object(i);
         // get original bounds
@@ -212 +214 @@
         for (i = 0; i < numberIntegers; i++) {
             int iColumn = integerVariable[i];
+            if (!isHeuristicInteger(newSolver,iColumn))
+              continue;
             if (used_[iColumn]) {
                 which[n] = iColumn;
@@ -224 +228 @@
         for (i = 0; i < n; i++) {
             int iColumn = integerVariable[i];
+            if (!isHeuristicInteger(newSolver,iColumn))
+              continue;
             if (used_[iColumn] <= allow) {
                 newSolver->setColUpper(iColumn, colLower[iColumn]);
@@ -260 +266 @@
                 double direction = newSolver->getObjSense();
                 for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                    if (!newSolver->isInteger(iColumn)) {
+                    if (!isHeuristicInteger(newSolver,iColumn)) {
                         if (!used_[iColumn]) {
                             //double djValue = dj[iColumn]*direction;
@@ -275 +281 @@
                     int nFix2 = 0;
                     for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                        if (!newSolver->isInteger(iColumn)) {
+                        if (!isHeuristicInteger(newSolver,iColumn)) {
                             if (!used_[iColumn]) {
                                 double djValue = dj[iColumn] * direction;
@@ -437 +443 @@
     const double * columnLower = solver->getColLower();
     for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-        if (!solver->isInteger(iColumn)) {
+        if (!isHeuristicInteger(solver,iColumn)) {
             if (solution[iColumn] > columnLower[iColumn] + 1.0e-8)
                 used_[iColumn] = numberSolutions_;
@@ -473 +479 @@
     for (i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(solver,iColumn))
+          continue;
         const OsiObject * object = model_->object(i);
         // get original bounds
@@ -571 +579 @@
         int * integerVariable = 
           CoinCopyOfArray(model_->integerVariable(),numberIntegers);
+#ifdef COIN_HAS_CLP
+        OsiClpSolverInterface * clpSolver
+          = dynamic_cast<OsiClpSolverInterface *> (model_->solver());
+        if (clpSolver ) {
+          // take out some integers
+          int nn=numberIntegers;
+          numberIntegers=0;
+          for (int i=0;i<nn;i++) {
+            int iColumn=integerVariable[i];
+            if (clpSolver->isHeuristicInteger(iColumn))
+              integerVariable[numberIntegers++]=iColumn;
+          }
+        }
+#endif
         if (swap>9 && numberIntegers>500) {
           int type=swap/10;
@@ -1147 +1169 @@
   for (int i = 0; i < numberIntegers; i++) {
     int iColumn = integerVariable[i];
+    if (!isHeuristicInteger(newSolver,iColumn))
+      continue;
     if (fabs(solutionIn[iColumn])<1.0e-5) 
       obj[iColumn]=1.0;
@@ -1201 +1225 @@
   if ((returnCode&1) != 0) {
     // redo objective
-    const double * obj = model_->continuousSolver()->getObjCoefficients();
+    OsiSolverInterface * solver = model_->continuousSolver();
+    const double * obj = solver->getObjCoefficients();
     solutionValue = - offset;
     int sumIncrease=0.0;
@@ -1209 +1234 @@
     for (int i=0;i<numberColumns;i++) {
       solutionValue += obj[i]*betterSolution[i];
-      if (model_->isInteger(i)) {
+      if (isHeuristicInteger(solver,i)) {
         int change=static_cast<int>(floor(solutionIn[i]-betterSolution[i]+0.5));
         if (change>0) {
@@ -1360 +1385 @@
     for (i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(newSolver,iColumn))
+          continue;
         double lower = colLower[iColumn];
         double upper = colUpper[iColumn];
@@ -1389 +1416 @@
     for (i = 0; i < numberIntegers; i++) {
         int iColumn = integerVariable[i];
+        if (!isHeuristicInteger(newSolver,iColumn))
+          continue;
         double lower = colLower[iColumn];
         double upper = colUpper[iColumn];
@@ -1451 +1480 @@
         double newLower;
         double newUpper;
-        if (newSolver->isInteger(iColumn)) {
+        if (isHeuristicInteger(newSolver,iColumn)) {
             newLower = CoinMax(lower, floor(value) - 2.0);
             newUpper = CoinMin(upper, ceil(value) + 2.0);
@@ -1474 +1503 @@
                 double newLower = lower;
                 double newUpper = upper;
-                if (newSolver->isInteger(iColumn)) {
+                if (isHeuristicInteger(newSolver,iColumn)) {
                     if (value < lower + 1.0e-6) {
                         nFix++;
@@ -1640 +1669 @@
         const double * solution = model_->savedSolution(k);
         for (int j = 0; j < numberColumns; j++) {
-            if (solver->isInteger(j)) {
+            if (isHeuristicInteger(solver,j)) {
                 if (fixed[j] == -COIN_DBL_MAX)
                     fixed[j] = floor(solution[j] + 0.5);
@@ -1650 +1679 @@
     const double * colLower = solver->getColLower();
     for (int i = 0; i < numberColumns; i++) {
-        if (solver->isInteger(i)) {
+        if (isHeuristicInteger(solver,i)) {
             double value = fixed[i];
             if (value != COIN_DBL_MAX) {

trunk/Cbc/src/CbcHeuristicRINS.cpp

@@ -166 +166 @@
         numberSolutions_ = model_->getSolutionCount();
 
+        OsiSolverInterface * solver = model_->solver();
         int numberIntegers = model_->numberIntegers();
         const int * integerVariable = model_->integerVariable();
@@ -172 +173 @@
         for (i = 0; i < numberIntegers; i++) {
             int iColumn = integerVariable[i];
+            if (!isHeuristicInteger(solver,iColumn))
+              continue;
             const OsiObject * object = model_->object(i);
             // get original bounds
@@ -223 +226 @@
         for (i = 0; i < numberIntegers; i++) {
             int iColumn = integerVariable[i];
+            if (!isHeuristicInteger(solver,iColumn))
+              continue;
             const OsiObject * object = model_->object(i);
             // get original bounds
@@ -282 +287 @@
                 double direction = newSolver->getObjSense();
                 for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                    if (!newSolver->isInteger(iColumn)) {
+                    if (!isHeuristicInteger(newSolver,iColumn)) {
                         double value = bestSolution[iColumn];
                         if (value < colLower[iColumn] + 1.0e-8) {
@@ -298 +303 @@
                     int nFix2 = 0;
                     for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
-                        if (!newSolver->isInteger(iColumn)) {
+                        if (!isHeuristicInteger(newSolver,iColumn)) {
                             double value = bestSolution[iColumn];
                             if (value < colLower[iColumn] + 1.0e-8) {

trunk/Cbc/src/CbcSolver.cpp

@@ -4362 +4362 @@
                                     threshold -= 10000*highPriority;
                                   }
+                                  // If 1000 set then don't put obj on ne variables
+                                  bool moveObjective=true;
+                                  if (threshold>1000) {
+                                    moveObjective=false;
+                                    threshold -= 1000;
+                                  }
                                   const double * columnLower = solver2->getColLower();
                                   const double * columnUpper = solver2->getColUpper();
@@ -4492 +4498 @@
                                           for (int kColumn=iLast;kColumn<jColumn;kColumn++) {
                                             iColumn=which[kColumn];
-                                            solver2->setObjCoeff(iColumn,0.0);
+                                            if (moveObjective)
+                                              solver2->setObjCoeff(iColumn,0.0);
                                             double lowerValue=columnLower[iColumn];
                                             double upperValue=columnUpper[iColumn];
@@ -4501 +4508 @@
                                               elementValue=1.0;
                                             }
+                                            if (!moveObjective)
+                                              objectiveNew[numberDifferentObj]=0.0;
                                             columnAdd[numberElements]=iColumn;
                                             elementAdd[numberElements++]=elementValue;
@@ -4546 +4555 @@
                                                        lowerNew, upperNew,objectiveNew);
                                       // add constraints and make integer if all integer in group
+#ifdef COIN_HAS_CLP
+                                      OsiClpSolverInterface * clpSolver2
+                                        = dynamic_cast<OsiClpSolverInterface *> (solver2);
+#endif
                                       for (int iObj=0; iObj < numberDifferentObj; iObj++) {
                                         lowerNew[iObj]=0.0;
                                         upperNew[iObj]=0.0;
                                         solver2->setInteger(numberColumns+iObj);
+#ifdef COIN_HAS_CLP
+                                        if (clpSolver2)
+                                          clpSolver2->setOptionalInteger(numberColumns+iObj);
+#endif
                                       }
                                       solver2->addRows(numberDifferentObj, 

trunk/Cbc/src/CbcSolverHeuristics.cpp

@@ -1215 +1215 @@
             int accumulate = r / 1000;
             r -= 1000 * accumulate;
-            if (accumulate >= 10) {
-                int which = accumulate / 10;
-                accumulate -= 10 * which;
+            if (accumulate >= 100) {
+                int which = accumulate / 100;
+                accumulate -= 100 * which;
                 which--;
                 // weights and factors

trunk/Cbc/src/CbcSymmetry.hpp

@@ -222 +222 @@
   { return GSparse_ != NULL;}
   inline int errorStatus() const
+#ifndef NTY_TRACES
   { return stats_->errstatus;}
+#else
+  { return 0;}
+#endif
   /**
    * Methods to classify orbits.  Not horribly efficient, but gets the job done