Ignore:
File:
1 edited

Legend:

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

    r1839 r2105  
    373373    if (nodeCount<lastRunDeep_+skip )
    374374      return 0;
     375#ifdef HEURISTIC_INFORM
     376    printf("Entering heuristic %s - nRuns %d numCould %d when %d\n",
     377           heuristicName(),numRuns_,numCouldRun_,when_);
     378#endif
    375379    lastRunDeep_ = nodeCount;
    376380    howOftenShallow_ = numberSolutions_;
     
    549553    // Switch off if may take too long
    550554    if (model_->getNumCols() > 10000 && model_->getNumCols() >
    551             10*model_->getNumRows())
     555            10*model_->getNumRows()&&swap<10)
    552556        tryHeuristic = false;
    553557/*
     
    562566        // maybe just do 1000
    563567        int maxIntegers = numberIntegers;
    564         if (((swap/10) &1) != 0) {
    565           maxIntegers = CoinMin(1000,numberIntegers);
     568        // stop if too many goes
     569        int maxTries=COIN_INT_MAX;
     570        // integerVariable may be randomized copy!
     571        int * integerVariable =
     572          CoinCopyOfArray(model_->integerVariable(),numberIntegers);
     573        if (swap>9 && numberIntegers>500) {
     574          int type=swap/10;
     575          if (type==1) {
     576            // reduce
     577            maxIntegers = CoinMin(1000,numberIntegers);
     578          } else if (type==2) {
     579            // reduce even more
     580            maxTries=100000;
     581            maxIntegers = CoinMin(500,numberIntegers);
     582          } else if (type>2) {
     583            assert (type<10);
     584            int totals[7]={1000,500,100,50,50,50,50};
     585            maxIntegers=CoinMin(totals[type-3],numberIntegers);
     586            double * weight = new double[numberIntegers];
     587            for (int i=0;i<numberIntegers;i++) {
     588              weight[i]=model_->randomNumberGenerator()->randomDouble();
     589            }
     590            CoinSort_2(weight,weight+numberIntegers,integerVariable);
     591          }
    566592        }
    567593/*
     
    618644              // try down
    619645                for (k = i + 1; k < endInner; k++) {
     646                    if (!maxTries)
     647                      break;
     648                    maxTries--;
    620649                    if ((way[k]&1) != 0) {
    621650                        // try down
     
    708737                // try up
    709738                for (k = i + 1; k < endInner; k++) {
     739                    if (!maxTries)
     740                      break;
    710741                    if ((way[k]&1) != 0) {
    711742                        // try down
     
    893924            }
    894925        }
     926        // This is just a copy!
     927        delete [] integerVariable;
    895928    }
    896929/*
     
    936969        : CbcHeuristic()
    937970{
     971    increment_ = 0.01;
    938972    feasibilityPump_ = NULL;
    939973    numberSolutions_ = 0;
     
    948982        : CbcHeuristic(model)
    949983{
     984    increment_ = 0.01;
    950985    feasibilityPump_ = NULL;
    951986    numberSolutions_ = 0;
     
    9871022  numberSolutions_(rhs.numberSolutions_)
    9881023{
     1024    increment_ = rhs.increment_;
    9891025    feasibilityPump_ = NULL;
    9901026    if (model_ && rhs.used_) {
     
    10041040    if (this != &rhs) {
    10051041        CbcHeuristic::operator=(rhs);
     1042        increment_ = rhs.increment_;
    10061043        numberSolutions_ = rhs.numberSolutions_;
    10071044        delete [] used_;
     
    10951132  double cutoff=model_->getCutoff();
    10961133  assert (cutoff<1.0e20);
    1097   if (model_->getCutoffIncrement()<1.0e-4)
    1098     cutoff -= 0.01;
     1134  if (model_->getCutoffIncrement()<1.0e-4) {
     1135    cutoff -= increment_;
     1136  }
    10991137  double offset;
    11001138  newSolver->getDblParam(OsiObjOffset, offset);
     
    11851223            numberNodesDone_,numberNodes_,
    11861224            numberIncrease,sumIncrease,numberDecrease,sumDecrease);
     1225    if (!numberIncrease&&!numberDecrease) {
     1226      // somehow tolerances are such that we can slip through
     1227      // change for next time
     1228      increment_ += CoinMax(increment_,fabs(solutionValue+offset)*1.0e-10);
     1229    }
    11871230  } else {
    11881231    sprintf(proxPrint,"Proximity search ran %d nodes - no new solution",
     
    12821325    bool atRoot = model_->getNodeCount() == 0;
    12831326    int passNumber = model_->getCurrentPassNumber();
    1284     if (!when() || (when() == 1 && model_->phase() != 1) || !atRoot || passNumber != 1)
     1327    if (!when() || (when() == 1 && model_->phase() != 1) || !atRoot || passNumber > 1)
    12851328        return 0; // switched off
    12861329    // Don't do if it was this heuristic which found solution!
Note: See TracChangeset for help on using the changeset viewer.