Ignore:
Timestamp:
Nov 21, 2012 4:38:56 AM (7 years ago)
Author:
forrest
Message:

add Proximity heuristic (Fischetti and Monaci) - shouldn't break anything

File:
1 edited

Legend:

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

    r1730 r1802  
    707707    {
    708708        int saveLogLevel = solver->messageHandler()->logLevel();
    709         if (saveLogLevel == 1)
     709        if (saveLogLevel == 1) 
    710710            solver->messageHandler()->setLogLevel(0);
    711711        OsiPresolve * pinfo = new OsiPresolve();
     
    838838    if (solver->isProvenOptimal()) {
    839839        CglPreProcess process;
     840        OsiSolverInterface * solver2 = NULL;
    840841        if ((model_->moreSpecialOptions()&65536)!=0)
    841842          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);
     843        /* Do not try and produce equality cliques and
     844           do up to 2 passes (normally) 5 if restart */
     845        int numberPasses = 2;
     846        if (numberNodes < 0) {
     847          numberPasses = 5;
     848          // Say some rows cuts
     849          int numberRows = solver->getNumRows();
     850          if (numberNodes_ < numberRows && true /* think */) {
     851            char * type = new char[numberRows];
     852            memset(type, 0, numberNodes_);
     853            memset(type + numberNodes_, 1, numberRows - numberNodes_);
     854            process.passInRowTypes(type, numberRows);
     855            delete [] type;
     856          }
     857        }
     858        if (logLevel <= 1)
     859          process.messageHandler()->setLogLevel(0);
    859860        if (!solver->defaultHandler()&&
    860861            solver->messageHandler()->logLevel(0)!=-1000)
    861862          process.passInMessageHandler(solver->messageHandler());
    862         OsiSolverInterface * solver2 = process.preProcessNonDefault(*solver, false,
    863                                        numberPasses);
    864         if (!solver2) {
     863        solver2 = process.preProcessNonDefault(*solver, false,
     864                                               numberPasses);
     865          if (!solver2) {
    865866            if (logLevel > 1)
    866                 printf("Pre-processing says infeasible\n");
     867              printf("Pre-processing says infeasible\n");
    867868            returnCode = 2; // so will be infeasible
    868         } else {
     869          } else {
    869870#ifdef COIN_DEVELOP_z
    870871            if (numberNodes < 0) {
    871                 solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
     872              solver2->writeMpsNative("after2.mps", NULL, NULL, 2, 1);
    872873            }
    873874#endif
     
    899900                    // normal
    900901                    model.setSpecialOptions(saveModelOptions | 2048);
    901                     if (logLevel <= 1)
     902                    if (logLevel <= 1 && feasibilityPumpOptions_ != -3)
    902903                        model.setLogLevel(0);
    903904                    else
     
    907908                    model.setCutoff(signedCutoff);
    908909                    // Don't do if original fraction > 1.0 and too large
    909                     if (fractionSmall_>1.0) {
     910                    if (fractionSmall_>1.0 && fractionSmall_ < 1000000.0) {
    910911                      /* 1.4 means -1 nodes if >.4
    911912                         2.4 means -1 nodes if >.5 and 0 otherwise
     
    9991000#endif
    10001001                model.setParentModel(*model_);
    1001                 model.setOriginalColumns(process.originalColumns());
     1002                model.setMaximumSolutions(model_->getMaximumSolutions());
     1003                model.setOriginalColumns(process.originalColumns());
    10021004                model.setSearchStrategy(-1);
    10031005                // If no feasibility pump then insert a lightweight one
    1004                 if (feasibilityPumpOptions_ >= 0) {
    1005                     bool gotPump = false;
     1006                if (feasibilityPumpOptions_ >= 0 || feasibilityPumpOptions_ == -2) {
     1007                    CbcHeuristicFPump * fpump = NULL;
    10061008                    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;
     1009                        CbcHeuristicFPump* pump =
     1010                            dynamic_cast<CbcHeuristicFPump*>(model.heuristic(i));
     1011                        if (pump) {
     1012                            fpump = pump;
     1013                            break;
     1014                        }
    10111015                    }
    1012                     if (!gotPump) {
     1016                    if (!fpump) {
    10131017                        CbcHeuristicFPump heuristic4;
    10141018                        // use any cutoff
     
    10171021                          heuristic4.setMaximumPasses(10);
    10181022                        int pumpTune = feasibilityPumpOptions_;
     1023                        if (pumpTune==-2)
     1024                          pumpTune = 4; // proximity
    10191025                        if (pumpTune > 0) {
    10201026                            /*
     
    10731079                        }
    10741080                        model.addHeuristic(&heuristic4, "feasibility pump", 0);
     1081       
    10751082                    }
    1076                 }
     1083                } else if (feasibilityPumpOptions_==-3) {
     1084                  // add all (except this)
     1085                  for (int i = 0; i < model_->numberHeuristics(); i++) {
     1086                    if (strcmp(heuristicName(),model_->heuristic(i)->heuristicName()))
     1087                      model.addHeuristic(model_->heuristic(i));
     1088                  }
     1089                }
    10771090                //printf("sol %x\n",inputSolution_);
    10781091                if (inputSolution_) {
     
    11691182#define ALWAYS_DUAL
    11701183#ifdef ALWAYS_DUAL
    1171                     OsiSolverInterface * solver = model.solver();
     1184                    OsiSolverInterface * solverD = model.solver();
    11721185                    bool takeHint;
    11731186                    OsiHintStrength strength;
    1174                     solver->getHintParam(OsiDoDualInResolve, takeHint, strength);
    1175                     solver->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
     1187                    solverD->getHintParam(OsiDoDualInResolve, takeHint, strength);
     1188                    solverD->setHintParam(OsiDoDualInResolve, true, OsiHintDo);
    11761189#endif
    11771190                    model.passInEventHandler(model_->getEventHandler());
     
    11821195                    model_->setSpecialOptions(saveOptions);
    11831196#ifdef ALWAYS_DUAL
    1184                     solver = model.solver();
    1185                     solver->setHintParam(OsiDoDualInResolve, takeHint, strength);
     1197                    solverD = model.solver();
     1198                    solverD->setHintParam(OsiDoDualInResolve, takeHint, strength);
    11861199#endif
    11871200#ifdef COIN_DEVELOP
     
    12381251                    }
    12391252#endif
    1240                     process.postProcess(*model.solver());
     1253                    //if (fractionSmall_ < 1000000.0)
     1254                      process.postProcess(*model.solver());
    12411255                    if (solver->isProvenOptimal() && solver->getObjValue()*solver->getObjSense() < cutoff) {
    12421256                        // Solution now back in solver
     
    12561270                                            process.numberIterationsPre() +
    12571271                                            process.numberIterationsPost();
    1258                 if (totalNumberIterations > 100*(numberNodes + 10)) {
     1272                if (totalNumberIterations > 100*(numberNodes + 10)
     1273                    && fractionSmall_ < 1000000.0) {
    12591274                    // only allow smaller problems
    12601275                    fractionSmall = fractionSmall_;
Note: See TracChangeset for help on using the changeset viewer.