Ignore:
Timestamp:
Jul 21, 2013 5:05:45 AM (6 years ago)
Author:
forrest
Message:

more options, copy statistics structure analysis
start coding of "switch" variables i.e. badly scaled ints or hi/lo
changes to allow more influence on small branch and bound
changes to get correct printout with threads

File:
1 edited

Legend:

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

    r1886 r1943  
    2424#include "CbcHeuristic.hpp"
    2525#include "CbcHeuristicFPump.hpp"
     26#include "CbcEventHandler.hpp"
    2627#include "CbcStrategy.hpp"
    2728#include "CglPreProcess.hpp"
     
    148149        numberNodesDone_(0),
    149150        inputSolution_(NULL)
    150 {}
     151{
     152}
    151153
    152154void
     
    407409                    if ((numCouldRun_ % howOften_) == 0 &&
    408410                            numberSolutionsFound_*howOften_ < numCouldRun_) {
     411                      //#define COIN_DEVELOP
    409412#ifdef COIN_DEVELOP
    410413                        int old = howOften_;
     
    664667}
    665668
    666 
     669//static int saveModel=0;
    667670// Do mini branch and bound (return 1 if solution)
    668671int
     
    671674                                  double cutoff, std::string name) const
    672675{
     676  CbcEventHandler *eventHandler = model_->getEventHandler() ;
     677  // Use this fraction
     678  double fractionSmall = fractionSmall_;
     679  int maximumSolutions =  model_->getMaximumSolutions();
     680  int iterationMultiplier = 100;
     681  if (eventHandler) {
     682    typedef struct {
     683      double fractionSmall;
     684      double spareDouble[3];
     685      OsiSolverInterface * solver;
     686      void * sparePointer[2];
     687      int numberNodes;
     688      int maximumSolutions;
     689      int iterationMultiplier;
     690      int howOften;
     691      int spareInt[3];
     692    } SmallMod;
     693    SmallMod temp;
     694    temp.solver=solver;
     695    temp.fractionSmall=fractionSmall;
     696    temp.numberNodes=numberNodes;
     697    temp.iterationMultiplier=iterationMultiplier;
     698    temp.howOften=howOften_;
     699    temp.maximumSolutions=maximumSolutions;
     700    CbcEventHandler::CbcAction status =
     701      eventHandler->event(CbcEventHandler::smallBranchAndBound,
     702                          &temp);
     703    if (status==CbcEventHandler::killSolution)
     704      return -1;
     705    if (status==CbcEventHandler::takeAction) {
     706      fractionSmall=temp.fractionSmall;
     707      numberNodes=temp.numberNodes;
     708      iterationMultiplier=temp.iterationMultiplier;
     709      howOften_=temp.howOften;
     710      maximumSolutions=temp.maximumSolutions;
     711    }
     712  }
     713#if 0
     714  if (saveModel || model_->getMaximumSolutions()==100) {
     715    printf("writing model\n");
     716    solver->writeMpsNative("before.mps", NULL, NULL, 2, 1);
     717  }
     718#endif
    673719    // size before
    674720    int shiftRows = 0;
     
    681727           name.c_str(), solver->getNumRows(), solver->getNumCols());
    682728#endif
    683     // Use this fraction
    684     double fractionSmall = fractionSmall_;
    685729    double before = 2 * numberRowsStart + numberColumnsStart;
    686730    if (before > 40000.0) {
     
    729773    //assert ((saveModelOptions&2048) == 0);
    730774    model_->setSpecialOptions(saveModelOptions | 2048);
    731     {
     775    if (fractionSmall<1.0) {
    732776        int saveLogLevel = solver->messageHandler()->logLevel();
    733777        if (saveLogLevel == 1)
     
    864908        OsiSolverInterface * solver2 = NULL;
    865909        if ((model_->moreSpecialOptions()&65536)!=0)
    866           process.setOptions(2+4+8); // no cuts
     910          process.setOptions(2+4+8+16); // no cuts
     911        else
     912          process.setOptions(16); // no complicated dupcol stuff
    867913        /* Do not try and produce equality cliques and
    868914           do up to 2 passes (normally) 5 if restart */
    869915        int numberPasses = 2;
     916        if ((model_->moreSpecialOptions2()&16)!=0) {
     917          // quick
     918          process.setOptions(2+4+8+16); // no cuts
     919          numberPasses = 1;
     920        }
    870921        if (numberNodes < 0) {
    871922          numberPasses = 5;
     
    9561007                    if ((saveModelOptions&2048) == 0)
    9571008                      model.setMoreSpecialOptions(model_->moreSpecialOptions());
     1009                      model.setMoreSpecialOptions2(model_->moreSpecialOptions2());
    9581010                    // off conflict analysis
    9591011                    model.setMoreSpecialOptions(model.moreSpecialOptions()&~4194304);
     
    10361088#endif
    10371089                model.setParentModel(*model_);
    1038                 model.setMaximumSolutions(model_->getMaximumSolutions());
     1090                model.setMaximumSolutions(maximumSolutions);
    10391091                model.setOriginalColumns(process.originalColumns());
    10401092                model.setSearchStrategy(-1);
     
    12081260                        setCutAndHeuristicOptions(model);
    12091261                        // not too many iterations
    1210                         model.setMaximumNumberIterations(100*(numberNodes + 10));
     1262                        model.setMaximumNumberIterations(iterationMultiplier*(numberNodes + 10));
    12111263                        // Not fast stuff
    12121264                        model.setFastNodeDepth(-1);
     
    12281280                    int saveOptions = model_->specialOptions();
    12291281                    model_->setSpecialOptions(saveOptions|1048576);
     1282                    // and switch off debugger
     1283                    model.setSpecialOptions(model.specialOptions()&(~1));
     1284#if 0 //def COIN_HAS_CLP
     1285                    OsiClpSolverInterface * clpSolver
     1286                      = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     1287                    if (clpSolver)
     1288                      clpSolver->zapDebugger();
     1289#endif
    12301290                    model.branchAndBound();
    12311291                    model_->setHeuristicModel(NULL);
     
    13331393    } else {
    13341394        returnCode = 2; // infeasible finished
     1395        printf("Infeasible on initial solve\n");
    13351396    }
    13361397    model_->setSpecialOptions(saveModelOptions);
     
    18081869    double primalTolerance;
    18091870    solver->getDblParam(OsiPrimalTolerance, primalTolerance);
     1871    double useTolerance = primalTolerance;
    18101872
    18111873    int numberRows = matrix_.getNumRows();
     
    18661928        int iColumn = integerVariable[i];
    18671929        double value = newSolution[iColumn];
     1930        double thisTolerance = integerTolerance;
    18681931        if (fabs(floor(value + 0.5) - value) > integerTolerance) {
    18691932            double below = floor(value);
     
    19351998                            double thisCost = -direction * objective[iColumn] * distance;
    19361999                            if (integerType[iColumn]) {
    1937                                 distance = ceil(distance - primalTolerance);
    1938                                 if (currentValue - distance >= lowerValue - primalTolerance) {
    1939                                     if (absInfeasibility - distance*absElement < -gap - primalTolerance)
     2000                                distance = ceil(distance - useTolerance);
     2001                                if (currentValue - distance >= lowerValue - useTolerance) {
     2002                                    if (absInfeasibility - distance*absElement < -gap - useTolerance)
    19402003                                        thisCost = 1.0e100; // no good
    19412004                                    else
     
    19612024                            if (integerType[iColumn]) {
    19622025                                distance = ceil(distance - 1.0e-7);
    1963                                 assert (currentValue - distance <= upperValue + primalTolerance);
    1964                                 if (absInfeasibility - distance*absElement < -gap - primalTolerance)
     2026                                assert (currentValue - distance <= upperValue + useTolerance);
     2027                                if (absInfeasibility - distance*absElement < -gap - useTolerance)
    19652028                                    thisCost = 1.0e100; // no good
    19662029                                else
     
    21392202        // and now all if improving
    21402203        double lastChange = penaltyChange ? 1.0 : 0.0;
    2141         while (lastChange > 1.0e-2) {
     2204        int numberPasses=0;
     2205        while (lastChange > 1.0e-2 && numberPasses < 1000) {
    21422206            lastChange = 0;
     2207            numberPasses++;
    21432208            for (iColumn = 0; iColumn < numberColumns; iColumn++) {
    21442209                bool isInteger = (integerType[iColumn] != 0);
     
    23552420                    bool good = true;
    23562421                    double newValue = newSolution[iColumn] + move;
    2357                     if (newValue < lower[iColumn] - primalTolerance ||
    2358                             newValue > upper[iColumn] + primalTolerance) {
     2422                    if (newValue < lower[iColumn] - useTolerance ||
     2423                            newValue > upper[iColumn] + useTolerance) {
    23592424                        move = 0.0;
    23602425                    } else {
Note: See TracChangeset for help on using the changeset viewer.