Changeset 1837


Ignore:
Timestamp:
Dec 22, 2012 11:17:37 AM (6 years ago)
Author:
stefan
Message:

undo r1835 and merge r1834 from releases/2.7.8

Location:
stable/2.7/Cbc
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • stable/2.7/Cbc

  • stable/2.7/Cbc/src/CbcHeuristic.cpp

    r1835 r1837  
    118118        numCouldRun_(0),
    119119        numberSolutionsFound_(0),
    120         numberNodesDone_(0),
    121120        inputSolution_(NULL)
    122121{
     
    146145        numCouldRun_(0),
    147146        numberSolutionsFound_(0),
    148         numberNodesDone_(0),
    149147        inputSolution_(NULL)
    150148{}
     
    174172    runNodes_ = rhs.runNodes_;
    175173    numberSolutionsFound_ = rhs.numberSolutionsFound_;
    176     numberNodesDone_ = rhs.numberNodesDone_;
    177174    if (rhs.inputSolution_) {
    178175        int numberColumns = model_->getNumCols();
     
    456453CbcHeuristic::setSeed(int value)
    457454{
    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     }
    471455    randomNumberGenerator_.setSeed(value);
    472456}
     
    723707    {
    724708        int saveLogLevel = solver->messageHandler()->logLevel();
    725         if (saveLogLevel == 1) 
     709        if (saveLogLevel == 1)
    726710            solver->messageHandler()->setLogLevel(0);
    727711        OsiPresolve * pinfo = new OsiPresolve();
     
    854838    if (solver->isProvenOptimal()) {
    855839        CglPreProcess process;
    856         OsiSolverInterface * solver2 = NULL;
    857840        if ((model_->moreSpecialOptions()&65536)!=0)
    858841          process.setOptions(2+4+8); // no cuts
    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);
     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);
    876859        if (!solver->defaultHandler()&&
    877860            solver->messageHandler()->logLevel(0)!=-1000)
    878861          process.passInMessageHandler(solver->messageHandler());
    879         solver2 = process.preProcessNonDefault(*solver, false,
    880                                                numberPasses);
    881           if (!solver2) {
     862        OsiSolverInterface * solver2 = process.preProcessNonDefault(*solver, false,
     863                                       numberPasses);
     864        if (!solver2) {
    882865            if (logLevel > 1)
    883               printf("Pre-processing says infeasible\n");
     866                printf("Pre-processing says infeasible\n");
    884867            returnCode = 2; // so will be infeasible
    885           } else {
     868        } else {
    886869#ifdef COIN_DEVELOP_z
    887870            if (numberNodes < 0) {
    888               solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
     871                solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
    889872            }
    890873#endif
     
    916899                    // normal
    917900                    model.setSpecialOptions(saveModelOptions | 2048);
    918                     if (logLevel <= 1 && feasibilityPumpOptions_ != -3)
     901                    if (logLevel <= 1)
    919902                        model.setLogLevel(0);
    920903                    else
     
    924907                    model.setCutoff(signedCutoff);
    925908                    // Don't do if original fraction > 1.0 and too large
    926                     if (fractionSmall_>1.0 && fractionSmall_ < 1000000.0) {
     909                    if (fractionSmall_>1.0) {
    927910                      /* 1.4 means -1 nodes if >.4
    928911                         2.4 means -1 nodes if >.5 and 0 otherwise
     
    1016999#endif
    10171000                model.setParentModel(*model_);
    1018                 model.setMaximumSolutions(model_->getMaximumSolutions());
    1019                 model.setOriginalColumns(process.originalColumns());
     1001                model.setOriginalColumns(process.originalColumns());
    10201002                model.setSearchStrategy(-1);
    10211003                // If no feasibility pump then insert a lightweight one
    1022                 if (feasibilityPumpOptions_ >= 0 || feasibilityPumpOptions_ == -2) {
    1023                     CbcHeuristicFPump * fpump = NULL;
     1004                if (feasibilityPumpOptions_ >= 0) {
     1005                    bool gotPump = false;
    10241006                    for (int i = 0; i < model.numberHeuristics(); i++) {
    1025                         CbcHeuristicFPump* pump =
    1026                             dynamic_cast<CbcHeuristicFPump*>(model.heuristic(i));
    1027                         if (pump) {
    1028                             fpump = pump;
    1029                             break;
    1030                         }
     1007                        const CbcHeuristicFPump* pump =
     1008                            dynamic_cast<const CbcHeuristicFPump*>(model.heuristic(i));
     1009                        if (pump)
     1010                            gotPump = true;
    10311011                    }
    1032                     if (!fpump) {
     1012                    if (!gotPump) {
    10331013                        CbcHeuristicFPump heuristic4;
    10341014                        // use any cutoff
     
    10371017                          heuristic4.setMaximumPasses(10);
    10381018                        int pumpTune = feasibilityPumpOptions_;
    1039                         if (pumpTune==-2)
    1040                           pumpTune = 4; // proximity
    10411019                        if (pumpTune > 0) {
    10421020                            /*
     
    10951073                        }
    10961074                        model.addHeuristic(&heuristic4, "feasibility pump", 0);
    1097        
    10981075                    }
    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                 }
     1076                }
    11061077                //printf("sol %x\n",inputSolution_);
    11071078                if (inputSolution_) {
     
    11981169#define ALWAYS_DUAL
    11991170#ifdef ALWAYS_DUAL
    1200                     OsiSolverInterface * solverD = model.solver();
     1171                    OsiSolverInterface * solver = model.solver();
    12011172                    bool takeHint;
    12021173                    OsiHintStrength strength;
    1203                     solverD->getHintParam(OsiDoDualInResolve, takeHint, strength);
    1204                     solverD->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
     1174                    solver->getHintParam(OsiDoDualInResolve, takeHint, strength);
     1175                    solver->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
    12051176#endif
    12061177                    model.passInEventHandler(model_->getEventHandler());
     
    12111182                    model_->setSpecialOptions(saveOptions);
    12121183#ifdef ALWAYS_DUAL
    1213                     solverD = model.solver();
    1214                     solverD->setHintParam(OsiDoDualInResolve, takeHint, strength);
    1215 #endif
    1216                     numberNodesDone_ = model.getNodeCount();
     1184                    solver = model.solver();
     1185                    solver->setHintParam(OsiDoDualInResolve, takeHint, strength);
     1186#endif
    12171187#ifdef COIN_DEVELOP
    12181188                    printf("sub branch %d nodes, %d iterations - max %d\n",
     
    12681238                    }
    12691239#endif
    1270                     //if (fractionSmall_ < 1000000.0)
    1271                       process.postProcess(*model.solver());
     1240                    process.postProcess(*model.solver());
    12721241                    if (solver->isProvenOptimal() && solver->getObjValue()*solver->getObjSense() < cutoff) {
    12731242                        // Solution now back in solver
     
    12871256                                            process.numberIterationsPre() +
    12881257                                            process.numberIterationsPost();
    1289                 if (totalNumberIterations > 100*(numberNodes + 10)
    1290                     && fractionSmall_ < 1000000.0) {
     1258                if (totalNumberIterations > 100*(numberNodes + 10)) {
    12911259                    // only allow smaller problems
    12921260                    fractionSmall = fractionSmall_;
     
    12981266                }
    12991267                if (model.status() == 5)
    1300                     model_->sayEventHappened();
     1268                  model_->sayEventHappened();
    13011269                if (model.isProvenInfeasible())
    13021270                    status = 1;
Note: See TracChangeset for help on using the changeset viewer.