Changeset 1053


Ignore:
Timestamp:
Sep 4, 2008 4:48:22 PM (10 years ago)
Author:
forrest
Message:

trying to make go faster

Location:
trunk/Cbc/src
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/Cbc/src/CbcBranchActual.cpp

    r1038 r1053  
    608608        int jColumn = members_[iWhere];
    609609        double solValue = info->solution_[jColumn];
     610        if (!solValue)
     611          continue;
    610612        objMove -= info->objective_[jColumn]*solValue;
    611613        for (j=info->columnStart_[jColumn];
  • trunk/Cbc/src/CbcBranchDynamic.cpp

    r931 r1053  
    710710    preferredWay=preferredWay_;
    711711  // weight at 1.0 is max min
    712 #define WEIGHT_AFTER 0.7
     712#define WEIGHT_AFTER 0.8
    713713#define WEIGHT_BEFORE 0.1
    714714  if (fabs(value-nearest)<=integerTolerance) {
     
    15381538    dynamic_cast<CbcBranchingObject *>(obj);
    15391539  assert (obj2);
     1540#if COIN_DEVELOP>1
    15401541  CbcDynamicPseudoCostBranchingObject * branchingObject =
    15411542    dynamic_cast<CbcDynamicPseudoCostBranchingObject *>(obj);
    1542 #if COIN_DEVELOP>1
    15431543  if (!branchingObject)
    15441544    printf("no dynamic branching object Dynamic Decision\n");
     
    17201720    bestNumberDown_=COIN_INT_MAX;
    17211721  }
     1722  // maybe branch up more if no solution or not many nodes done?
    17221723  if (stateOfSearch<=2) {
    1723     //#define TRY_STUFF 1
     1724//#define TRY_STUFF 1
    17241725#ifdef TRY_STUFF
    17251726    // before solution - choose smallest number
     
    17871788    value = WEIGHT_BEFORE*minValue + (1.0-WEIGHT_BEFORE)*maxValue;
    17881789    if (value>bestCriterion_+1.0e-8) {
    1789       if (changeUp<=changeDown) {
     1790      if (changeUp<=1.5*changeDown) {
    17901791        betterWay=1;
    17911792      } else {
     
    18311832#endif
    18321833    if (useValue>useBest+1.0e-8) {
    1833       if (changeUp<=changeDown) {
     1834      if (changeUp<=1.5*changeDown) {
    18341835        betterWay=1;
    18351836      } else {
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r1016 r1053  
    168168CbcCutGenerator::generateCuts( OsiCuts & cs , int fullScan, OsiSolverInterface * solver, CbcNode * node)
    169169{
    170 #define PROBE1 0
     170#define PROBE1 1
    171171#define PROBE2 0
    172 #define PROBE3 0
     172#define PROBE3 1
    173173  int depth;
    174174  if (node)
     
    256256#if PROBE3
    257257        if ((numberTimes_==200||(numberTimes_>200&&(numberTimes_%2000)==0))
    258              &&!model_->parentModel()) {
     258             &&!model_->parentModel()&&info.formulation_rows>500) {
    259259          // in tree, maxStack, maxProbe
    260260          int test[]= {
     
    272272          int saveStack = generator->getMaxLook();
    273273          int saveNumber = generator->getMaxProbe();
     274#undef CLP_INVESTIGATE
    274275#ifdef CLP_INVESTIGATE
    275276          int kr1=0;
     
    315316#ifdef CLP_INVESTIGATE
    316317            printf("RRSwitching off number %d -> %d, stack %d -> %d\n",
    317                    saveNumber,saveNumber,saveStack,1);
     318                   saveNumber,saveNumber,saveStack,0);
    318319#endif
    319320          }
     
    512513      const double * solution = solver->getColSolution();
    513514      bool feasible=true;
     515      double primalTolerance = 1.0e-7;
    514516      for (k = numberRowCutsAfter-1;k>=numberRowCutsBefore;k--) {
    515517        const OsiRowCut * thisCut = cs.rowCutPtr(k) ;
     
    529531            sum += value*solution[column[i]];
    530532          }
    531           if (sum>thisCut->ub()) {
     533          if (sum>thisCut->ub()+primalTolerance) {
    532534            sum= sum-thisCut->ub();
    533           } else if (sum<thisCut->lb()) {
     535          } else if (sum<thisCut->lb()-primalTolerance) {
    534536            sum= thisCut->lb()-sum;
    535537          } else {
     
    608610        // Now see which ones are too similar
    609611        int nParallel=0;
     612        double testValue = (depth>1) ? 0.99 : 0.999999;
    610613        for (k = 0;k<nCuts;k++) {
    611614          int j=which[k];
     
    626629          }
    627630          int kkk = CoinMin(nCuts,k+5);
    628           double testValue = (depth>1) ? 0.9 : 0.99999;
    629631          for (int kk=k+1;kk<kkk;kk++) {
    630632            int jj=which[kk];
  • trunk/Cbc/src/CbcHeuristic.cpp

    r1020 r1053  
    472472CbcHeuristic::~CbcHeuristic ()
    473473{
     474  delete [] inputSolution_;
    474475}
    475476
     
    496497  // Use this fraction
    497498  double fractionSmall = fractionSmall_;
    498   if (before>20000.0) {
     499  if (before>40000.0) {
    499500    // fairly large - be more conservative
    500     double multiplier = 1.0 - 0.3*CoinMin(100000.0,before-20000.0)/100000.0;
     501    double multiplier = 1.0 - 0.3*CoinMin(100000.0,before-40000.0)/100000.0;
    501502    if (multiplier<1.0) {
    502503      fractionSmall *= multiplier;
     
    623624              <<CoinMessageEol;
    624625          } else {
    625             returnCode=-1; // infeasible
     626            returnCode=2; // infeasible
    626627          }
    627628        }
    628629      }
    629630    } else {
    630       returnCode=-1; // infeasible
     631      returnCode=2; // infeasible
    631632    }
    632633    solver->messageHandler()->setLogLevel(saveLogLevel);
    633634  }
    634   if (returnCode==-1) {
     635  if (returnCode==2) {
    635636    delete [] reset;
    636637#ifdef HISTORY_STATISTICS
     
    721722            // Turn on if was turned on
    722723            int iOften = model_->cutGenerator(i)->howOften();
     724#ifdef CLP_INVESTIGATE
    723725            printf("Gen %d often %d %d\n",
    724726                   i,model.cutGenerator(i)->howOften(),
    725727                   iOften);
     728#endif
    726729            if (iOften>0)
    727730              model.cutGenerator(i)->setHowOften(iOften%1000000);
     
    814817                >=1000 use index+1 as number of large loops
    815818                >=100 use 0.05 objvalue as increment
    816                 >=10 use +0.1 objvalue for cutoff (add)
     819                %100 == 10,20 etc for experimentation
    817820                1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds
    818821                4 and static continuous, 5 as 3 but no internal integers
     
    821824              double value = solver2->getObjSense()*solver2->getObjValue();
    822825              int w = pumpTune/10;
     826              int ix = w % 10;
     827              w /= 10;
    823828              int c = w % 10;
    824               w /= 10;
    825               int i = w % 10;
    826829              w /= 10;
    827830              int r = w;
     
    845848                heuristic4.setFakeCutoff(cutoff);
    846849              }
    847               if (i||r) {
     850              if (r) {
    848851                // also set increment
    849852                //double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12);
     
    856859              if (pumpTune==6)
    857860                pumpTune =13;
    858               heuristic4.setWhen(pumpTune+10);
     861              if (pumpTune!=13)
     862                pumpTune = pumpTune%10;
     863              heuristic4.setWhen(pumpTune);
     864              if (ix) {
     865                heuristic4.setFeasibilityPumpOptions(ix*10);
     866              }
    859867            }
    860868            model.addHeuristic(&heuristic4,"feasibility pump",0);
  • trunk/Cbc/src/CbcHeuristic.hpp

    r1013 r1053  
    165165      3 finished - solution
    166166      (could add global cut if finished)
     167      -1 returned on size
     168      -2 time or user event
    167169  */
    168170  int smallBranchAndBound(OsiSolverInterface * solver,int numberNodes,
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r1020 r1053  
    1919#include "CoinTime.hpp"
    2020#include "CbcEventHandler.hpp"
     21#ifdef COIN_HAS_CLP
     22#include "OsiClpSolverInterface.hpp"
     23#endif
    2124
    2225
     
    258261  } else if ((accumulate_&8)==0) {
    259262    doGeneral=false;
     263    j=0;
     264    for (i=0;i<numberIntegers;i++) {
     265      int iColumn = integerVariableOrig[i];
     266      if (upper[iColumn]-lower[iColumn]<1.000001)
     267        integerVariable[j++]=iColumn;
     268    }
    260269  }
    261270  if (!general)
    262271    doGeneral=false;
     272#ifdef CLP_INVESTIGATE
     273  if (doGeneral)
     274    printf("DOing general with %d out of %d\n",general,numberIntegers);
     275#endif
    263276  // For solution closest to feasible if none found
    264277  int * closestSolution = general ? NULL : new int[numberIntegers];
     
    270283  double newSolutionValue=COIN_DBL_MAX;
    271284  bool solutionFound=false;
    272   char * usedColumn = NULL;
     285  int * usedColumn = NULL;
    273286  double * lastSolution=NULL;
    274287  int fixContinuous=0;
     
    317330      fixContinuous=2;
    318331    when_=1;
    319     usedColumn = new char [numberColumns];
    320     memset(usedColumn,0,numberColumns);
     332    usedColumn = new int [numberColumns];
     333    for (int i=0;i<numberColumns;i++)
     334      usedColumn[i]=-1;
    321335    lastSolution = CoinCopyOfArray(model_->solver()->getColSolution(),numberColumns);
    322336  }
     
    334348  double roundingObjective = solutionValue;
    335349  CbcRounding roundingHeuristic(*model_);
     350  int dualPass = 0;
     351  int secondPassOpt=0;
     352  if (feasibilityPumpOptions_>0) {
     353    secondPassOpt = (feasibilityPumpOptions_/10)%10;
     354    /* 1 to 7 - re-use solution
     355       8 use dual and current solution(ish)
     356       9 use dual and allslack
     357       1 - primal and mod obj
     358       2 - dual and mod obj
     359       3 - primal and no mod obj
     360       add 3 to redo current solution
     361    */
     362    if (secondPassOpt>=8) {
     363      dualPass=secondPassOpt-7;
     364      secondPassOpt=0;
     365    }
     366  }
    336367  while (!exitAll) {
    337368    int numberPasses=0;
     
    342373    // Clone solver - otherwise annoys root node computations
    343374    solver = model_->solver()->clone();
     375#ifdef COIN_HAS_CLP
     376    {
     377      OsiClpSolverInterface * clpSolver
     378        = dynamic_cast<OsiClpSolverInterface *> (solver);
     379      if (clpSolver) {
     380        // better to clean up using primal?
     381        ClpSimplex * lp = clpSolver->getModelPtr();
     382        int options = lp->specialOptions();
     383        lp->setSpecialOptions(options|8192);
     384        //lp->setSpecialOptions(options|0x01000000);
     385      }
     386    }
     387#endif
    344388    if (CoinMin(fakeCutoff_,cutoff)<1.0e50) {
    345389      // Fix on djs
     
    363407    bool useCutoff = (fabs(cutoff)<1.0e20&&(fakeCutoff_!=COIN_DBL_MAX||numberTries>1));
    364408    // but there may be a close one
    365     if (firstCutoff<2.0*solutionValue&&numberTries==1)
     409    if (firstCutoff<2.0*solutionValue&&numberTries==1/*&&CoinMin(cutoff,fakeCutoff_)<1.0e20*/)
    366410      useCutoff=true;
    367411    if (useCutoff) {
     
    479523        for (i=0;i<numberColumns;i++) {
    480524          if (fabs(solution[i]-lastSolution[i])>1.0e-8)
    481             usedColumn[i]=1;
     525            usedColumn[i]=numberPasses;
    482526          lastSolution[i]=solution[i];
    483527        }
     
    845889          OsiHintStrength strength;
    846890          solver->getHintParam(OsiDoDualInResolve,takeHint,strength);
    847           if (numberPerturbed>numberColumns)
     891          if (dualPass) {
    848892            solver->setHintParam(OsiDoDualInResolve,true); // dual may be better
    849           if (numberTries>1&&numberPasses==1&&false) {
     893            if (dualPass==1) {
     894              // but we need to make infeasible
     895              CoinWarmStartBasis * basis =
     896                dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
     897              if (basis) {
     898                // modify
     899                const double * lower = solver->getColLower();
     900                const double * upper = solver->getColUpper();
     901                double * solution = CoinCopyOfArray(solver->getColSolution(),
     902                                                    numberColumns);
     903                const double * objective = solver->getObjCoefficients();
     904                int nChanged=0;
     905                for (i=0;i<numberIntegersOrig;i++) {
     906                  int iColumn=integerVariableOrig[i];
     907                  if (objective[iColumn]>0.0) {
     908                    if (basis->getStructStatus(iColumn)==
     909                        CoinWarmStartBasis::atUpperBound) {
     910                      solution[iColumn]=lower[iColumn];
     911                      basis->setStructStatus(iColumn,CoinWarmStartBasis::atLowerBound);
     912                      nChanged++;
     913                    }
     914                  } else if (objective[iColumn]<0.0) {
     915                    if (basis->getStructStatus(iColumn)==
     916                        CoinWarmStartBasis::atUpperBound) {
     917                      solution[iColumn]=upper[iColumn];
     918                      basis->setStructStatus(iColumn,CoinWarmStartBasis::atUpperBound);
     919                      nChanged++;
     920                    }
     921                  }
     922                }
     923                if (!nChanged) {
     924                  for (i=0;i<numberIntegersOrig;i++) {
     925                    int iColumn=integerVariableOrig[i];
     926                    if (objective[iColumn]>0.0) {
     927                      if (basis->getStructStatus(iColumn)==
     928                          CoinWarmStartBasis::basic) {
     929                        solution[iColumn]=lower[iColumn];
     930                        basis->setStructStatus(iColumn,CoinWarmStartBasis::atLowerBound);
     931                        break;
     932                      }
     933                    } else if (objective[iColumn]<0.0) {
     934                      if (basis->getStructStatus(iColumn)==
     935                          CoinWarmStartBasis::basic) {
     936                        solution[iColumn]=upper[iColumn];
     937                        basis->setStructStatus(iColumn,CoinWarmStartBasis::atUpperBound);
     938                        break;
     939                      }
     940                    }
     941                  }
     942                }
     943                solver->setColSolution(solution);
     944                delete [] solution;
     945                solver->setWarmStart(basis);
     946                delete basis;
     947              }
     948            } else {
     949              // faster to do from all slack!!!! ???
     950              CoinWarmStartBasis dummy;
     951              solver->setWarmStart(&dummy);
     952            }
     953          }
     954          if (numberTries>1&&numberPasses==1&&firstPerturbedObjective) {
     955            // Modify to use convex combination
    850956            // use basis from first time
    851957            solver->setWarmStart(&saveBasis);
    852958            // and objective
    853             solver->setObjective(firstPerturbedObjective);
     959            if (secondPassOpt<3||(secondPassOpt>=4&&secondPassOpt<6))
     960              solver->setObjective(firstPerturbedObjective);
    854961            // and solution
    855962            solver->setColSolution(firstPerturbedSolution);
     963            if (secondPassOpt==2||secondPassOpt==5)
     964              solver->setHintParam(OsiDoDualInResolve,true); // dual may be better
    856965          }
    857966          solver->resolve();
     
    861970            break;
    862971          }
    863           if (numberTries==1&&numberPasses==1&&false) {
    864             // save basis
    865             CoinWarmStartBasis * basis =
    866               dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
    867             if (basis) {
    868               saveBasis = * basis;
    869               delete basis;
    870             }
    871             firstPerturbedObjective = CoinCopyOfArray(solver->getObjCoefficients(),numberColumns);
    872             firstPerturbedSolution = CoinCopyOfArray(solver->getColSolution(),numberColumns);
     972          if (numberPasses==1&&secondPassOpt) {
     973            if (numberTries==1||secondPassOpt>3) {
     974              // save basis
     975              CoinWarmStartBasis * basis =
     976                dynamic_cast<CoinWarmStartBasis *>(solver->getWarmStart()) ;
     977              if (basis) {
     978                saveBasis = * basis;
     979                delete basis;
     980              }
     981              firstPerturbedObjective = CoinCopyOfArray(solver->getObjCoefficients(),numberColumns);
     982              firstPerturbedSolution = CoinCopyOfArray(solver->getColSolution(),numberColumns);
     983            }
    873984          }
    874985          solver->setHintParam(OsiDoDualInResolve,takeHint);
     
    10441155            if (newSolution[iColumn]>lower[iColumn]+primalTolerance&&
    10451156                newSolution[iColumn]<upper[iColumn]-primalTolerance) {
     1157              assert (upper[iColumn]-lower[iColumn]>1.00001);
    10461158              obj[nAdd]=1.0;
    10471159              addLower[nAdd]=0.0;
     
    11071219            delete solver2;
    11081220          }
     1221          lower = solver->getColLower();
     1222          upper = solver->getColUpper();
     1223          solution = solver->getColSolution();
     1224          newTrueSolutionValue = -saveOffset;
     1225          newSumInfeas=0.0;
     1226          newNumberInfeas=0;
     1227          {
     1228            const double * newSolution = solver->getColSolution();
     1229            for (  i=0 ; i<numberColumns ; i++ ) {
     1230              if (solver->isInteger(i)) {
     1231                double value = newSolution[i];
     1232                double nearest = floor(value+0.5);
     1233                newSumInfeas += fabs(value-nearest);
     1234                if (fabs(value-nearest)>1.0e-6)
     1235                  newNumberInfeas++;
     1236              }
     1237              newTrueSolutionValue += saveObjective[i]*newSolution[i];
     1238            }
     1239            newTrueSolutionValue *= direction;
     1240          }
    11091241        }
    11101242        if (lastMove!=1000000) {
     
    11751307      const double * colLower = newSolver->getColLower();
    11761308      const double * colUpper = newSolver->getColUpper();
    1177       int i;
    1178       int nFix=0;
    1179       int nFixI=0;
    1180       int nFixC=0;
    1181       int nFixC2=0;
    1182       for (i=0;i<numberIntegersOrig;i++) {
    1183         int iColumn=integerVariableOrig[i];
    1184         //const OsiObject * object = model_->object(i);
    1185         //double originalLower;
    1186         //double originalUpper;
    1187         //getIntegerInformation( object,originalLower, originalUpper);
    1188         //assert(colLower[iColumn]==originalLower);
    1189         //newSolver->setColLower(iColumn,CoinMax(colLower[iColumn],originalLower));
    1190         newSolver->setColLower(iColumn,colLower[iColumn]);
    1191         //assert(colUpper[iColumn]==originalUpper);
    1192         //newSolver->setColUpper(iColumn,CoinMin(colUpper[iColumn],originalUpper));
    1193         newSolver->setColUpper(iColumn,colUpper[iColumn]);
    1194         if (!usedColumn[iColumn]) {
    1195           double value=lastSolution[iColumn];
    1196           double nearest = floor(value+0.5);
    1197           if (fabs(value-nearest)<1.0e-7) {
    1198             if (nearest==colLower[iColumn]) {
    1199               newSolver->setColUpper(iColumn,colLower[iColumn]);
    1200               nFix++;
    1201             } else if (nearest==colUpper[iColumn]) {
    1202               newSolver->setColLower(iColumn,colUpper[iColumn]);
    1203               nFix++;
    1204             } else if (fixInternal) {
    1205               newSolver->setColLower(iColumn,nearest);
    1206               newSolver->setColUpper(iColumn,nearest);
    1207               nFix++;
    1208               nFixI++;
    1209             }
    1210           }
    1211         }
    1212       }
    1213       if (fixContinuous) {
    1214         for (int iColumn=0;iColumn<numberColumns;iColumn++) {
    1215           if (!newSolver->isInteger(iColumn)&&!usedColumn[iColumn]) {
     1309      bool stopBAB=false;
     1310      int allowedPass=-1;
     1311      while (!stopBAB) {
     1312        stopBAB=true;
     1313        int i;
     1314        int nFix=0;
     1315        int nFixI=0;
     1316        int nFixC=0;
     1317        int nFixC2=0;
     1318        for (i=0;i<numberIntegersOrig;i++) {
     1319          int iColumn=integerVariableOrig[i];
     1320          //const OsiObject * object = model_->object(i);
     1321          //double originalLower;
     1322          //double originalUpper;
     1323          //getIntegerInformation( object,originalLower, originalUpper);
     1324          //assert(colLower[iColumn]==originalLower);
     1325          //newSolver->setColLower(iColumn,CoinMax(colLower[iColumn],originalLower));
     1326          newSolver->setColLower(iColumn,colLower[iColumn]);
     1327          //assert(colUpper[iColumn]==originalUpper);
     1328          //newSolver->setColUpper(iColumn,CoinMin(colUpper[iColumn],originalUpper));
     1329          newSolver->setColUpper(iColumn,colUpper[iColumn]);
     1330          if (usedColumn[iColumn]<=allowedPass) {
    12161331            double value=lastSolution[iColumn];
    1217             if (value<colLower[iColumn]+1.0e-8) {
    1218               newSolver->setColUpper(iColumn,colLower[iColumn]);
    1219               nFixC++;
    1220             } else if (value>colUpper[iColumn]-1.0e-8) {
    1221               newSolver->setColLower(iColumn,colUpper[iColumn]);
    1222               nFixC++;
    1223             } else if (fixContinuous==2) {
    1224               newSolver->setColLower(iColumn,value);
    1225               newSolver->setColUpper(iColumn,value);
    1226               nFixC++;
    1227               nFixC2++;
    1228             }
    1229           }
    1230         }
    1231       }
    1232       newSolver->initialSolve();
    1233       if (!newSolver->isProvenOptimal()) {
    1234         //newSolver->writeMps("bad.mps");
    1235         //assert (newSolver->isProvenOptimal());
    1236         exitAll=true;
    1237         break;
    1238       }
    1239       sprintf(pumpPrint,"Before mini branch and bound, %d integers at bound fixed and %d continuous",
    1240              nFix,nFixC);
    1241       if (nFixC2+nFixI!=0)
    1242         sprintf(pumpPrint+strlen(pumpPrint)," of which %d were internal integer and %d internal continuous",
    1243                 nFixI,nFixC2);
    1244       model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    1245         << pumpPrint
    1246         <<CoinMessageEol;
    1247       double saveValue = newSolutionValue;
    1248       if (newSolutionValue-model_->getCutoffIncrement()
    1249           >continuousObjectiveValue-1.0e-7) {
    1250         double saveFraction = fractionSmall_;
    1251         if (numberTries>1&&!numberBandBsolutions)
    1252           fractionSmall_ *= 0.5;
    1253         // Give branch and bound a bit more freedom
    1254         double cutoff2=newSolutionValue-model_->getCutoffIncrement();
    1255         int returnCode2 = smallBranchAndBound(newSolver,numberNodes_,newSolution,newSolutionValue,
    1256                                               cutoff2,"CbcHeuristicLocalAfterFPump");
    1257         fractionSmall_ = saveFraction;
    1258         if (returnCode2<0) {
    1259           if (returnCode2==-2)
    1260             exitAll=true;
    1261           returnCode2=0; // returned on size (or event) - could try changing
    1262         }
    1263         if ((returnCode2&2)!=0) {
    1264           // could add cut
    1265           returnCode2 &= ~2;
    1266         }
    1267         if (returnCode2)
    1268           numberBandBsolutions++;
    1269       } else {
    1270         // no need
    1271         exitAll=true;
    1272         //returnCode=0;
    1273       }
    1274       // recompute solution value
    1275       if (returnCode&&true) {
    1276         delete newSolver;
    1277         newSolver = model_->continuousSolver()->clone();
    1278         newSolutionValue = -saveOffset;
    1279         double newSumInfeas=0.0;
    1280         const double * obj = newSolver->getObjCoefficients();
    1281         for (int i=0 ; i<numberColumns ; i++ ) {
    1282           if (newSolver->isInteger(i)) {
    1283             double value = newSolution[i];
    12841332            double nearest = floor(value+0.5);
    1285             newSumInfeas += fabs(value-nearest);
    1286           }
    1287           newSolutionValue += obj[i]*newSolution[i];
    1288         }
    1289         newSolutionValue *= direction;
    1290       }
    1291       if (returnCode&&newSolutionValue<saveValue) {
    1292         sprintf(pumpPrint,"Mini branch and bound improved solution from %g to %g (%.2f seconds)",
    1293                 saveValue,newSolutionValue,model_->getCurrentSeconds());
     1333            if (fabs(value-nearest)<1.0e-7) {
     1334              if (nearest==colLower[iColumn]) {
     1335                newSolver->setColUpper(iColumn,colLower[iColumn]);
     1336                nFix++;
     1337              } else if (nearest==colUpper[iColumn]) {
     1338                newSolver->setColLower(iColumn,colUpper[iColumn]);
     1339                nFix++;
     1340              } else if (fixInternal) {
     1341                newSolver->setColLower(iColumn,nearest);
     1342                newSolver->setColUpper(iColumn,nearest);
     1343                nFix++;
     1344                nFixI++;
     1345              }
     1346            }
     1347          }
     1348        }
     1349        if (fixContinuous) {
     1350          for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     1351            if (!newSolver->isInteger(iColumn)&&usedColumn[iColumn]<=allowedPass) {
     1352              double value=lastSolution[iColumn];
     1353              if (value<colLower[iColumn]+1.0e-8) {
     1354                newSolver->setColUpper(iColumn,colLower[iColumn]);
     1355                nFixC++;
     1356              } else if (value>colUpper[iColumn]-1.0e-8) {
     1357                newSolver->setColLower(iColumn,colUpper[iColumn]);
     1358                nFixC++;
     1359              } else if (fixContinuous==2) {
     1360                newSolver->setColLower(iColumn,value);
     1361                newSolver->setColUpper(iColumn,value);
     1362                nFixC++;
     1363                nFixC2++;
     1364              }
     1365            }
     1366          }
     1367        }
     1368        newSolver->initialSolve();
     1369        if (!newSolver->isProvenOptimal()) {
     1370          //newSolver->writeMps("bad.mps");
     1371          //assert (newSolver->isProvenOptimal());
     1372          exitAll=true;
     1373          break;
     1374        }
     1375        sprintf(pumpPrint,"Before mini branch and bound, %d integers at bound fixed and %d continuous",
     1376                nFix,nFixC);
     1377        if (nFixC2+nFixI!=0)
     1378          sprintf(pumpPrint+strlen(pumpPrint)," of which %d were internal integer and %d internal continuous",
     1379                  nFixI,nFixC2);
    12941380        model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    12951381          << pumpPrint
    12961382          <<CoinMessageEol;
    1297         memcpy(betterSolution,newSolution,numberColumns*sizeof(double));
    1298         if (fixContinuous) {
    1299           // may be able to do even better
    1300           const double * lower = model_->solver()->getColLower();
    1301           const double * upper = model_->solver()->getColUpper();
    1302           for (int iColumn=0;iColumn<numberColumns;iColumn++) {
    1303             if (newSolver->isInteger(iColumn)) {
    1304               double value=floor(newSolution[iColumn]+0.5);
    1305               newSolver->setColLower(iColumn,value);
    1306               newSolver->setColUpper(iColumn,value);
     1383        double saveValue = newSolutionValue;
     1384        if (newSolutionValue-model_->getCutoffIncrement()
     1385            >continuousObjectiveValue-1.0e-7) {
     1386          double saveFraction = fractionSmall_;
     1387          if (numberTries>1&&!numberBandBsolutions)
     1388            fractionSmall_ *= 0.5;
     1389          // Give branch and bound a bit more freedom
     1390          double cutoff2=newSolutionValue+
     1391            CoinMax(model_->getCutoffIncrement(),1.0e-3);
     1392          int returnCode2 = smallBranchAndBound(newSolver,numberNodes_,newSolution,newSolutionValue,
     1393                                                cutoff2,"CbcHeuristicLocalAfterFPump");
     1394          fractionSmall_ = saveFraction;
     1395          if (returnCode2<0) {
     1396            if (returnCode2==-2) {
     1397              exitAll=true;
     1398              returnCode=0;
    13071399            } else {
    1308               newSolver->setColLower(iColumn,lower[iColumn]);
    1309               newSolver->setColUpper(iColumn,upper[iColumn]);
    1310             }
    1311           }
    1312           newSolver->initialSolve();
    1313           if (newSolver->isProvenOptimal()) {
    1314             double value = newSolver->getObjValue()*newSolver->getObjSense();
    1315             if (value<newSolutionValue) {
    1316               //newSolver->writeMps("query","mps");
     1400              returnCode2=0; // returned on size - try changing
     1401              //#define ROUND_AGAIN
     1402#ifdef ROUND_AGAIN
     1403              if (numberTries==1&&numberPasses>20&&allowedPass<numberPasses-1) {
     1404                allowedPass=(numberPasses+allowedPass)>>1;
     1405                sprintf(pumpPrint,
     1406                        "Fixing all variables which were last changed on pass %d and trying again",
     1407                       allowedPass);
     1408                model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
     1409                  << pumpPrint
     1410                  <<CoinMessageEol;
     1411                stopBAB=false;
     1412                continue;
     1413              }
     1414#endif
     1415            }
     1416          }
     1417          if ((returnCode2&2)!=0) {
     1418            // could add cut
     1419            returnCode2 &= ~2;
     1420          }
     1421          if (returnCode2)
     1422            numberBandBsolutions++;
     1423        } else {
     1424          // no need
     1425          exitAll=true;
     1426          //returnCode=0;
     1427        }
     1428        // recompute solution value
     1429        if (returnCode&&true) {
     1430          delete newSolver;
     1431          newSolver = model_->continuousSolver()->clone();
     1432          newSolutionValue = -saveOffset;
     1433          double newSumInfeas=0.0;
     1434          const double * obj = newSolver->getObjCoefficients();
     1435          for (int i=0 ; i<numberColumns ; i++ ) {
     1436            if (newSolver->isInteger(i)) {
     1437              double value = newSolution[i];
     1438              double nearest = floor(value+0.5);
     1439              newSumInfeas += fabs(value-nearest);
     1440            }
     1441            newSolutionValue += obj[i]*newSolution[i];
     1442          }
     1443          newSolutionValue *= direction;
     1444        }
     1445        bool gotSolution = false;
     1446        if (returnCode&&newSolutionValue<saveValue) {
     1447          sprintf(pumpPrint,"Mini branch and bound improved solution from %g to %g (%.2f seconds)",
     1448                  saveValue,newSolutionValue,model_->getCurrentSeconds());
     1449          model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
     1450            << pumpPrint
     1451            <<CoinMessageEol;
     1452          memcpy(betterSolution,newSolution,numberColumns*sizeof(double));
     1453          gotSolution=true;
     1454          if (fixContinuous&&nFixC+nFixC2>0) {
     1455            // may be able to do even better
     1456            const double * lower = model_->solver()->getColLower();
     1457            const double * upper = model_->solver()->getColUpper();
     1458            for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     1459              if (newSolver->isInteger(iColumn)) {
     1460                double value=floor(newSolution[iColumn]+0.5);
     1461                newSolver->setColLower(iColumn,value);
     1462                newSolver->setColUpper(iColumn,value);
     1463              } else {
     1464                newSolver->setColLower(iColumn,lower[iColumn]);
     1465                newSolver->setColUpper(iColumn,upper[iColumn]);
     1466              }
     1467            }
     1468            newSolver->initialSolve();
     1469            if (newSolver->isProvenOptimal()) {
     1470              double value = newSolver->getObjValue()*newSolver->getObjSense();
     1471              if (value<newSolutionValue) {
     1472                //newSolver->writeMps("query","mps");
    13171473#if 0
    1318               {
    1319                 double saveOffset;
    1320                 newSolver->getDblParam(OsiObjOffset,saveOffset);
    1321                 const double * obj = newSolver->getObjCoefficients();
    1322                 double newTrueSolutionValue = -saveOffset;
    1323                 double newSumInfeas=0.0;
    1324                 int numberColumns = newSolver->getNumCols();
    1325                 const double * solution = newSolver->getColSolution();
    1326                 for (int  i=0 ; i<numberColumns ; i++ ) {
    1327                   if (newSolver->isInteger(i)) {
    1328                     double value = solution[i];
    1329                     double nearest = floor(value+0.5);
    1330                     newSumInfeas += fabs(value-nearest);
     1474                {
     1475                  double saveOffset;
     1476                  newSolver->getDblParam(OsiObjOffset,saveOffset);
     1477                  const double * obj = newSolver->getObjCoefficients();
     1478                  double newTrueSolutionValue = -saveOffset;
     1479                  double newSumInfeas=0.0;
     1480                  int numberColumns = newSolver->getNumCols();
     1481                  const double * solution = newSolver->getColSolution();
     1482                  for (int  i=0 ; i<numberColumns ; i++ ) {
     1483                    if (newSolver->isInteger(i)) {
     1484                      double value = solution[i];
     1485                      double nearest = floor(value+0.5);
     1486                      newSumInfeas += fabs(value-nearest);
     1487                    }
     1488                    if (solution[i])
     1489                      printf("%d obj %g val %g - total %g\n",i,obj[i],solution[i],
     1490                             newTrueSolutionValue);
     1491                    newTrueSolutionValue += obj[i]*solution[i];
    13311492                  }
    1332                   if (solution[i])
    1333                     printf("%d obj %g val %g - total %g\n",i,obj[i],solution[i],
    1334                            newTrueSolutionValue);
    1335                   newTrueSolutionValue += obj[i]*solution[i];
     1493                  printf("obj %g - inf %g\n",newTrueSolutionValue,
     1494                         newSumInfeas);
    13361495                }
    1337                 printf("obj %g - inf %g\n",newTrueSolutionValue,
    1338                        newSumInfeas);
    1339               }
    13401496#endif
    1341               sprintf(pumpPrint,"Freeing continuous variables gives a solution of %g", value);
    1342               model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    1343                 << pumpPrint
    1344                 <<CoinMessageEol;
    1345               newSolutionValue=value;
    1346               memcpy(betterSolution,newSolver->getColSolution(),numberColumns*sizeof(double));
    1347             }
    1348           } else {
    1349             //newSolver->writeMps("bad3.mps");
    1350             exitAll=true;
    1351             break;
    1352           }
    1353         }
    1354         if ((accumulate_&1)!=0) {
    1355           model_->incrementUsed(betterSolution); // for local search
    1356           numberSolutions++;
    1357         }
    1358         solutionValue=newSolutionValue;
    1359         solutionFound=true;
    1360         CoinWarmStartBasis * basis =
    1361           dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart()) ;
    1362         if (basis) {
    1363           bestBasis = * basis;
    1364           delete basis;
    1365           CbcEventHandler * handler = model_->getEventHandler();
    1366           if (handler) {
    1367             double * saveOldSolution = CoinCopyOfArray(model_->bestSolution(),numberColumns);
    1368             double saveObjectiveValue = model_->getMinimizationObjValue();
    1369             model_->setBestSolution(betterSolution,numberColumns,newSolutionValue);
    1370             int action = handler->event(CbcEventHandler::heuristicSolution);
    1371             //printf("cutoff %g\n",model_->getCutoff());
    1372             if (saveOldSolution&&saveObjectiveValue<model_->getMinimizationObjValue())
    1373               model_->setBestSolution(saveOldSolution,numberColumns,saveObjectiveValue);
    1374             delete [] saveOldSolution;
    1375             if (!action||model_->getCurrentSeconds()>model_->getMaximumSeconds()) {
    1376               exitAll=true; // exit
     1497                sprintf(pumpPrint,"Freeing continuous variables gives a solution of %g", value);
     1498                model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
     1499                  << pumpPrint
     1500                  <<CoinMessageEol;
     1501                newSolutionValue=value;
     1502                memcpy(betterSolution,newSolver->getColSolution(),numberColumns*sizeof(double));
     1503              }
     1504            } else {
     1505              //newSolver->writeMps("bad3.mps");
     1506              exitAll=true;
    13771507              break;
    13781508            }
    1379           }
    1380         }
    1381       } else {
    1382         sprintf(pumpPrint,"Mini branch and bound did not improve solution (%.2f seconds)",
    1383                 model_->getCurrentSeconds());
    1384         model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
    1385           << pumpPrint
    1386           <<CoinMessageEol;
    1387       }
     1509          }
     1510        } else {
     1511          sprintf(pumpPrint,"Mini branch and bound did not improve solution (%.2f seconds)",
     1512                  model_->getCurrentSeconds());
     1513          model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
     1514            << pumpPrint
     1515            <<CoinMessageEol;
     1516          if (returnCode&&newSolutionValue<saveValue+1.0e-3&&nFixC+nFixC2) {
     1517            // may be able to do better
     1518            const double * lower = model_->solver()->getColLower();
     1519            const double * upper = model_->solver()->getColUpper();
     1520            for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     1521              if (newSolver->isInteger(iColumn)) {
     1522                double value=floor(newSolution[iColumn]+0.5);
     1523                newSolver->setColLower(iColumn,value);
     1524                newSolver->setColUpper(iColumn,value);
     1525              } else {
     1526                newSolver->setColLower(iColumn,lower[iColumn]);
     1527                newSolver->setColUpper(iColumn,upper[iColumn]);
     1528              }
     1529            }
     1530            newSolver->initialSolve();
     1531            if (newSolver->isProvenOptimal()) {
     1532              double value = newSolver->getObjValue()*newSolver->getObjSense();
     1533              if (value<saveValue) {
     1534                sprintf(pumpPrint,"Freeing continuous variables gives a solution of %g", value);
     1535                model_->messageHandler()->message(CBC_FPUMP1,model_->messages())
     1536                  << pumpPrint
     1537                  <<CoinMessageEol;
     1538                newSolutionValue=value;
     1539                memcpy(betterSolution,newSolver->getColSolution(),numberColumns*sizeof(double));
     1540                gotSolution=true;
     1541              }
     1542            }
     1543          }
     1544        }
     1545        if (gotSolution) {
     1546          if ((accumulate_&1)!=0) {
     1547            model_->incrementUsed(betterSolution); // for local search
     1548            numberSolutions++;
     1549          }
     1550          solutionValue=newSolutionValue;
     1551          solutionFound=true;
     1552          CoinWarmStartBasis * basis =
     1553            dynamic_cast<CoinWarmStartBasis *>(newSolver->getWarmStart()) ;
     1554          if (basis) {
     1555            bestBasis = * basis;
     1556            delete basis;
     1557            CbcEventHandler * handler = model_->getEventHandler();
     1558            if (handler) {
     1559              double * saveOldSolution = CoinCopyOfArray(model_->bestSolution(),numberColumns);
     1560              double saveObjectiveValue = model_->getMinimizationObjValue();
     1561              model_->setBestSolution(betterSolution,numberColumns,newSolutionValue);
     1562              int action = handler->event(CbcEventHandler::heuristicSolution);
     1563              //printf("cutoff %g\n",model_->getCutoff());
     1564              if (saveOldSolution&&saveObjectiveValue<model_->getMinimizationObjValue())
     1565                model_->setBestSolution(saveOldSolution,numberColumns,saveObjectiveValue);
     1566              delete [] saveOldSolution;
     1567              if (!action||model_->getCurrentSeconds()>model_->getMaximumSeconds()) {
     1568                exitAll=true; // exit
     1569                break;
     1570              }
     1571            }
     1572          }
     1573        }
     1574      } // end stopBAB while
    13881575      delete newSolver;
    13891576    }
     
    13981585        cutoff -= CoinMax(CoinMax(gap,absoluteIncrement_),model_->getCutoffIncrement());
    13991586      } else {
    1400         double weights[10]={0.1,0.1,0.2,0.2,0.2,0.3,0.3,0.3,0.4,0.5};
     1587        //double weights[10]={0.1,0.1,0.2,0.2,0.2,0.3,0.3,0.3,0.4,0.5};
     1588        double weights[10]={0.1,0.2,0.3,0.3,0.4,0.4,0.4,0.5,0.5,0.6};
    14011589        cutoff -= weights[CoinMin(numberTries-1,9)]*(cutoff-continuousObjectiveValue);
    14021590      }
     
    14111599        << pumpPrint
    14121600        <<CoinMessageEol;
    1413       if ((accumulate_&3)<2&&usedColumn)
    1414         memset(usedColumn,0,numberColumns);
     1601      if ((accumulate_&3)<2&&usedColumn) {
     1602        for (int i=0;i<numberColumns;i++)
     1603          usedColumn[i]=-1;
     1604      }
    14151605      totalNumberPasses += numberPasses-1;
    14161606    }
     
    15121702                          const double * objective,
    15131703                          int numberIntegers, const int * integerVariable,
    1514                           char * pumpPrint, int & iter,
     1704                          char * pumpPrint, int iter,
    15151705                          bool roundExpensive, double downValue, int *flip)
    15161706{
     
    15341724  const double * rowUpper = solver->getRowUpper();
    15351725  int numberRows = solver->getNumRows();
    1536 #if 1
    1537   // Do set covering variables
    1538   const CoinPackedMatrix * matrixByRow = solver->getMatrixByRow();
    1539   const double * elementByRow = matrixByRow->getElements();
    1540   const int * column = matrixByRow->getIndices();
    1541   const CoinBigIndex * rowStart = matrixByRow->getVectorStarts();
    1542   const int * rowLength = matrixByRow->getVectorLengths();
    1543   for (i=0;i<numberRows;i++) {
    1544     if (rowLower[i]==1.0&&rowUpper[i]==1.0) {
    1545       bool cover=true;
    1546       double largest=0.0;
    1547       int jColumn=-1;
    1548       for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
    1549         int iColumn = column[k];
    1550         if (elementByRow[k]!=1.0||!solver->isInteger(iColumn)) {
    1551           cover=false;
    1552           break;
    1553         } else {
    1554           if (solution[iColumn]) {
    1555             double value = solution[iColumn]*
    1556               (randomNumberGenerator_.randomDouble()+5.0);
    1557             if (value>largest) {
    1558               largest=value;
    1559               jColumn=iColumn;
    1560             }
    1561           }
    1562         }
    1563       }
    1564       if (cover) {
     1726  if ((iter&1)!=0) {
     1727    // Do set covering variables
     1728    const CoinPackedMatrix * matrixByRow = solver->getMatrixByRow();
     1729    const double * elementByRow = matrixByRow->getElements();
     1730    const int * column = matrixByRow->getIndices();
     1731    const CoinBigIndex * rowStart = matrixByRow->getVectorStarts();
     1732    const int * rowLength = matrixByRow->getVectorLengths();
     1733    for (i=0;i<numberRows;i++) {
     1734      if (rowLower[i]==1.0&&rowUpper[i]==1.0) {
     1735        bool cover=true;
     1736        double largest=0.0;
     1737        int jColumn=-1;
    15651738        for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
    15661739          int iColumn = column[k];
    1567           double value=solution[iColumn];
    1568           if (iColumn==jColumn)
    1569             solution[iColumn]=1.0;
    1570            else
    1571             solution[iColumn]=0.0;
    1572 #if 0
    1573           if (value!=solution[iColumn])
    1574             printf("%d sol changed from %g to %g\n",iColumn,value,solution[iColumn]);
    1575           if (value>0.5&&solution[iColumn]<0.5)
    1576             printf("why!\n");
    1577 #endif
     1740          if (elementByRow[k]!=1.0||!solver->isInteger(iColumn)) {
     1741            cover=false;
     1742            break;
     1743          } else {
     1744            if (solution[iColumn]) {
     1745              double value = solution[iColumn]*
     1746                (randomNumberGenerator_.randomDouble()+5.0);
     1747              if (value>largest) {
     1748                largest=value;
     1749                jColumn=iColumn;
     1750              }
     1751            }
     1752          }
     1753        }
     1754        if (cover) {
     1755          for (CoinBigIndex k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1756            int iColumn = column[k];
     1757            if (iColumn==jColumn)
     1758              solution[iColumn]=1.0;
     1759            else
     1760              solution[iColumn]=0.0;
     1761          }
    15781762        }
    15791763      }
    15801764    }
    15811765  }
    1582 #endif
    15831766#if 0
    15841767  // Do set covering variables
     
    16791862  const double * columnLower = solver->getColLower();
    16801863  const double * columnUpper = solver->getColUpper();
     1864  // Check if valid with current solution (allow for 0.99999999s)
     1865  for (i=0;i<numberIntegers;i++) {
     1866    int iColumn = integerVariable[i];
     1867    double value=solution[iColumn];
     1868    double round = floor(value+0.5);
     1869    if (fabs(value-round)>primalTolerance)
     1870      break;
     1871  }
     1872  if (i==numberIntegers) {
     1873    // may be able to use solution even if 0.99999's
     1874    // get row activities
     1875    double * rowActivity = new double[numberRows];
     1876    memset(rowActivity,0,numberRows*sizeof(double));
     1877    solver->getMatrixByCol()->times(solution,rowActivity) ;
     1878    double largestInfeasibility =0.0;
     1879    for (i=0 ; i < numberRows ; i++) {
     1880      largestInfeasibility = max(largestInfeasibility,
     1881                                 rowLower[i]-rowActivity[i]);
     1882      largestInfeasibility = max(largestInfeasibility,
     1883                                 rowActivity[i]-rowUpper[i]);
     1884    }
     1885    delete [] rowActivity;
     1886    if (largestInfeasibility<=primalTolerance) {
     1887      // feasible
     1888      delete [] list;
     1889      delete [] val;
     1890      return 1;
     1891    }
     1892  }
     1893     
    16811894  // return rounded solution
    16821895  for (i=0;i<numberIntegers;i++) {
  • trunk/Cbc/src/CbcHeuristicFPump.hpp

    r931 r1053  
    199199  int rounds(OsiSolverInterface * solver,double * solution, const double * objective,
    200200             int numberIntegers, const int * integerVariable,
    201              char * pumpPrint,int & passNumber,
     201             char * pumpPrint,int passNumber,
    202202             bool roundExpensive=false,
    203203             double downValue=0.5, int *flip=0);
  • trunk/Cbc/src/CbcModel.cpp

    r1039 r1053  
    1616#define MODEL11 0
    1717#define MODEL12 1
     18#define MODEL13 1
    1819
    1920#include "CbcConfig.h"
     
    12481249  continuous relaxation.
    12491250*/
     1251  /* Tell solver we are in Branch and Cut
     1252     Could use last parameter for subtle differences */
     1253  solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
     1254#ifdef COIN_HAS_CLP
     1255  {
     1256    OsiClpSolverInterface * clpSolver
     1257      = dynamic_cast<OsiClpSolverInterface *> (solver_);
     1258    if (clpSolver) {
     1259      //#define CLP_QUICK_OPTIONS
     1260#ifdef CLP_QUICK_OPTIONS
     1261      // Try and re-use regions   
     1262      ClpSimplex * simplex = clpSolver->getModelPtr();
     1263      simplex->setPersistenceFlag(1);
     1264#if 0
     1265      clpSolver->deleteScaleFactors();
     1266      int value=131072;
     1267      clpSolver->setSpecialOptions(clpSolver->specialOptions()|value);
     1268      if ((clpSolver->specialOptions()&value)!=0)
     1269        simplex->setSpecialOptions(simplex->specialOptions()|value);
     1270#else
     1271#undef CLP_QUICK_OPTIONS
     1272      //if (simplex->numberRows()<50)
     1273      //simplex->setAlphaAccuracy(1.0);
     1274      //clpSolver->setSpecialOptions((clpSolver->specialOptions()&~128)|65536);
     1275      //simplex->setMoreSpecialOptions(simplex->moreSpecialOptions()|4);
     1276      //simplex->setSpecialOptions(simplex->specialOptions()|65536);
     1277      //simplex->startPermanentArrays();
     1278#endif
     1279#endif
     1280      ClpSimplex * clpSimplex = clpSolver->getModelPtr();
     1281      if ((specialOptions_&32)==0) {
     1282        // take off names
     1283        clpSimplex->dropNames();
     1284      }
     1285      // no crunch if mostly continuous
     1286      //int numberColumns = solver_->getNumCols()+1000000; // fake for testing
     1287      int numberColumns = solver_->getNumCols();
     1288      if (numberColumns>1000&&numberIntegers_*4<numberColumns)
     1289        clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~1));
     1290      //#define NO_CRUNCH
     1291#ifdef NO_CRUNCH
     1292      printf("TEMP switching off crunch\n");
     1293      clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~1));
     1294#endif
     1295    }
     1296  }
     1297#endif
    12501298  bool feasible;
    12511299  // If NLP then we assume already solved outside branchAndbound
     
    14511499    currentSolution_ = new double[numberColumns] ;
    14521500  testSolution_ = currentSolution_;
    1453   /* Tell solver we are in Branch and Cut
    1454      Could use last parameter for subtle differences */
    1455   solver_->setHintParam(OsiDoInBranchAndCut,true,OsiHintDo,NULL) ;
    1456 #ifdef COIN_HAS_CLP
    1457  {
    1458    OsiClpSolverInterface * clpSolver
    1459      = dynamic_cast<OsiClpSolverInterface *> (solver_);
    1460    if (clpSolver) {
    1461      //#define CLP_QUICK_OPTIONS
    1462 #ifdef CLP_QUICK_OPTIONS
    1463      // Try and re-use regions   
    1464      ClpSimplex * simplex = clpSolver->getModelPtr();
    1465      simplex->setPersistenceFlag(1);
    1466 #if 0
    1467      clpSolver->deleteScaleFactors();
    1468      int value=131072;
    1469      clpSolver->setSpecialOptions(clpSolver->specialOptions()|value);
    1470      if ((clpSolver->specialOptions()&value)!=0)
    1471        simplex->setSpecialOptions(simplex->specialOptions()|value);
    1472 #else
    1473 #undef CLP_QUICK_OPTIONS
    1474      //if (simplex->numberRows()<50)
    1475      //simplex->setAlphaAccuracy(1.0);
    1476      //clpSolver->setSpecialOptions((clpSolver->specialOptions()&~128)|65536);
    1477      //simplex->setMoreSpecialOptions(simplex->moreSpecialOptions()|4);
    1478      //simplex->setSpecialOptions(simplex->specialOptions()|65536);
    1479      //simplex->startPermanentArrays();
    1480 #endif
    1481 #endif
    1482      ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    1483      if ((specialOptions_&32)==0) {
    1484        // take off names
    1485        clpSimplex->dropNames();
    1486      }
    1487      // no crunch if mostly continuous
    1488      //int numberColumns = solver_->getNumCols()+1000000; // fake for testing
    1489      int numberColumns = solver_->getNumCols();
    1490      if (numberColumns>1000&&numberIntegers_*4<numberColumns)
    1491        clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~1));
    1492      //#define NO_CRUNCH
    1493 #ifdef NO_CRUNCH
    1494      printf("TEMP switching off crunch\n");
    1495      clpSolver->setSpecialOptions(clpSolver->specialOptions()&(~1));
    1496 #endif
    1497    }
    1498  }
    1499 #endif
    15001501/*
    15011502  Create a copy of the solver, thus capturing the original (root node)
     
    17981799                                                   objectiveValue,
    17991800                                                   cutoff,"Reduce");
    1800      if (returnCode==-1) {
     1801     if (returnCode<0) {
    18011802#ifdef COIN_DEVELOP
    18021803       printf("Restart - not small enough to do search after fixing\n");
     
    18041805       delete [] newSolution;
    18051806     } else {
    1806        assert (returnCode>=0);
    18071807       if ((returnCode&1)!=0) {
    18081808         // increment number of solutions so other heuristics can test
     
    20312031#endif
    20322032          CglImplication implication(probingInfo_);
    2033           addCutGenerator(&implication,1,"implication",true,false,false,-200);
     2033          addCutGenerator(&implication,1,"ImplicationCuts",true,false,false,-200);
    20342034        } else {
    20352035          delete probingInfo_;
     
    26112611                                                      objectiveValue,
    26122612                                                      cutoff,"Reduce");
    2613         if (returnCode==-1) {
     2613        if (returnCode<0) {
    26142614#ifdef COIN_DEVELOP
    26152615          printf("Restart - not small enough to do search after fixing\n");
     
    26172617          delete [] newSolution;
    26182618        } else {
    2619           assert (returnCode>=0);
    26202619          if ((returnCode&1)!=0) {
    26212620            // increment number of solutions so other heuristics can test
     
    26262625          }
    26272626          delete [] newSolution;
     2627          if (tree_->size()) {
     2628            double dummyBest;
     2629            tree_->cleanTree(this,-COIN_DBL_MAX,dummyBest) ;
     2630          }
    26282631          break;
    26292632        }
     
    33623365          threadCount[iThread]++;
    33633366        }
    3364 #ifndef CBC_DETERMINISTIC_THREAD
    33653367        lockThread();
    3366 #endif
    33673368        locked=true;
    33683369        // see if any finished
     
    33713372            break;
    33723373        }
    3373 #ifndef CBC_DETERMINISTIC_THREAD
    33743374        unlockThread();
    3375 #endif
    33763375        locked=false;
    33773376        if (iThread<numberThreads_) {
     
    33893388          }
    33903389          if (iThread<numberThreads_) {
    3391 #ifndef CBC_DETERMINISTIC_THREAD
    33923390            lockThread();
    3393 #endif
    33943391            locked=true;
    33953392            // If any on tree get
     
    34003397              continue; // ** get another node
    34013398            }
    3402 #ifndef CBC_DETERMINISTIC_THREAD
    34033399            unlockThread();
    3404 #endif
    34053400            locked=false;
    34063401          }
     
    37633758    for (i=0;i<numberObjects_;i++)
    37643759      lookup[i]=-1;
    3765     bool goodIds=true;
     3760    bool goodIds=false; //true;
    37663761    for (i=0;i<numberObjects_;i++) {
    37673762      int iColumn = object_[i]->columnNumber();
     
    57265721  bool sameProblem=false;
    57275722#ifdef NODE_LAST
    5728   {
     5723  if (numberThreads_<=0) {
    57295724    {
    57305725      int n1=numberRowsAtContinuous_;
     
    60876082          nDiff += nDiff2;
    60886083        }
    6089 #ifdef COIN_DEVELOP
     6084#ifdef COIN_DEVELOP_z
    60906085        printf("add now %d add last %d - same %d, diff %d %s\n",
    60916086             numberToAdd,lastNumberCuts2_,nSame,nDiff,
     
    64356430  }
    64366431#endif
     6432#if MODEL13
     6433#define CUT_HISTORY 7
     6434  double cut_obj[CUT_HISTORY];
     6435  for (int j=0;j<CUT_HISTORY;j++)
     6436         cut_obj[j]=-COIN_DBL_MAX;
     6437#endif
    64376438# ifdef COIN_HAS_CLP
    64386439  OsiClpSolverInterface * clpSolver
     
    65256526#endif
    65266527  double lastObjective = solver_->getObjValue()*solver_->getObjSense();
     6528#if MODEL13
     6529  cut_obj[CUT_HISTORY-1]=lastObjective;
     6530#endif
    65276531  //double firstObjective = lastObjective+1.0e-8+1.0e-12*fabs(lastObjective);
    65286532  if (node&&node->nodeInfo()&&!node->nodeInfo()->numberBranchesLeft())
     
    67036707*/
    67046708  double minimumDrop = minimumDrop_ ;
     6709  bool allowZeroIterations = false;
     6710#if MODEL13==0
    67056711  if (numberTries<0)
    67066712  { numberTries = -numberTries ;
     6713    if (numberTries>100)
     6714      allowZeroIterations=true;
    67076715    minimumDrop = -1.0 ; }
     6716#else
     6717  if (numberTries<0) {
     6718    numberTries = -numberTries ;
     6719    minimumDrop *= 1.0e-5 ;
     6720    if (numberTries>=-1000000) {
     6721      //numberTries=100;
     6722      minimumDrop=-1.0;
     6723    }
     6724    numberTries=CoinMax(numberTries,100);
     6725    allowZeroIterations=true;
     6726  }
     6727#endif
    67086728/*
    67096729  Is it time to scan the cuts in order to remove redundant cuts? If so, set
     
    68746894#endif
    68756895        if (!doCutsNow(1)&&!fullScan) {
    6876           //if (node)
    6877           //assert (node->depth()+1==currentDepth_);
    6878           //if (node&&node->depth()>10&&(node->depth()&1)==whenCuts&&!fullScan) {
    68796896          // switch off if default
    68806897#if MODEL6
     
    75797596        numberRowsAtStart = numberOldActiveCuts_+numberRowsAtContinuous_ ;
    75807597        lastNumberCuts = numberNewCuts_ ;
    7581         if (direction*solver_->getObjValue() < lastObjective+minimumDrop &&
    7582             currentPassNumber_ >= 10
     7598        double thisObj = direction*solver_->getObjValue();
     7599#if MODEL13
     7600        bool badObj = (allowZeroIterations) ? thisObj < cut_obj[0]+minimumDrop
     7601          : thisObj < cut_obj[CUT_HISTORY-1]+minimumDrop;;
     7602        if (numberTries==1&&currentDepth_&&currentPassNumber_<10) {
     7603          if (thisObj-lastObjective>10.0*minimumDrop) {
     7604            numberTries++;
     7605#ifdef CLP_INVESTIGATE
     7606            //printf("drop %g %g %d\n",thisObj,lastObjective,currentPassNumber_);
     7607#endif
     7608          }
     7609        }
     7610        for (int j=0;j<CUT_HISTORY-1;j++)
     7611          cut_obj[j] = cut_obj[j+1];
     7612        cut_obj[CUT_HISTORY-1]=thisObj;
     7613#else
     7614        bool badObj = thisObj < lastObjective+minimumDrop;
     7615#endif
     7616        bool allowEarlyTermination = currentPassNumber_ >= 10;
     7617        if (currentDepth_>10||(currentDepth_>5&&numberColumns>200))
     7618          allowEarlyTermination=true;
     7619        //if (badObj && (currentPassNumber_ >= 10 || (currentDepth_>10))
     7620        if (badObj && allowEarlyTermination
    75837621            //&&(currentPassNumber_>=10||lastObjective>firstObjective)
    75847622            && !keepGoing)
    75857623          { numberTries = 0 ; }
    7586         if (numberRowCuts+numberColumnCuts == 0 || cutIterations == 0)
     7624        if (numberRowCuts+numberColumnCuts == 0 ||
     7625            (cutIterations == 0 && !allowZeroIterations) )
    75877626          { break ; }
    75887627        if (numberTries > 0) {
     
    79417980        <<currentPassNumber_
    79427981        <<CoinMessageEol ;
     7982    if (!numberNodes_) {
     7983      double value = CoinMax(minimumDrop_,0.005*(thisObjective-startObjective)/
     7984                             ((double) currentPassNumber_));
     7985      if (numberColumns<200)
     7986        value = CoinMax(minimumDrop_,0.1*value);
     7987#ifdef CLP_INVESTIGATE
     7988      printf("Minimum drop for cuts was %g, now is %g\n",minimumDrop_,value);
     7989#endif
     7990      minimumDrop_=value;
     7991    }
    79437992    int * count = new int[numberCutGenerators_] ;
    79447993    memset(count,0,numberCutGenerators_*sizeof(int)) ;
     
    1501615065  int size = continuousSolver_->getNumRows()+continuousSolver_->getNumCols();
    1501715066
    15018   if (whenCuts_<0||size<=500) {
     15067  if (whenCuts_<0||(size<=500&&allowForTopOfTree!=3)) {
    1501915068    int whenCuts = (size<=500) ? -1 :1;
    1502015069    if (parentModel_)
  • trunk/Cbc/src/CbcModel.hpp

    r1015 r1053  
    19651965  */
    19661966  CbcNodeInfo ** walkback_;
    1967   //#define NODE_LAST
     1967#ifndef CBC_DETERMINISTIC_THREAD
     1968#define NODE_LAST
     1969#endif
    19681970#ifdef NODE_LAST
    19691971  CbcNodeInfo ** lastNodeInfo_;
  • trunk/Cbc/src/CbcNode.cpp

    r1038 r1053  
    14871487                */
    14881488                if (fabs(value-targetValue)>integerTolerance) {
    1489                   infeasibility = 1.0-fabs(value-targetValue);
    1490                   if (targetValue==1.0)
    1491                     infeasibility += 1.0;
     1489                  infeasibility = fabs(value-targetValue);
     1490                  //if (targetValue==1.0)
     1491                  //infeasibility += 1.0;
    14921492                  if (value>targetValue) {
    14931493                    preferredWay=-1;
     
    25412541  OsiSolverInterface *osiclp = 0 ;
    25422542# endif
    2543   const CglTreeProbingInfo * probingInfo = model->probingInfo();
     2543  const CglTreeProbingInfo * probingInfo = NULL; //model->probingInfo();
    25442544  int saveSearchStrategy2 = model->searchStrategy();
    25452545#define NODE_NEW  2
     
    27062706      iBestGot=-1;
    27072707      best=0.0;
     2708      //#define CBC_NODE7 3
     2709#if CBC_NODE7>1
     2710      double * activeWeight = NULL;
     2711      if (usefulInfo.columnLength_) {
     2712        double tolerance=1.0e-6;
     2713        int numberRows = solver->getNumRows();
     2714        activeWeight = new double [numberRows];
     2715        for (int iRow = 0;iRow<numberRows;iRow++) {
     2716          // could use pi to see if active or activity
     2717#if 1
     2718          if (usefulInfo.rowActivity_[iRow]>usefulInfo.rowUpper_[iRow]-tolerance
     2719              ||usefulInfo.rowActivity_[iRow]<usefulInfo.rowLower_[iRow]+tolerance) {
     2720            activeWeight[iRow]=0.0;
     2721          } else {
     2722            activeWeight[iRow]=-1.0;
     2723          }
     2724#else
     2725          if (fabs(usefulInfo.pi_[iRow])>1.0e-6) {
     2726            activeWeight[iRow]=0.0;
     2727          } else {
     2728            activeWeight[iRow]=-1.0;
     2729          }
     2730#endif
     2731        }
     2732        for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     2733          if (solver->isInteger(iColumn)) {
     2734            double value = usefulInfo.solution_[iColumn];
     2735            if (fabs(value-floor(value+0.5))>1.0e-6) {
     2736              CoinBigIndex start = usefulInfo.columnStart_[iColumn];
     2737              CoinBigIndex end = start + usefulInfo.columnLength_[iColumn];
     2738              for (CoinBigIndex j=start;j<end;j++) {
     2739                int iRow = usefulInfo.row_[j];
     2740                if (activeWeight[iRow]>=0.0)
     2741                  activeWeight[iRow] += 1.0;
     2742              }
     2743            }
     2744          }
     2745        }
     2746        for (int iRow = 0;iRow<numberRows;iRow++) {
     2747          if (activeWeight[iRow]>0.0) {
     2748            // could use pi
     2749            activeWeight[iRow] = 1.0/activeWeight[iRow];
     2750#if 0
     2751            activeWeight[iRow] *= fabs(usefulInfo.pi_[iRow]);
     2752#endif
     2753          }
     2754        }
     2755      }
     2756#endif
    27082757      /* Problem type as set by user or found by analysis.  This will be extended
    27092758         0 - not known
     
    27482797            }
    27492798            iColumn = dynamicObject->columnNumber();
     2799            gotDown=false;
     2800            numberThisDown = dynamicObject->numberTimesDown();
     2801            if (numberThisDown>=numberBeforeTrust)
     2802              gotDown=true;
     2803            gotUp=false;
     2804            numberThisUp = dynamicObject->numberTimesUp();
     2805            if (numberThisUp>=numberBeforeTrust)
     2806              gotUp=true;
     2807#ifdef CBC_NODE7
     2808            if (usefulInfo.columnLength_&&iColumn>=0&&iColumn<numberColumns) {
     2809              CoinBigIndex start = usefulInfo.columnStart_[iColumn];
     2810              CoinBigIndex end = start + usefulInfo.columnLength_[iColumn];
     2811              double upValue = 0.0;
     2812              double downValue = 0.0;
     2813#if CBC_NODE7==1||CBC_NODE7==3
     2814              double value = usefulInfo.direction_*usefulInfo.objective_[iColumn];
     2815              // Bias cost
     2816              if (value>0.0)
     2817                upValue += 1.5*value;
     2818              else
     2819                downValue -= 1.5*value;
     2820              for (CoinBigIndex j=start;j<end;j++) {
     2821                int iRow = usefulInfo.row_[j];
     2822                value = -usefulInfo.pi_[iRow];
     2823                if (value) {
     2824                  value *= usefulInfo.elementByColumn_[j];
     2825#if CBC_NODE7==3
     2826                  value *= activeWeight[iRow];
     2827#endif
     2828                  if (value>0.0)
     2829                    upValue += value;
     2830                  else
     2831                    downValue -= value;
     2832                }
     2833              }
     2834              value = usefulInfo.solution_[iColumn];
     2835              value -= floor(value);
     2836              downValue *= value;
     2837              upValue *= (1.0-value);
     2838#if 0
     2839              printf("%d inf %g ord %g %g shadow %g %g\n",
     2840                     iColumn,infeasibility,
     2841                     object->downEstimate(),object->upEstimate(),
     2842                     downValue,upValue);
     2843#endif
     2844              //if (!numberThisDown||!numberThisUp)
     2845              //if (!gotDown||!gotUp)
     2846#if 0
     2847              infeasibility = CoinMax(CoinMax(downValue,upValue),infeasibility);
     2848#else
     2849              infeasibility = CoinMax(downValue,upValue);
     2850#endif
     2851#elif CBC_NODE7==2
     2852              double value=0.0;
     2853              for (CoinBigIndex j=start;j<end;j++) {
     2854                int iRow = usefulInfo.row_[j];
     2855                if (activeWeight[iRow])
     2856                  value += fabs(usefulInfo.elementByColumn_[j])*activeWeight[iRow];
     2857              }
     2858              double solValue = usefulInfo.solution_[iColumn];
     2859              solValue -= floor(solValue);
     2860              downValue = value*solValue;
     2861              upValue = value*(1.0-solValue);
     2862#if 0
     2863              printf("%d inf %g ord %g %g shadow %g %g\n",
     2864                     iColumn,infeasibility,
     2865                     object->downEstimate(),object->upEstimate(),
     2866                     downValue,upValue);
     2867#endif
     2868              //if (!numberThisDown||!numberThisUp)
     2869              //if (!gotDown||!gotUp)
     2870              infeasibility = CoinMax(CoinMax(downValue,upValue),infeasibility);
     2871              infeasibility = CoinMax(downValue,upValue);
     2872              infeasibility = value;
     2873#endif
     2874            }
     2875#endif
    27502876            //double gap = saveUpper[iColumn]-saveLower[iColumn];
    27512877            // Give precedence to ones with gap of 1.0
     
    27732899              }
    27742900            }
    2775             gotDown=false;
    2776             numberThisDown = dynamicObject->numberTimesDown();
    2777             if (numberThisDown>=numberBeforeTrust)
    2778               gotDown=true;
    2779             gotUp=false;
    2780             numberThisUp = dynamicObject->numberTimesUp();
    2781             if (numberThisUp>=numberBeforeTrust)
    2782               gotUp=true;
    27832901            if ((numberNodes%PRINT_STUFF)==0&&PRINT_STUFF>0)
    27842902              printf("%d down %d %g up %d %g - infeas %g\n",
     
    28562974        }
    28572975      }
     2976#if CBC_NODE7>1
     2977      delete [] activeWeight;
     2978#endif
    28582979      if (numberUnsatisfied_) {
    28592980        if (probingInfo&&false)
     
    41744295    if (((numberUnfinished*4>numberStrongDone&&
    41754296         numberStrongInfeasible*40<numberStrongDone)||
    4176          numberStrongInfeasible<0)&&model->numberStrong()<10&&model->numberBeforeTrust()<20) {
     4297         numberStrongInfeasible<0)&&model->numberStrong()<10&&model->numberBeforeTrust()<20&&model->numberObjects()>1000) {
    41774298      strategy=2;
    41784299#ifdef COIN_DEVELOP
  • trunk/Cbc/src/CbcSolver.cpp

    r1052 r1053  
    1616#include "CoinHelperFunctions.hpp"
    1717// Version
    18 #define CBCVERSION "2.20.00"
     18#define CBCVERSION "2.30.00"
    1919
    2020#include "CoinMpsIO.hpp"
     
    5858static int malloc_n=10;
    5959double malloc_counts[10]={0,0,0,0,0,0,0,0,0,0};
    60 bool malloc_counts_on=false;
     60bool malloc_counts_on=true;
    6161void * operator new (size_t size) throw (std::bad_alloc)
    6262{
     
    12051205static OsiClpSolverInterface * fixVubs(CbcModel & model, int skipZero2,
    12061206                                       int & doAction, CoinMessageHandler * generalMessageHandler,
    1207                                        const double * lastSolution, double dextra[5])
     1207                                       const double * lastSolution, double dextra[6],
     1208                                       int extra[5])
    12081209{
    12091210  if (doAction==11&&!lastSolution)
    12101211    lastSolution = model.bestSolution();
    1211   assert (((doAction>=1&&doAction<=3)&&!lastSolution)||(doAction==11&&lastSolution));
     1212  assert (((doAction>=0&&doAction<=3)&&!lastSolution)||(doAction==11&&lastSolution));
    12121213  double fractionIntFixed = dextra[3];
    12131214  double fractionFixed = dextra[4];
    12141215  double fixAbove = dextra[2];
     1216  double fixAboveValue = (dextra[5]>0.0) ? dextra[5] : 1.0;
    12151217  double time1 = CoinCpuTime();
     1218  int leaveIntFree = extra[1];
    12161219  OsiSolverInterface * originalSolver = model.solver();
    12171220  OsiClpSolverInterface * originalClpSolver = dynamic_cast< OsiClpSolverInterface*> (originalSolver);
     
    19331936      }
    19341937      printf("This fixes %d variables in lower priorities\n",nTotalFixed);
    1935       if (iLargest<0)
     1938      if (iLargest<0||numberFree<=leaveIntFree)
    19361939        break;
    19371940      double movement;
    19381941      int way;
    1939       if (smallest<=1.0-largest&&smallest<0.2) {
     1942      if (smallest<=1.0-largest&&smallest<0.2&&largest<fixAboveValue) {
    19401943        columnUpper[iSmallest]=0.0;
    19411944        state[iSmallest]=0;
     
    19711974      double moveObj = lpSolver->objectiveValue()-saveObj;
    19721975      printf("movement %s was %g costing %g\n",
    1973              (smallest<=1.0-largest) ? "down" : "up",movement,moveObj);
     1976             (way==-1) ? "down" : "up",movement,moveObj);
    19741977      if (way==-1&&(moveObj>=(1.0-movement)*objective[iSmallest]||lpSolver->status())) {
    19751978        // go up
     
    32593262        >=1000000 use as accumulate switch
    32603263        >=1000 use index+1 as number of large loops
    3261         >=100 use 0.05 objvalue as increment
    3262         >=10 use +0.1 objvalue for cutoff (add)
     3264        >=100 use dextra1 as cutoff
     3265        %100 == 10,20 etc for experimentation
    32633266        1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds
    32643267        4 and static continuous, 5 as 3 but no internal integers
     
    32673270      double value = model->solver()->getObjSense()*model->solver()->getObjValue();
    32683271      int w = pumpTune/10;
     3272      int i = w % 10;
     3273      w /= 10;
    32693274      int c = w % 10;
    3270       w /= 10;
    3271       int i = w % 10;
    32723275      w /= 10;
    32733276      int r = w;
     
    32983301          printf("fake cutoff of %g ",cutoff);
    32993302      }
    3300       if (i||r) {
     3303      if (r) {
    33013304        // also set increment
    33023305        //double increment = (0.01*i+0.005)*(fabs(value)+1.0e-12);
     
    33093312        heuristic4.setMaximumRetries(r+1);
    33103313        if (logLevel>1) {
    3311           if (i)
    3312             printf("increment of %g ",heuristic4.absoluteIncrement());
     3314          printf("increment of %g ",heuristic4.absoluteIncrement());
    33133315          if (accumulate)
    33143316            printf("accumulate of %d ",accumulate);
     
    33163318        }
    33173319      }
     3320      if (i) {
     3321        heuristic4.setFeasibilityPumpOptions(i*10);
     3322      }
    33183323      pumpTune = pumpTune%100;
    33193324      if (logLevel>1)
     
    33213326      if (pumpTune==6)
    33223327        pumpTune =13;
    3323       heuristic4.setWhen(pumpTune+10);
     3328      heuristic4.setWhen((pumpTune%10)+10);
    33243329    }
    33253330    heuristic4.setHeuristicName("feasibility pump");
     
    33753380    CbcHeuristicRINS heuristic5(*model);
    33763381    heuristic5.setHeuristicName("RINS");
    3377     heuristic5.setFractionSmall(0.5);
    3378     if (useRINS==1)
     3382    if (useRINS==1) {
     3383      heuristic5.setFractionSmall(0.5);
    33793384      heuristic5.setDecayFactor(5.0);
    3380     else
     3385    } else {
     3386      heuristic5.setFractionSmall(0.6);
    33813387      heuristic5.setDecayFactor(1.5);
     3388    }
    33823389    model->addHeuristic(&heuristic5) ;
    33833390    anyToDo=true;
     
    33973404  int useDIVING=0;
    33983405  {
    3399     useDIVING |= 1*parameters_[whichParam(DIVINGV,numberParameters_,parameters_)].currentOptionAsInteger();
    3400     useDIVING |= 2*parameters_[whichParam(DIVINGG,numberParameters_,parameters_)].currentOptionAsInteger();
    3401     useDIVING |= 4*parameters_[whichParam(DIVINGF,numberParameters_,parameters_)].currentOptionAsInteger();
    3402     useDIVING |= 8*parameters_[whichParam(DIVINGC,numberParameters_,parameters_)].currentOptionAsInteger();
    3403     useDIVING |= 16*parameters_[whichParam(DIVINGL,numberParameters_,parameters_)].currentOptionAsInteger();
    3404     useDIVING |= 32*parameters_[whichParam(DIVINGP,numberParameters_,parameters_)].currentOptionAsInteger();
     3406    useDIVING |= 1*((parameters_[whichParam(DIVINGV,numberParameters_,parameters_)].currentOptionAsInteger()>=kType) ? 1 : 0);
     3407    useDIVING |= 2*((parameters_[whichParam(DIVINGG,numberParameters_,parameters_)].currentOptionAsInteger()>=kType) ? 1 : 0);
     3408    useDIVING |= 4*((parameters_[whichParam(DIVINGF,numberParameters_,parameters_)].currentOptionAsInteger()>=kType) ? 1 : 0);
     3409    useDIVING |= 8*((parameters_[whichParam(DIVINGC,numberParameters_,parameters_)].currentOptionAsInteger()>=kType) ? 1 : 0);
     3410    useDIVING |= 16*((parameters_[whichParam(DIVINGL,numberParameters_,parameters_)].currentOptionAsInteger()>=kType) ? 1 : 0);
     3411    useDIVING |= 32*((parameters_[whichParam(DIVINGP,numberParameters_,parameters_)].currentOptionAsInteger()>=kType) ? 1 : 0);
    34053412  }
    34063413  if (useDIVING2>=kType) {
     
    34353442  }
    34363443 
    3437   if (useDIVING>=kType) {
     3444  if (useDIVING>0) {
    34383445    int diveOptions=parameters_[whichParam(DIVEOPT,numberParameters_,parameters_)].intValue();
    34393446    if (diveOptions<0||diveOptions>10)
     
    40934100    std::vector<std::string> rowNames;
    40944101    std::vector<std::string> columnNames;
    4095    
     4102    // Default strategy stuff
     4103    {
     4104      // try changing tolerance at root
     4105#define MORE_CUTS
     4106#ifdef MORE_CUTS
     4107      gomoryGen.setAwayAtRoot(0.005);
     4108      //gomoryGen.setAway(0.01);
     4109#else
     4110      gomoryGen.setAwayAtRoot(0.01);
     4111#endif
     4112      int iParam;
     4113      iParam = whichParam(DIVEOPT,numberParameters_,parameters_);
     4114      parameters_[iParam].setIntValue(3);
     4115      iParam = whichParam(FPUMPITS,numberParameters_,parameters_);
     4116      parameters_[iParam].setIntValue(30);
     4117      iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
     4118      parameters_[iParam].setIntValue(1005043);
     4119      iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
     4120      parameters_[iParam].setIntValue(6);
     4121      tunePreProcess=6;
     4122      iParam = whichParam(DIVINGC,numberParameters_,parameters_);
     4123      parameters_[iParam].setCurrentOption("on");
     4124      iParam = whichParam(RINS,numberParameters_,parameters_);
     4125      parameters_[iParam].setCurrentOption("on");
     4126      iParam = whichParam(PROBINGCUTS,numberParameters_,parameters_);
     4127      parameters_[iParam].setCurrentOption("forceon");
     4128      probingAction=4;
     4129    }
    40964130    std::string field;
    40974131    if (!noPrinting_) {
     
    41034137      // Print command line
    41044138      if (argc>1) {
     4139        bool foundStrategy=false;
    41054140        sprintf(generalPrint,"command line - ");
    41064141        for (int i=0;i<argc;i++) {
    41074142          if (!argv[i])
    41084143            break;
     4144          if (strstr(argv[i],"strat"))
     4145            foundStrategy=true;
    41094146          sprintf(generalPrint+strlen(generalPrint),"%s ",argv[i]);
    41104147        }
     4148        if (!foundStrategy)
     4149          sprintf(generalPrint+strlen(generalPrint),"(default strategy 1)");
    41114150        generalMessageHandler->message(CLP_GENERAL,generalMessages)
    41124151          << generalPrint
     
    44754514                  iParam = whichParam(FPUMPITS,numberParameters_,parameters_);
    44764515                  parameters_[iParam].setIntValue(30);
     4516                  iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
     4517                  parameters_[iParam].setIntValue(8043);
    44774518                  iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    44784519                  parameters_[iParam].setIntValue(6);
     
    44824523                  iParam = whichParam(RINS,numberParameters_,parameters_);
    44834524                  parameters_[iParam].setCurrentOption("on");
     4525                  iParam = whichParam(PROBINGCUTS,numberParameters_,parameters_);
     4526                  parameters_[iParam].setCurrentOption("on");
     4527                  probingAction=1;
     4528                }
     4529              } else if (parameters_[iParam].type()==STRATEGY) {
     4530                if (value==0) {
     4531                  gomoryGen.setAwayAtRoot(0.05);
     4532                  int iParam;
     4533                  iParam = whichParam(DIVEOPT,numberParameters_,parameters_);
     4534                  parameters_[iParam].setIntValue(-1);
     4535                  iParam = whichParam(FPUMPITS,numberParameters_,parameters_);
     4536                  parameters_[iParam].setIntValue(20);
     4537                  iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
     4538                  parameters_[iParam].setIntValue(1003);
     4539                  iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
     4540                  parameters_[iParam].setIntValue(-1);
     4541                  tunePreProcess=0;
     4542                  iParam = whichParam(DIVINGC,numberParameters_,parameters_);
     4543                  parameters_[iParam].setCurrentOption("off");
     4544                  iParam = whichParam(RINS,numberParameters_,parameters_);
     4545                  parameters_[iParam].setCurrentOption("off");
    44844546                  iParam = whichParam(PROBINGCUTS,numberParameters_,parameters_);
    44854547                  parameters_[iParam].setCurrentOption("on");
     
    52755337              if (vubAction!=-1) {
    52765338                // look at vubs
     5339                // extra1 is number of ints to leave free
    52775340                // Just ones which affect >= extra3
    52785341                int extra3 = parameters_[whichParam(EXTRA3,numberParameters_,parameters_)].intValue();
    52795342                /* 2 is cost above which to fix if feasible
    5280                    3 is fraction of integer variables fixed (0.97)
    5281                    4 is fraction of all variables fixed (0.0)
     5343                   3 is fraction of integer variables fixed if relaxing (0.97)
     5344                   4 is fraction of all variables fixed if relaxing (0.0)
    52825345                */
    5283                 double dextra[5];
     5346                double dextra[6];
     5347                int extra[5];
     5348                extra[1] = parameters_[whichParam(EXTRA1,numberParameters_,parameters_)].intValue();
     5349                if (parameters_[whichParam(EXPERIMENT,numberParameters_,
     5350                                           parameters_)].intValue()>=1&&
     5351                    extra[1]==-1)
     5352                  extra[1]=999998;
    52845353                dextra[1] = parameters_[whichParam(DEXTRA1,numberParameters_,parameters_)].doubleValue();
    52855354                dextra[2] = parameters_[whichParam(DEXTRA2,numberParameters_,parameters_)].doubleValue();
    52865355                dextra[3] = parameters_[whichParam(DEXTRA3,numberParameters_,parameters_)].doubleValue();
    52875356                dextra[4] = parameters_[whichParam(DEXTRA4,numberParameters_,parameters_)].doubleValue();
     5357                dextra[5] = parameters_[whichParam(DEXTRA5,numberParameters_,parameters_)].doubleValue();
    52885358                if (!dextra[3])
    52895359                  dextra[3] = 0.97;
    52905360                //OsiClpSolverInterface * newSolver =
    52915361                fixVubs(model_,extra3,vubAction,generalMessageHandler,
    5292                         debugValues,dextra);
     5362                        debugValues,dextra,extra);
    52935363                //assert (!newSolver);
    52945364              }
     
    53835453                statistics_nprocessedrows=si->getNumRows();
    53845454                statistics_nprocessedcols=si->getNumCols();
     5455                ClpSimplex * lpSolver = si->getModelPtr();
     5456                if (doVector) {
     5457                  ClpMatrixBase * matrix = lpSolver->clpMatrix();
     5458                  if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     5459                    ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     5460                    clpMatrix->makeSpecialColumnCopy();
     5461                  }
     5462                }
    53855463                // See if quadratic
    53865464#ifdef COIN_HAS_LINK
    53875465                if (!complicatedInteger) {
    5388                   ClpSimplex * lpSolver = si->getModelPtr();
    53895466                  ClpQuadraticObjective * obj = (dynamic_cast< ClpQuadraticObjective*>(lpSolver->objectiveAsObject()));
    53905467                  if (obj) {
     
    56525729                    <<CoinMessageEol;
    56535730                }
     5731                if (false) {
     5732                  // See if No objective!
     5733                  int numberColumns = clpSolver->getNumCols();
     5734                  const double * obj = clpSolver->getObjCoefficients();
     5735                  const double * lower = clpSolver->getColLower();
     5736                  const double * upper = clpSolver->getColUpper();
     5737                  int nObj=0;
     5738                  for (int i=0;i<numberColumns;i++) {
     5739                    if (upper[i]>lower[i]&&obj[i])
     5740                      nObj++;
     5741                  }
     5742                  if (!nObj) {
     5743                    printf("No objective!!\n");
     5744                    model_.setMaximumSolutions(1);
     5745                    // Column copy
     5746                    CoinPackedMatrix  matrixByCol(*model_.solver()->getMatrixByCol());
     5747                    //const double * element = matrixByCol.getElements();
     5748                    //const int * row = matrixByCol.getIndices();
     5749                    //const CoinBigIndex * columnStart = matrixByCol.getVectorStarts();
     5750                    const int * columnLength = matrixByCol.getVectorLengths();
     5751                    for (int i=0;i<numberColumns;i++) {
     5752                      double value = (CoinDrand48()+0.5)*10000;
     5753                      value *= columnLength[i];
     5754                      int iValue = ((int) value)/10;
     5755                      //iValue=1;
     5756                      clpSolver->setObjCoeff(i,iValue);
     5757                    }
     5758                  }
     5759                }
    56545760                if (!complicatedInteger&&preProcess==0&&clpSolver->tightenPrimalBounds(0.0,0,true)!=0) {
    56555761#ifndef DISALLOW_PRINTING
     
    56675773                if (clpSolver->dualBound()==1.0e10) {
    56685774                  ClpSimplex temp=*clpSolver;
     5775                  temp.setLogLevel(0);
    56695776                  temp.dual(0,7);
    56705777                  // user did not set - so modify
     
    62006307                  babModel_->setNumberBeforeTrust(10);
    62016308              }
     6309              int experimentFlag = parameters_[whichParam(EXPERIMENT,numberParameters_,
     6310                                                          parameters_)].intValue();
     6311              int strategyFlag = parameters_[whichParam(STRATEGY,numberParameters_,
     6312                                                          parameters_)].intValue();
     6313              int bothFlags = CoinMax(experimentFlag,strategyFlag);
    62026314              // add cut generators if wanted
    62036315              int switches[20];
     
    63096421              // Could tune more
    63106422              if (!miplib) {
    6311                 babModel_->setMinimumDrop(min(5.0e-2,
    6312                                              fabs(babModel_->getMinimizationObjValue())*1.0e-3+1.0e-4));
     6423                double minimumDrop =
     6424                  fabs(babModel_->solver()->getObjValue())*1.0e-5+1.0e-5;
     6425                babModel_->setMinimumDrop(CoinMin(5.0e-2,minimumDrop));
    63136426                if (cutPass==-1234567) {
    6314                   if (babModel_->getNumCols()<500)
     6427                  if (babModel_->getNumCols()<50000)
    63156428                    babModel_->setMaximumCutPassesAtRoot(-100); // always do 100 if possible
    63166429                  else if (babModel_->getNumCols()<5000)
     
    63226435                }
    63236436                if (cutPassInTree==-1234567)
    6324                   babModel_->setMaximumCutPasses(2);
     6437                  babModel_->setMaximumCutPasses(4);
    63256438                else
    63266439                  babModel_->setMaximumCutPasses(cutPassInTree);
     
    63566469              if (osiclp->getNumRows()<300&&osiclp->getNumCols()<500) {
    63576470                osiclp->setupForRepeatedUse(2,parameters_[slog].intValue());
     6471                if (bothFlags>=1) {
     6472                  ClpSimplex * lp = osiclp->getModelPtr();
     6473                  int specialOptions = lp->specialOptions();
     6474                  lp->setSpecialOptions(specialOptions|(2048+4096));
     6475                }
    63586476              } else {
    63596477                osiclp->setupForRepeatedUse(0,parameters_[slog].intValue());
    63606478              }
     6479              if (bothFlags>=2) {
     6480                ClpSimplex * lp = osiclp->getModelPtr();
     6481                int specialOptions = lp->specialOptions();
     6482                lp->setSpecialOptions(specialOptions|(2048+4096));
     6483              }
    63616484              double increment=babModel_->getCutoffIncrement();;
    63626485              int * changed = NULL;
     
    63956518              OsiSolverInterface * strengthenedModel=NULL;
    63966519              if (type==BAB||type==MIPLIB) {
    6397                 if (parameters_[whichParam(EXPERIMENT,numberParameters_,
    6398                                            parameters_)].intValue()==2) {
     6520                if (experimentFlag==2||strategyFlag==1) {
    63996521                  // try reduced model
    64006522                  babModel_->setSpecialOptions(babModel_->specialOptions()|512);
    6401                 } else if (parameters_[whichParam(EXPERIMENT,numberParameters_,
    6402                                            parameters_)].intValue()==3) {
     6523                } else if (experimentFlag==3||strategyFlag==2) {
    64036524                  // try reduced model at root
    64046525                  babModel_->setSpecialOptions(babModel_->specialOptions()|2048);
     
    64596580                    printf("XXXXX analyze %d\n",extra1);
    64606581                  }
     6582                } else if (bothFlags>=1) {
     6583                  babModel_->setWhenCuts(999998);
    64616584                }
    64626585              }
     
    65186641                      n = babModel_->getNumCols();
    65196642                    }
    6520                     prioritiesIn = new int[n];
     6643                    prioritiesIn = (int *) malloc(n*sizeof(int));
    65216644                    for (int i=0;i<n;i++)
    65226645                      prioritiesIn[i]=100;
     
    74297552                  return returnCode;
    74307553                }
    7431                 if (parameters_[whichParam(EXPERIMENT,numberParameters_,parameters_)].intValue()>=1) {
    7432                   osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    7433                   lpSolver = osiclp->getModelPtr();
     7554                osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     7555                lpSolver = osiclp->getModelPtr();
     7556                if (experimentFlag>=1||strategyFlag>=2) {
    74347557                  if (lpSolver->numberColumns()<200&&lpSolver->numberRows()<40)
    74357558                    babModel_->setFastNodeDepth(-9);
     7559                }
     7560                if (bothFlags>=1) {
    74367561#ifdef CLP_MULTIPLE_FACTORIZATIONS   
    74377562                  int goDense=40;
     
    75147639                  int numberColumns = babModel_->getNumCols();
    75157640                  const double * solution = babModel_->bestSolution();
    7516                   if (solution) {
     7641                  if (solution&&numberColumns<1000) {
    75177642                    for (int i=0;i<numberColumns;i++) {
    75187643                      if (solution[i])
     
    75927717                stuff[7]=parameters_[whichParam(EXTRA4,numberParameters_,parameters_)].intValue();
    75937718                stuff[8]=parameters_[whichParam(EXPERIMENT,numberParameters_,parameters_)].intValue();
     7719                stuff[8]=bothFlags;
     7720                stuff[9]=doVector;
    75947721                int returnCode=CbcClpUnitTest(model_, dirMiplib, extra1==1,stuff);
    75957722                babModel_=NULL;
     
    76237750                for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
    76247751                  CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator);
    7625                   CglStored * stored = dynamic_cast<CglStored*>(generator->generator());
    76267752                  statistics_name_generators[iGenerator]=
    76277753                    generator->cutGeneratorName();
    76287754                  statistics_number_cuts[iGenerator]=generator->numberCutsInTotal();
    7629                   if (stored&&!generator->numberCutsInTotal())
    7630                     continue;
    76317755                  sprintf(generalPrint,"%s was tried %d times and created %d cuts of which %d were active after adding rounds of cuts",
    76327756                          generator->cutGeneratorName(),
     
    76407764                    statistics_cut_time += generator->timeInCutGenerator();
    76417765                  }
     7766                  CglStored * stored = dynamic_cast<CglStored*>(generator->generator());
     7767                  if (stored&&!generator->numberCutsInTotal())
     7768                    continue;
     7769#ifndef CLP_INVESTIGATE
     7770                  CglImplication * implication = dynamic_cast<CglImplication*>(generator->generator());
     7771                  if (implication)
     7772                    continue;
     7773#endif
    76427774                  generalMessageHandler->message(CLP_GENERAL,generalMessages)
    76437775                    << generalPrint
     
    76767808                  bestSolution = new double [n];
    76777809                  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     7810                  ClpSimplex * lpSolver = clpSolver->getModelPtr();
    76787811                  // Save bounds on processed model
    76797812                  const int * originalColumns = process.originalColumns();
     
    76967829                    upper2[jColumn]=columnUpper[i];
    76977830                  }
    7698                   ClpSimplex * lpSolver = clpSolver->getModelPtr();
    76997831                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
    77007832                  process.postProcess(*babModel_->solver());
     
    93919523              }
    93929524            }
     9525            break;
    93939526          case SOLUTION:
    93949527            if (goodModel) {
  • trunk/Cbc/src/CbcStrategy.cpp

    r954 r1053  
    136136  // Set up some cut generators and defaults
    137137  // Probing first as gets tight bounds on continuous
     138  int genFlags=63;
     139  //#define CBC_GENERATE_TEST
     140#ifdef CBC_GENERATE_TEST
     141  int nNodes = model.getMaximumNodes();
     142  if (nNodes>=190000&&nNodes<190064)
     143    genFlags = nNodes-190000;
     144#endif
    138145
    139146  CglProbing generator1;
     
    183190    }
    184191  }
    185   if (!found)
     192  if (!found&&(genFlags&1)!=0)
    186193    model.addCutGenerator(&generator1,setting,"Probing");
    187194  found=false;
     
    194201    }
    195202  }
    196   if (!found)
     203  if (!found&&(genFlags&2)!=0)
    197204  model.addCutGenerator(&generator2,setting,"Gomory");
    198205  found=false;
     
    205212    }
    206213  }
    207   if (!found)
     214  if (!found&&(genFlags&4)!=0)
    208215    model.addCutGenerator(&generator3,setting,"Knapsack");
    209216  //model.addCutGenerator(&generator4,setting,"OddHole");
     
    217224    }
    218225  }
    219   if (!found)
     226  if (!found&&(genFlags&8)!=0)
    220227    model.addCutGenerator(&generator5,setting,"Clique");
    221228  found=false;
     
    228235    }
    229236  }
    230   if (!found)
     237  if (!found&&(genFlags&16)!=0)
    231238    model.addCutGenerator(&flowGen,setting,"FlowCover");
    232239  found=false;
     
    239246    }
    240247  }
    241   if (!found)
     248  if (!found&&(genFlags&32)!=0)
    242249    model.addCutGenerator(&mixedGen,setting,"MixedIntegerRounding2");
    243250  // Say we want timings
  • trunk/Cbc/src/CbcTree.cpp

    r954 r1053  
    8585        if (iColumn==kColumn) {
    8686          jColumn |= 0x40000000;
     87#ifndef NDEBUG
    8788          double value = newBounds[i];
    8889          if ((jColumn&0x80000000)==0) {
     
    9192            assert (value==down[1]);
    9293          }
     94#endif
    9395        }
    9496        if (numberBranching_==maximumBranching_)
  • trunk/Cbc/src/unitTestClp.cpp

    r961 r1053  
    99#include "CbcModel.hpp"
    1010#include "CbcCutGenerator.hpp"
     11#include "CglProbing.hpp"
    1112#include "OsiClpSolverInterface.hpp"
    1213#include "ClpFactorization.hpp"
     
    130131    //PUSH_MPS("p2756",755,2756,3124,2688.75,7);
    131132    //PUSH_MPS("seymour_1",4944,1372,410.7637014,404.35152,7);
     133    //PUSH_MPS("enigma",21,100,0.0,0.0,7);
    132134#define HOWMANY 2
    133135#if HOWMANY
     
    281283    // get clp itself
    282284    ClpSimplex * modelC = si->getModelPtr();
     285    if (stuff[9]) {
     286      // vector matrix!
     287      ClpMatrixBase * matrix = modelC->clpMatrix();
     288      if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     289        ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     290        clpMatrix->makeSpecialColumnCopy();
     291      }
     292    }
    283293    modelC->tightenPrimalBounds(0.0,0,true);
    284294    model->initialSolve();
     
    359369    model->setMinimumDrop(min(5.0e-2,
    360370                              fabs(model->getMinimizationObjValue())*1.0e-3+1.0e-4));
    361     if (model->getNumCols()<500) {
    362       model->setMaximumCutPassesAtRoot(-100); // always do 100 if possible
    363     } else if (model->getNumCols()<5000) {
    364       model->setMaximumCutPassesAtRoot(100); // use minimum drop
    365     } else {
    366       model->setMaximumCutPassesAtRoot(20);
     371    if (CoinAbs(model->getMaximumCutPassesAtRoot())<=100) {
     372      if (model->getNumCols()<500) {
     373        model->setMaximumCutPassesAtRoot(-100); // always do 100 if possible
     374      } else if (model->getNumCols()<5000) {
     375        model->setMaximumCutPassesAtRoot(100); // use minimum drop
     376      } else {
     377        model->setMaximumCutPassesAtRoot(20);
     378      }
    367379    }
    368380    // If defaults then increase trust for small models
     
    387399      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
    388400    }
     401    if (model->getNumCols()==-160) {
     402      // misc03
     403      std::string problemName ;
     404      model->solver()->getStrParam(OsiProbName,problemName) ;
     405      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     406    }
     407    if (model->getNumCols()==353) {
     408      // blend2
     409      std::string problemName ;
     410      model->solver()->getStrParam(OsiProbName,problemName) ;
     411      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     412    }
     413    if (model->getNumCols()==-100&&model->getNumRows()==21) {
     414      // enigma
     415      std::string problemName ;
     416      model->solver()->getStrParam(OsiProbName,problemName) ;
     417      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     418    }
     419    if (model->getNumCols()==-1541) {
     420      // qnet1
     421      std::string problemName ;
     422      model->solver()->getStrParam(OsiProbName,problemName) ;
     423      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     424    }
    389425    if (model->getNumCols()==-1224) {
    390426      //PUSH_MPS("gesa2",1392,1224,25779856.372,25476489.678,7);
     
    451487    for (int iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
    452488      CbcCutGenerator * generator = model->cutGenerator(iGenerator);
     489#ifndef CLP_INVESTIGATE
     490      CglImplication * implication = dynamic_cast<CglImplication*>(generator->generator());
     491      if (implication)
     492        continue;
     493#endif
    453494      std::cout<<generator->cutGeneratorName()<<" was tried "
    454495               <<generator->numberTimesEntered()<<" times and created "
     
    461502    }
    462503    if (!model->status()) {
    463       double soln = model->getObjValue();       
    464       CoinRelFltEq eq(1.0e-3) ;
    465       if (eq(soln,objValue[m])) {
     504      double soln = model->getObjValue(); 
     505      double tolerance = CoinMax(1.0e-5,1.0e-5*CoinMin(fabs(soln),fabs(objValue[m])));
     506      //CoinRelFltEq eq(1.0e-3) ;
     507      if (fabs(soln-objValue[m])<tolerance) {
    466508        std::cout
    467509          <<"cbc_clp"<<" "
     
    479521      std::cout << "error; too many nodes" ;
    480522    }
     523    timeTaken += timeOfSolution;
    481524    std::cout<<" - took " <<timeOfSolution<<" seconds.("<<
    482525      model->getNodeCount()<<" / "<<model->getIterationCount()<<
    483       " )"<<std::endl;
    484     timeTaken += timeOfSolution;
     526      " ) subtotal "<<timeTaken<<std::endl;
    485527    delete model;
    486528  }
Note: See TracChangeset for help on using the changeset viewer.