Ignore:
File:
1 edited

Legend:

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

    r1834 r1888  
    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);
     472}
     473// Get seed
     474int
     475CbcHeuristic::getSeed() const
     476{
     477  return randomNumberGenerator_.getSeed();
    456478}
    457479
     
    632654    // valueNow,numberRowsNow,numberColumnsNow,
    633655    // valueStart,numberRowsStart,numberColumnsStart);
    634     if (10*numberRowsNow < 8*numberRowsStart)
     656    if (10*numberRowsNow < 8*numberRowsStart || 10*numberColumnsNow < 7*numberColumnsStart)
    635657        return valueNow / valueStart;
    636658    else if (10*numberRowsNow < 9*numberRowsStart)
     
    694716    getHistoryStatistics_ = false;
    695717#endif
     718#ifdef COIN_DEVELOP
    696719    int status = 0;
     720#endif
    697721    int logLevel = model_->logLevel();
    698722#define LEN_PRINT 250
     
    707731    {
    708732        int saveLogLevel = solver->messageHandler()->logLevel();
    709         if (saveLogLevel == 1)
     733        if (saveLogLevel == 1) 
    710734            solver->messageHandler()->setLogLevel(0);
    711735        OsiPresolve * pinfo = new OsiPresolve();
     
    810834                    }
    811835                }
    812             } else if (ratio > fractionSmall && after > 300) {
     836            } else if (ratio > fractionSmall && after > 300 && numberNodes >=0) {
    813837                returnCode = -1;
    814838            }
     
    838862    if (solver->isProvenOptimal()) {
    839863        CglPreProcess process;
     864        OsiSolverInterface * solver2 = NULL;
    840865        if ((model_->moreSpecialOptions()&65536)!=0)
    841866          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);
     867        /* Do not try and produce equality cliques and
     868           do up to 2 passes (normally) 5 if restart */
     869        int numberPasses = 2;
     870        if (numberNodes < 0) {
     871          numberPasses = 5;
     872          // Say some rows cuts
     873          int numberRows = solver->getNumRows();
     874          if (numberNodes_ < numberRows && true /* think */) {
     875            char * type = new char[numberRows];
     876            memset(type, 0, numberNodes_);
     877            memset(type + numberNodes_, 1, numberRows - numberNodes_);
     878            process.passInRowTypes(type, numberRows);
     879            delete [] type;
     880          }
     881        }
     882        if (logLevel <= 1)
     883          process.messageHandler()->setLogLevel(0);
    859884        if (!solver->defaultHandler()&&
    860885            solver->messageHandler()->logLevel(0)!=-1000)
    861886          process.passInMessageHandler(solver->messageHandler());
    862         OsiSolverInterface * solver2 = process.preProcessNonDefault(*solver, false,
    863                                        numberPasses);
    864         if (!solver2) {
     887        solver2 = process.preProcessNonDefault(*solver, false,
     888                                               numberPasses);
     889          if (!solver2) {
    865890            if (logLevel > 1)
    866                 printf("Pre-processing says infeasible\n");
     891              printf("Pre-processing says infeasible\n");
    867892            returnCode = 2; // so will be infeasible
    868         } else {
     893          } else {
    869894#ifdef COIN_DEVELOP_z
    870895            if (numberNodes < 0) {
    871                 solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
     896              solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
    872897            }
    873898#endif
     
    896921                solver2->resolve();
    897922                CbcModel model(*solver2);
     923                // move seed across
     924                model.randomNumberGenerator()->setSeed(model_->randomNumberGenerator()->getSeed());
    898925                if (numberNodes >= 0) {
    899926                    // normal
    900927                    model.setSpecialOptions(saveModelOptions | 2048);
    901                     if (logLevel <= 1)
     928                    if (logLevel <= 1 && feasibilityPumpOptions_ != -3)
    902929                        model.setLogLevel(0);
    903930                    else
     
    906933                    model.setFastNodeDepth(-1);
    907934                    model.setCutoff(signedCutoff);
     935                    model.setStrongStrategy(0);
    908936                    // Don't do if original fraction > 1.0 and too large
    909                     if (fractionSmall_>1.0) {
     937                    if (fractionSmall_>1.0 && fractionSmall_ < 1000000.0) {
    910938                      /* 1.4 means -1 nodes if >.4
    911939                         2.4 means -1 nodes if >.5 and 0 otherwise
     
    928956                    if ((saveModelOptions&2048) == 0)
    929957                      model.setMoreSpecialOptions(model_->moreSpecialOptions());
     958                    // off conflict analysis
     959                    model.setMoreSpecialOptions(model.moreSpecialOptions()&~4194304);
     960                   
    930961                    // Lightweight
    931962                    CbcStrategyDefaultSubTree strategy(model_, 1, 5, 1, 0);
     
    941972                    // going for full search and copy across more stuff
    942973                    model.gutsOfCopy(*model_, 2);
     974                    assert (!model_->heuristicModel());
     975                    model_->setHeuristicModel(&model);
    943976                    for (int i = 0; i < model.numberCutGenerators(); i++) {
    944977                        CbcCutGenerator * generator = model.cutGenerator(i);
     
    9681001                    model_->solver()->getHintParam(OsiDoReducePrint, takeHint, strength);
    9691002                    model.solver()->setHintParam(OsiDoReducePrint, takeHint, strength);
    970                     CbcStrategyDefault strategy(1, model_->numberStrong(),
    971                                                 model_->numberBeforeTrust());
     1003                    // no cut generators if none in parent
     1004                    CbcStrategyDefault
     1005                      strategy(model_->numberCutGenerators() ? 1 : -1,
     1006                               model_->numberStrong(),
     1007                               model_->numberBeforeTrust());
    9721008                    // Set up pre-processing - no
    9731009                    strategy.setupPreProcessing(0); // was (4);
     
    9791015                        CglStored cuts = process.cuts();
    9801016                        model.addCutGenerator(&cuts, 1, "Stored from first");
     1017                        model.cutGenerator(model.numberCutGenerators()-1)->setGlobalCuts(true);
    9811018                    }
    9821019                }
     
    9991036#endif
    10001037                model.setParentModel(*model_);
    1001                 model.setOriginalColumns(process.originalColumns());
     1038                model.setMaximumSolutions(model_->getMaximumSolutions());
     1039                model.setOriginalColumns(process.originalColumns());
    10021040                model.setSearchStrategy(-1);
    10031041                // If no feasibility pump then insert a lightweight one
    1004                 if (feasibilityPumpOptions_ >= 0) {
    1005                     bool gotPump = false;
     1042                if (feasibilityPumpOptions_ >= 0 || feasibilityPumpOptions_ == -2) {
     1043                    CbcHeuristicFPump * fpump = NULL;
    10061044                    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;
     1045                        CbcHeuristicFPump* pump =
     1046                            dynamic_cast<CbcHeuristicFPump*>(model.heuristic(i));
     1047                        if (pump) {
     1048                            fpump = pump;
     1049                            break;
     1050                        }
    10111051                    }
    1012                     if (!gotPump) {
     1052                    if (!fpump) {
    10131053                        CbcHeuristicFPump heuristic4;
    10141054                        // use any cutoff
     
    10171057                          heuristic4.setMaximumPasses(10);
    10181058                        int pumpTune = feasibilityPumpOptions_;
     1059                        if (pumpTune==-2)
     1060                          pumpTune = 4; // proximity
    10191061                        if (pumpTune > 0) {
    10201062                            /*
     
    10731115                        }
    10741116                        model.addHeuristic(&heuristic4, "feasibility pump", 0);
     1117       
    10751118                    }
    1076                 }
     1119                } else if (feasibilityPumpOptions_==-3) {
     1120                  // add all (except this)
     1121                  for (int i = 0; i < model_->numberHeuristics(); i++) {
     1122                    if (strcmp(heuristicName(),model_->heuristic(i)->heuristicName()))
     1123                      model.addHeuristic(model_->heuristic(i));
     1124                  }
     1125                }
    10771126                //printf("sol %x\n",inputSolution_);
    10781127                if (inputSolution_) {
     
    11691218#define ALWAYS_DUAL
    11701219#ifdef ALWAYS_DUAL
    1171                     OsiSolverInterface * solver = model.solver();
     1220                    OsiSolverInterface * solverD = model.solver();
    11721221                    bool takeHint;
    11731222                    OsiHintStrength strength;
    1174                     solver->getHintParam(OsiDoDualInResolve, takeHint, strength);
    1175                     solver->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
     1223                    solverD->getHintParam(OsiDoDualInResolve, takeHint, strength);
     1224                    solverD->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
    11761225#endif
    11771226                    model.passInEventHandler(model_->getEventHandler());
     
    11801229                    model_->setSpecialOptions(saveOptions|1048576);
    11811230                    model.branchAndBound();
     1231                    model_->setHeuristicModel(NULL);
    11821232                    model_->setSpecialOptions(saveOptions);
    11831233#ifdef ALWAYS_DUAL
    1184                     solver = model.solver();
    1185                     solver->setHintParam(OsiDoDualInResolve, takeHint, strength);
    1186 #endif
     1234                    solverD = model.solver();
     1235                    solverD->setHintParam(OsiDoDualInResolve, takeHint, strength);
     1236#endif
     1237                    numberNodesDone_ = model.getNodeCount();
    11871238#ifdef COIN_DEVELOP
    11881239                    printf("sub branch %d nodes, %d iterations - max %d\n",
     
    11931244                        model_->incrementIterationCount(model.getIterationCount());
    11941245                        model_->incrementNodeCount(model.getNodeCount());
     1246                        // update best solution (in case ctrl-c)
     1247                        // !!! not a good idea - think a bit harder
     1248                        //model_->setMinimizationObjValue(model.getMinimizationObjValue());
    11951249                        for (int iGenerator = 0; iGenerator < model.numberCutGenerators(); iGenerator++) {
    11961250                            CbcCutGenerator * generator = model.cutGenerator(iGenerator);
     
    12381292                    }
    12391293#endif
    1240                     process.postProcess(*model.solver());
     1294                    //if (fractionSmall_ < 1000000.0)
     1295                      process.postProcess(*model.solver());
    12411296                    if (solver->isProvenOptimal() && solver->getObjValue()*solver->getObjSense() < cutoff) {
    12421297                        // Solution now back in solver
     
    12561311                                            process.numberIterationsPre() +
    12571312                                            process.numberIterationsPost();
    1258                 if (totalNumberIterations > 100*(numberNodes + 10)) {
     1313                if (totalNumberIterations > 100*(numberNodes + 10)
     1314                    && fractionSmall_ < 1000000.0) {
    12591315                    // only allow smaller problems
    12601316                    fractionSmall = fractionSmall_;
     
    12661322                }
    12671323                if (model.status() == 5)
    1268                   model_->sayEventHappened();
     1324                   model_->sayEventHappened();
     1325#ifdef COIN_DEVELOP
    12691326                if (model.isProvenInfeasible())
    12701327                    status = 1;
    12711328                else if (model.isProvenOptimal())
    12721329                    status = 2;
     1330#endif
    12731331            }
    12741332        }
Note: See TracChangeset for help on using the changeset viewer.