Ignore:
File:
1 edited

Legend:

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

    r2055 r2110  
    2424#include "CbcHeuristic.hpp"
    2525#include "CbcHeuristicFPump.hpp"
     26#include "CbcHeuristicRINS.hpp"
     27#include "CbcEventHandler.hpp"
    2628#include "CbcStrategy.hpp"
    2729#include "CglPreProcess.hpp"
     
    148150        numberNodesDone_(0),
    149151        inputSolution_(NULL)
    150 {}
     152{
     153}
    151154
    152155void
     
    331334            return false;
    332335        }
    333         if (model_->getCurrentPassNumber() != 1) {
     336        if (model_->getCurrentPassNumber() > 1) {
    334337            // Run the heuristic only when first entering the node.
    335338            // LL: I don't think this is right. It should run just before strong
     
    380383            3 only at root and if no solution
    381384            4 only at root and if this heuristic has not got solution
    382             5 as 3 but decay more
    383             6 decay
     385            5 decay (but only if no solution)
     386            6 if depth <3 or decay
    384387            7 run up to 2 times if solution found 4 otherwise
    385388            */
     
    407410                    if ((numCouldRun_ % howOften_) == 0 &&
    408411                            numberSolutionsFound_*howOften_ < numCouldRun_) {
     412                      //#define COIN_DEVELOP
    409413#ifdef COIN_DEVELOP
    410414                        int old = howOften_;
     
    419423                    if (model_->bestSolution())
    420424                        probability *= 0.5;
     425                } else {
     426                    probability = 1.1;
    421427                }
    422428                break;
     
    664670}
    665671
    666 
     672//static int saveModel=0;
    667673// Do mini branch and bound (return 1 if solution)
    668674int
     
    671677                                  double cutoff, std::string name) const
    672678{
     679  CbcEventHandler *eventHandler = model_->getEventHandler() ;
     680  // Use this fraction
     681  double fractionSmall = fractionSmall_;
     682  int maximumSolutions =  model_->getMaximumSolutions();
     683  int iterationMultiplier = 100;
     684  if (eventHandler) {
     685    typedef struct {
     686      double fractionSmall;
     687      double spareDouble[3];
     688      OsiSolverInterface * solver;
     689      void * sparePointer[2];
     690      int numberNodes;
     691      int maximumSolutions;
     692      int iterationMultiplier;
     693      int howOften;
     694      int spareInt[3];
     695    } SmallMod;
     696    SmallMod temp;
     697    temp.solver=solver;
     698    temp.fractionSmall=fractionSmall;
     699    temp.numberNodes=numberNodes;
     700    temp.iterationMultiplier=iterationMultiplier;
     701    temp.howOften=howOften_;
     702    temp.maximumSolutions=maximumSolutions;
     703    CbcEventHandler::CbcAction status =
     704      eventHandler->event(CbcEventHandler::smallBranchAndBound,
     705                          &temp);
     706    if (status==CbcEventHandler::killSolution)
     707      return -1;
     708    if (status==CbcEventHandler::takeAction) {
     709      fractionSmall=temp.fractionSmall;
     710      numberNodes=temp.numberNodes;
     711      iterationMultiplier=temp.iterationMultiplier;
     712      howOften_=temp.howOften;
     713      maximumSolutions=temp.maximumSolutions;
     714    }
     715  }
     716#if 0
     717  if (saveModel || model_->getMaximumSolutions()==100) {
     718    printf("writing model\n");
     719    solver->writeMpsNative("before.mps", NULL, NULL, 2, 1);
     720  }
     721#endif
    673722    // size before
    674723    int shiftRows = 0;
     
    681730           name.c_str(), solver->getNumRows(), solver->getNumCols());
    682731#endif
    683     // Use this fraction
    684     double fractionSmall = fractionSmall_;
    685732    double before = 2 * numberRowsStart + numberColumnsStart;
    686733    if (before > 40000.0) {
     
    729776    //assert ((saveModelOptions&2048) == 0);
    730777    model_->setSpecialOptions(saveModelOptions | 2048);
    731     {
     778    if (fractionSmall<1.0) {
    732779        int saveLogLevel = solver->messageHandler()->logLevel();
    733780        if (saveLogLevel == 1)
     
    864911        OsiSolverInterface * solver2 = NULL;
    865912        if ((model_->moreSpecialOptions()&65536)!=0)
    866           process.setOptions(2+4+8); // no cuts
     913          process.setOptions(2+4+8+16); // no cuts
     914        else
     915          process.setOptions(16); // no complicated dupcol stuff
    867916        /* Do not try and produce equality cliques and
    868917           do up to 2 passes (normally) 5 if restart */
    869918        int numberPasses = 2;
     919        if ((model_->moreSpecialOptions2()&16)!=0) {
     920          // quick
     921          process.setOptions(2+4+8+16); // no cuts
     922          numberPasses = 1;
     923        }
    870924        if (numberNodes < 0) {
    871925          numberPasses = 5;
     
    9561010                    if ((saveModelOptions&2048) == 0)
    9571011                      model.setMoreSpecialOptions(model_->moreSpecialOptions());
     1012                      model.setMoreSpecialOptions2(model_->moreSpecialOptions2());
    9581013                    // off conflict analysis
    9591014                    model.setMoreSpecialOptions(model.moreSpecialOptions()&~4194304);
     
    9651020                    model.setMaximumCutPassesAtRoot(CoinMin(20, CoinAbs(model_->getMaximumCutPassesAtRoot())));
    9661021                    model.setMaximumCutPasses(CoinMin(10, model_->getMaximumCutPasses()));
     1022                    // Set best solution (even if bad for this submodel)
     1023                    if (model_->bestSolution()) {
     1024                      const double * bestSolution = model_->bestSolution();
     1025                      int numberColumns2 = model.solver()->getNumCols();
     1026                      double * bestSolution2 = new double [numberColumns2];
     1027                      const int * originalColumns = process.originalColumns();
     1028                      for (int iColumn=0;iColumn<numberColumns2;iColumn++) {
     1029                        int jColumn = originalColumns[iColumn];
     1030                        bestSolution2[iColumn] = bestSolution[jColumn];
     1031                      }
     1032                      model.setBestSolution(bestSolution2,numberColumns2,
     1033                                            1.0e50,
     1034                                            false);
     1035                      model.setSolutionCount(1);
     1036                      maximumSolutions++;
     1037                      delete [] bestSolution2;
     1038                    }
    9671039                } else {
    9681040                    model.setSpecialOptions(saveModelOptions);
     
    10361108#endif
    10371109                model.setParentModel(*model_);
    1038                 model.setMaximumSolutions(model_->getMaximumSolutions());
     1110                model.setMaximumSolutions(maximumSolutions);
    10391111                model.setOriginalColumns(process.originalColumns());
    10401112                model.setSearchStrategy(-1);
     
    11241196                  }
    11251197                }
     1198                // modify heuristics
     1199                for (int i = 0; i < model.numberHeuristics(); i++) {
     1200                  // reset lastNode
     1201                  CbcHeuristicRINS * rins =
     1202                    dynamic_cast<CbcHeuristicRINS*>(model.heuristic(i));
     1203                  if (rins) {
     1204                    rins->setLastNode(-1000);
     1205                    rins->setSolutionCount(0);
     1206                  }
     1207                }
    11261208                //printf("sol %x\n",inputSolution_);
    11271209                if (inputSolution_) {
     
    11921274                        value *= solver3->getObjSense();
    11931275                        model.setCutoff(value);
     1276                        sprintf(generalPrint, "Unable to insert previous solution - using cutoff of %g",
     1277                                value);
     1278                        model_->messageHandler()->message(CBC_FPUMP1, model_->messages())
     1279                        << generalPrint
     1280                        << CoinMessageEol;
    11941281#ifdef CLP_INVESTIGATE
    11951282                        printf("NOT added seren\n");
     
    12081295                        setCutAndHeuristicOptions(model);
    12091296                        // not too many iterations
    1210                         model.setMaximumNumberIterations(100*(numberNodes + 10));
     1297                        model.setMaximumNumberIterations(iterationMultiplier*(numberNodes + 10));
    12111298                        // Not fast stuff
    12121299                        model.setFastNodeDepth(-1);
     1300                        //model.solver()->writeMps("before");
    12131301                    } else if (model.fastNodeDepth() >= 1000000) {
    12141302                        // already set
     
    12281316                    int saveOptions = model_->specialOptions();
    12291317                    model_->setSpecialOptions(saveOptions|1048576);
     1318                    // and switch off debugger
     1319                    model.setSpecialOptions(model.specialOptions()&(~1));
     1320#if 0 //def COIN_HAS_CLP
     1321                    OsiClpSolverInterface * clpSolver
     1322                      = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     1323                    if (clpSolver)
     1324                      clpSolver->zapDebugger();
     1325#endif
     1326#ifdef CONFLICT_CUTS
     1327                    if ((model_->moreSpecialOptions()&4194304)!=0)
     1328                      model.zapGlobalCuts();
     1329#endif
    12301330                    model.branchAndBound();
    12311331                    model_->setHeuristicModel(NULL);
     
    13331433    } else {
    13341434        returnCode = 2; // infeasible finished
     1435        if (logLevel > 1){
     1436           printf("Infeasible on initial solve\n");
     1437        }
    13351438    }
    13361439    model_->setSpecialOptions(saveModelOptions);
     
    16531756    up_ = NULL;
    16541757    equal_ = NULL;
    1655     //whereFrom_ |= 16; // allow more often
     1758    //whereFrom_ |= 16*(1+256); // allow more often
    16561759}
    16571760
     
    16711774    equal_ = NULL;
    16721775    seed_ = 7654321;
    1673     //whereFrom_ |= 16; // allow more often
     1776    //whereFrom_ |= 16*(1+256); // allow more often
    16741777}
    16751778
     
    17601863    validate();
    17611864}
     1865/* Check whether the heuristic should run at all
     1866   0 - before cuts at root node (or from doHeuristics)
     1867   1 - during cuts at root
     1868   2 - after root node cuts
     1869   3 - after cuts at other nodes
     1870   4 - during cuts at other nodes
     1871   8 added if previous heuristic in loop found solution
     1872*/
     1873bool
     1874CbcRounding::shouldHeurRun(int whereFrom)
     1875{
     1876  if (whereFrom!=4) {
     1877    return CbcHeuristic::shouldHeurRun(whereFrom);
     1878  } else {
     1879    numCouldRun_++;
     1880    return shouldHeurRun_randomChoice();
     1881  }
     1882}
    17621883// See if rounding will give solution
    17631884// Sets value of solution
     
    17771898        return 0; // switched off
    17781899    numRuns_++;
     1900#ifdef HEURISTIC_INFORM
     1901    printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
     1902           heuristicName(),numRuns_,numCouldRun_,when_);
     1903#endif
    17791904    OsiSolverInterface * solver = model_->solver();
    17801905    double direction = solver->getObjSense();
     
    18081933    double primalTolerance;
    18091934    solver->getDblParam(OsiPrimalTolerance, primalTolerance);
     1935    double useTolerance = primalTolerance;
    18101936
    18111937    int numberRows = matrix_.getNumRows();
    18121938    assert (numberRows <= solver->getNumRows());
     1939    if (numberRows == 0){
     1940       return 0;
     1941    }
    18131942    int numberIntegers = model_->numberIntegers();
    18141943    const int * integerVariable = model_->integerVariable();
     
    18661995        int iColumn = integerVariable[i];
    18671996        double value = newSolution[iColumn];
     1997        //double thisTolerance = integerTolerance;
    18681998        if (fabs(floor(value + 0.5) - value) > integerTolerance) {
    18691999            double below = floor(value);
     
    19352065                            double thisCost = -direction * objective[iColumn] * distance;
    19362066                            if (integerType[iColumn]) {
    1937                                 distance = ceil(distance - primalTolerance);
    1938                                 if (currentValue - distance >= lowerValue - primalTolerance) {
    1939                                     if (absInfeasibility - distance*absElement < -gap - primalTolerance)
     2067                                distance = ceil(distance - useTolerance);
     2068                                if (currentValue - distance >= lowerValue - useTolerance) {
     2069                                    if (absInfeasibility - distance*absElement < -gap - useTolerance)
    19402070                                        thisCost = 1.0e100; // no good
    19412071                                    else
     
    19612091                            if (integerType[iColumn]) {
    19622092                                distance = ceil(distance - 1.0e-7);
    1963                                 assert (currentValue - distance <= upperValue + primalTolerance);
    1964                                 if (absInfeasibility - distance*absElement < -gap - primalTolerance)
     2093                                assert (currentValue - distance <= upperValue + useTolerance);
     2094                                if (absInfeasibility - distance*absElement < -gap - useTolerance)
    19652095                                    thisCost = 1.0e100; // no good
    19662096                                else
     
    21392269        // and now all if improving
    21402270        double lastChange = penaltyChange ? 1.0 : 0.0;
    2141         while (lastChange > 1.0e-2) {
     2271        int numberPasses=0;
     2272        while (lastChange > 1.0e-2 && numberPasses < 1000) {
    21422273            lastChange = 0;
     2274            numberPasses++;
    21432275            for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    21442276                bool isInteger = (integerType[iColumn] != 0);
     
    23552487                    bool good = true;
    23562488                    double newValue = newSolution[iColumn] + move;
    2357                     if (newValue < lower[iColumn] - primalTolerance ||
    2358                             newValue > upper[iColumn] + primalTolerance) {
     2489                    if (newValue < lower[iColumn] - useTolerance ||
     2490                            newValue > upper[iColumn] + useTolerance) {
    23592491                        move = 0.0;
    23602492                    } else {
     
    26712803    if (fixPriority_ < 0)
    26722804        return 0; // switched off
     2805#ifdef HEURISTIC_INFORM
     2806    printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
     2807           heuristicName(),numRuns_,numCouldRun_,when_);
     2808#endif
    26732809    const double * hotstartSolution = model_->hotstartSolution();
    26742810    const int * hotstartPriorities = model_->hotstartPriorities();
     
    28102946    if (!model_)
    28112947        return 0;
     2948#ifdef HEURISTIC_INFORM
     2949    printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
     2950           heuristicName(),numRuns_,numCouldRun_,when_);
     2951#endif
    28122952    if (!inputSolution_) {
    28132953        // get information on solver type
Note: See TracChangeset for help on using the changeset viewer.