Changeset 1835 for stable/2.7


Ignore:
Timestamp:
Dec 21, 2012 4:30:02 AM (6 years ago)
Author:
forrest
Message:

keep event happened status from mini branch and bound

File:
1 edited

Legend:

Unmodified
Added
Removed
  • stable/2.7/Cbc/src/CbcHeuristic.cpp

    r1731 r1835  
    118118        numCouldRun_(0),
    119119        numberSolutionsFound_(0),
     120        numberNodesDone_(0),
    120121        inputSolution_(NULL)
    121122{
     
    145146        numCouldRun_(0),
    146147        numberSolutionsFound_(0),
     148        numberNodesDone_(0),
    147149        inputSolution_(NULL)
    148150{}
     
    172174    runNodes_ = rhs.runNodes_;
    173175    numberSolutionsFound_ = rhs.numberSolutionsFound_;
     176    numberNodesDone_ = rhs.numberNodesDone_;
    174177    if (rhs.inputSolution_) {
    175178        int numberColumns = model_->getNumCols();
     
    453456CbcHeuristic::setSeed(int value)
    454457{
     458    if (value==0) {
     459      double time = fabs(CoinGetTimeOfDay());
     460      while (time>=COIN_INT_MAX)
     461        time *= 0.5;
     462      value = static_cast<int>(time);
     463      char printArray[100];
     464      sprintf(printArray, "using time of day seed was changed from %d to %d",
     465              randomNumberGenerator_.getSeed(), value);
     466      if (model_)
     467        model_->messageHandler()->message(CBC_FPUMP1, model_->messages())
     468          << printArray
     469          << CoinMessageEol;
     470    }
    455471    randomNumberGenerator_.setSeed(value);
    456472}
     
    707723    {
    708724        int saveLogLevel = solver->messageHandler()->logLevel();
    709         if (saveLogLevel == 1)
     725        if (saveLogLevel == 1) 
    710726            solver->messageHandler()->setLogLevel(0);
    711727        OsiPresolve * pinfo = new OsiPresolve();
     
    838854    if (solver->isProvenOptimal()) {
    839855        CglPreProcess process;
     856        OsiSolverInterface * solver2 = NULL;
    840857        if ((model_->moreSpecialOptions()&65536)!=0)
    841858          process.setOptions(2+4+8); // no cuts
    842         /* Do not try and produce equality cliques and
    843            do up to 2 passes (normally) 5 if restart */
    844         int numberPasses = 2;
    845         if (numberNodes < 0) {
    846             numberPasses = 5;
    847             // Say some rows cuts
    848             int numberRows = solver->getNumRows();
    849             if (numberNodes_ < numberRows && true /* think */) {
    850                 char * type = new char[numberRows];
    851                 memset(type, 0, numberNodes_);
    852                 memset(type + numberNodes_, 1, numberRows - numberNodes_);
    853                 process.passInRowTypes(type, numberRows);
    854                 delete [] type;
    855             }
    856         }
    857         if (logLevel <= 1)
    858             process.messageHandler()->setLogLevel(0);
     859        /* Do not try and produce equality cliques and
     860           do up to 2 passes (normally) 5 if restart */
     861        int numberPasses = 2;
     862        if (numberNodes < 0) {
     863          numberPasses = 5;
     864          // Say some rows cuts
     865          int numberRows = solver->getNumRows();
     866          if (numberNodes_ < numberRows && true /* think */) {
     867            char * type = new char[numberRows];
     868            memset(type, 0, numberNodes_);
     869            memset(type + numberNodes_, 1, numberRows - numberNodes_);
     870            process.passInRowTypes(type, numberRows);
     871            delete [] type;
     872          }
     873        }
     874        if (logLevel <= 1)
     875          process.messageHandler()->setLogLevel(0);
    859876        if (!solver->defaultHandler()&&
    860877            solver->messageHandler()->logLevel(0)!=-1000)
    861878          process.passInMessageHandler(solver->messageHandler());
    862         OsiSolverInterface * solver2 = process.preProcessNonDefault(*solver, false,
    863                                        numberPasses);
    864         if (!solver2) {
     879        solver2 = process.preProcessNonDefault(*solver, false,
     880                                               numberPasses);
     881          if (!solver2) {
    865882            if (logLevel > 1)
    866                 printf("Pre-processing says infeasible\n");
     883              printf("Pre-processing says infeasible\n");
    867884            returnCode = 2; // so will be infeasible
    868         } else {
     885          } else {
    869886#ifdef COIN_DEVELOP_z
    870887            if (numberNodes < 0) {
    871                 solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
     888              solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
    872889            }
    873890#endif
     
    899916                    // normal
    900917                    model.setSpecialOptions(saveModelOptions | 2048);
    901                     if (logLevel <= 1)
     918                    if (logLevel <= 1 && feasibilityPumpOptions_ != -3)
    902919                        model.setLogLevel(0);
    903920                    else
     
    907924                    model.setCutoff(signedCutoff);
    908925                    // Don't do if original fraction > 1.0 and too large
    909                     if (fractionSmall_>1.0) {
     926                    if (fractionSmall_>1.0 && fractionSmall_ < 1000000.0) {
    910927                      /* 1.4 means -1 nodes if >.4
    911928                         2.4 means -1 nodes if >.5 and 0 otherwise
     
    9991016#endif
    10001017                model.setParentModel(*model_);
    1001                 model.setOriginalColumns(process.originalColumns());
     1018                model.setMaximumSolutions(model_->getMaximumSolutions());
     1019                model.setOriginalColumns(process.originalColumns());
    10021020                model.setSearchStrategy(-1);
    10031021                // If no feasibility pump then insert a lightweight one
    1004                 if (feasibilityPumpOptions_ >= 0) {
    1005                     bool gotPump = false;
     1022                if (feasibilityPumpOptions_ >= 0 || feasibilityPumpOptions_ == -2) {
     1023                    CbcHeuristicFPump * fpump = NULL;
    10061024                    for (int i = 0; i < model.numberHeuristics(); i++) {
    1007                         const CbcHeuristicFPump* pump =
    1008                             dynamic_cast<const CbcHeuristicFPump*>(model.heuristic(i));
    1009                         if (pump)
    1010                             gotPump = true;
     1025                        CbcHeuristicFPump* pump =
     1026                            dynamic_cast<CbcHeuristicFPump*>(model.heuristic(i));
     1027                        if (pump) {
     1028                            fpump = pump;
     1029                            break;
     1030                        }
    10111031                    }
    1012                     if (!gotPump) {
     1032                    if (!fpump) {
    10131033                        CbcHeuristicFPump heuristic4;
    10141034                        // use any cutoff
     
    10171037                          heuristic4.setMaximumPasses(10);
    10181038                        int pumpTune = feasibilityPumpOptions_;
     1039                        if (pumpTune==-2)
     1040                          pumpTune = 4; // proximity
    10191041                        if (pumpTune > 0) {
    10201042                            /*
     
    10731095                        }
    10741096                        model.addHeuristic(&heuristic4, "feasibility pump", 0);
     1097       
    10751098                    }
    1076                 }
     1099                } else if (feasibilityPumpOptions_==-3) {
     1100                  // add all (except this)
     1101                  for (int i = 0; i < model_->numberHeuristics(); i++) {
     1102                    if (strcmp(heuristicName(),model_->heuristic(i)->heuristicName()))
     1103                      model.addHeuristic(model_->heuristic(i));
     1104                  }
     1105                }
    10771106                //printf("sol %x\n",inputSolution_);
    10781107                if (inputSolution_) {
     
    11691198#define ALWAYS_DUAL
    11701199#ifdef ALWAYS_DUAL
    1171                     OsiSolverInterface * solver = model.solver();
     1200                    OsiSolverInterface * solverD = model.solver();
    11721201                    bool takeHint;
    11731202                    OsiHintStrength strength;
    1174                     solver->getHintParam(OsiDoDualInResolve, takeHint, strength);
    1175                     solver->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
     1203                    solverD->getHintParam(OsiDoDualInResolve, takeHint, strength);
     1204                    solverD->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
    11761205#endif
    11771206                    model.passInEventHandler(model_->getEventHandler());
     
    11821211                    model_->setSpecialOptions(saveOptions);
    11831212#ifdef ALWAYS_DUAL
    1184                     solver = model.solver();
    1185                     solver->setHintParam(OsiDoDualInResolve, takeHint, strength);
    1186 #endif
     1213                    solverD = model.solver();
     1214                    solverD->setHintParam(OsiDoDualInResolve, takeHint, strength);
     1215#endif
     1216                    numberNodesDone_ = model.getNodeCount();
    11871217#ifdef COIN_DEVELOP
    11881218                    printf("sub branch %d nodes, %d iterations - max %d\n",
     
    12381268                    }
    12391269#endif
    1240                     process.postProcess(*model.solver());
     1270                    //if (fractionSmall_ < 1000000.0)
     1271                      process.postProcess(*model.solver());
    12411272                    if (solver->isProvenOptimal() && solver->getObjValue()*solver->getObjSense() < cutoff) {
    12421273                        // Solution now back in solver
     
    12561287                                            process.numberIterationsPre() +
    12571288                                            process.numberIterationsPost();
    1258                 if (totalNumberIterations > 100*(numberNodes + 10)) {
     1289                if (totalNumberIterations > 100*(numberNodes + 10)
     1290                    && fractionSmall_ < 1000000.0) {
    12591291                    // only allow smaller problems
    12601292                    fractionSmall = fractionSmall_;
     
    12661298                }
    12671299                if (model.status() == 5)
    1268                     returnCode = -2; // stop
     1300                    model_->sayEventHappened();
    12691301                if (model.isProvenInfeasible())
    12701302                    status = 1;
Note: See TracChangeset for help on using the changeset viewer.