Changeset 2093


Ignore:
Timestamp:
Nov 6, 2014 11:17:38 AM (4 years ago)
Author:
forrest
Message:

changes for diving heuristic

Location:
trunk/Cbc/src
Files:
19 edited

Legend:

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

    r2092 r2093  
    334334            return false;
    335335        }
    336         if (model_->getCurrentPassNumber() != 1) {
     336        if (model_->getCurrentPassNumber() > 1) {
    337337            // Run the heuristic only when first entering the node.
    338338            // LL: I don't think this is right. It should run just before strong
  • trunk/Cbc/src/CbcHeuristic.hpp

    r1943 r2093  
    170170        16 bit - needs new solution to run
    171171        1024 bit - stop all heuristics on max time
     172        65536 bit and above used for temporary communication
    172173    */
    173174    inline int switches() const {
  • trunk/Cbc/src/CbcHeuristicDINS.cpp

    r1943 r2093  
    202202    }
    203203    int finalReturnCode = 0;
    204     if (((model_->getNodeCount() % howOften_) == howOften_ / 2 || !model_->getNodeCount()) && (model_->getCurrentPassNumber() == 1 || model_->getCurrentPassNumber() == 999999)) {
     204    if (((model_->getNodeCount() % howOften_) == howOften_ / 2 || !model_->getNodeCount()) && (model_->getCurrentPassNumber() <= 1 || model_->getCurrentPassNumber() == 999999)) {
    205205        OsiSolverInterface * solver = model_->solver();
    206206
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r2092 r2093  
    1313#include "CbcModel.hpp"
    1414#include "CbcSubProblem.hpp"
     15#include "CbcSimpleInteger.hpp"
    1516#include "OsiAuxInfo.hpp"
    1617#include  "CoinTime.hpp"
     
    2223//#define DIVE_FIX_BINARY_VARIABLES
    2324//#define DIVE_DEBUG
     25#ifdef DIVE_DEBUG
     26#define DIVE_PRINT
     27#endif
     28#undef DIVE_PRINT
    2429
    2530// Default Constructor
     
    3237    downArray_ = NULL;
    3338    upArray_ = NULL;
     39    priority_ = NULL;
    3440    percentageToFix_ = 0.2;
    3541    maxIterations_ = 100;
     
    3945    whereFrom_ = 255 - 2 - 16 + 256;
    4046    decayFactor_ = 1.0;
     47    smallObjective_ = 1.0e-10;
    4148}
    4249
     
    4956    downArray_ = NULL;
    5057    upArray_ = NULL;
     58    priority_ = NULL;
    5159    // Get a copy of original matrix
    5260    assert(model.solver());
     
    5967    }
    6068    percentageToFix_ = 0.2;
     69    maxTime_ = 600;
     70    smallObjective_ = 1.0e-10;
    6171    maxIterations_ = 100;
    6272    maxSimplexIterations_ = 10000;
    6373    maxSimplexIterationsAtRoot_ = 1000000;
    64     maxTime_ = 600;
    6574    whereFrom_ = 255 - 2 - 16 + 256;
    6675    decayFactor_ = 1.0;
     76    smallObjective_ = 1.0e-10;
     77    setPriorities();
    6778}
    6879
     
    7283    delete [] downLocks_;
    7384    delete [] upLocks_;
     85    delete [] priority_;
    7486    assert (!downArray_);
    7587}
     
    106118        matrixByRow_(rhs.matrixByRow_),
    107119        percentageToFix_(rhs.percentageToFix_),
     120        maxTime_(rhs.maxTime_),
     121        smallObjective_(rhs.smallObjective_),
    108122        maxIterations_(rhs.maxIterations_),
    109123        maxSimplexIterations_(rhs.maxSimplexIterations_),
    110         maxSimplexIterationsAtRoot_(rhs.maxSimplexIterationsAtRoot_),
    111         maxTime_(rhs.maxTime_)
     124        maxSimplexIterationsAtRoot_(rhs.maxSimplexIterationsAtRoot_)
    112125{
    113126    downArray_ = NULL;
     
    117130        downLocks_ = CoinCopyOfArray(rhs.downLocks_, numberIntegers);
    118131        upLocks_ = CoinCopyOfArray(rhs.upLocks_, numberIntegers);
     132        priority_ = CoinCopyOfArray(rhs.priority_, numberIntegers);
    119133    } else {
    120134        downLocks_ = NULL;
    121135        upLocks_ = NULL;
     136        priority_ = NULL;
    122137    }
    123138}
     
    136151        maxSimplexIterationsAtRoot_ = rhs.maxSimplexIterationsAtRoot_;
    137152        maxTime_ = rhs.maxTime_;
     153        smallObjective_ = rhs.smallObjective_;
    138154        delete [] downLocks_;
    139155        delete [] upLocks_;
     156        delete [] priority_;
    140157        if (rhs.downLocks_) {
    141158            int numberIntegers = model_->numberIntegers();
    142159            downLocks_ = CoinCopyOfArray(rhs.downLocks_, numberIntegers);
    143160            upLocks_ = CoinCopyOfArray(rhs.upLocks_, numberIntegers);
     161            priority_ = CoinCopyOfArray(rhs.priority_, numberIntegers);
    144162        } else {
    145163            downLocks_ = NULL;
    146164            upLocks_ = NULL;
     165            priority_ = NULL;
    147166        }
    148167    }
     
    164183        validate();
    165184    }
     185    setPriorities();
    166186}
    167187
    168188// update model
    169 void CbcHeuristicDive::setModel(CbcModel * model)
     189void
     190CbcHeuristicDive::setModel(CbcModel * model)
    170191{
    171192    model_ = model;
     
    179200        validate();
    180201    }
    181 }
     202    setPriorities();
     203}
     204
     205// Sets priorities if any
     206void
     207CbcHeuristicDive::setPriorities()
     208{
     209  delete [] priority_;
     210  assert (model_);
     211  priority_=NULL;
     212  if (!model_->objects())
     213    return;
     214  bool gotPriorities=false;
     215  int numberIntegers = model_->numberIntegers();
     216  int priority1=-COIN_INT_MAX;
     217  int priority2=COIN_INT_MAX;
     218  smallObjective_=0.0;
     219  const double * objective = model_->solver()->getObjCoefficients();
     220  for (int i = 0; i < numberIntegers; i++) {
     221    OsiObject * object = model_->modifiableObject(i);
     222    const CbcSimpleInteger * thisOne = dynamic_cast <const CbcSimpleInteger *> (object);
     223    assert (thisOne);
     224    int iColumn = thisOne->columnNumber();
     225    smallObjective_ += objective[iColumn];
     226    int level=thisOne->priority();
     227    priority1=CoinMax(priority1,level);
     228    priority2=CoinMin(priority2,level);
     229    if (thisOne->preferredWay()!=0)
     230      gotPriorities=true;
     231  }
     232  smallObjective_ = CoinMax(1.0e-10,1.0e-5*(smallObjective_/numberIntegers));
     233  if (gotPriorities || priority1>priority2) {
     234    priority_ = new PriorityType [numberIntegers];
     235    for (int i = 0; i < numberIntegers; i++) {
     236      OsiObject * object = model_->modifiableObject(i);
     237      const CbcSimpleInteger * thisOne = dynamic_cast <const CbcSimpleInteger *> (object);
     238      int level=thisOne->priority()-priority2;
     239      assert (level<(1<<29));
     240      priority_[i].priority=static_cast<unsigned int>(level);
     241      int direction=0;
     242      if (thisOne->preferredWay()<0)
     243        direction=1;
     244      else if (thisOne->preferredWay()>0)
     245        direction=1|1;
     246        // at present don't try other way is not used
     247      priority_[i].direction=static_cast<unsigned char>(direction);
     248    }
     249  }
     250}
     251
    182252
    183253bool CbcHeuristicDive::canHeuristicRun()
    184254{
     255    if (model_->bestSolution()) {
     256      if (when_==3 || (when_==4 && numberSolutionsFound_) )
     257        return false;
     258    }
    185259    return shouldHeurRun_randomChoice();
    186260}
     
    199273                           double * newSolution)
    200274{
    201 #ifdef DIVE_DEBUG
     275#ifdef DIVE_PRINT
    202276    int nRoundInfeasible = 0;
    203277    int nRoundFeasible = 0;
     
    208282    int maxSimplexIterations = (model_->getNodeCount()) ? maxSimplexIterations_
    209283                               : maxSimplexIterationsAtRoot_;
     284    int maxIterationsInOneSolve = (maxSimplexIterations<1000000) ? 1000 : 10000;
    210285    // but can't be exactly coin_int_max
    211286    maxSimplexIterations = CoinMin(maxSimplexIterations,COIN_INT_MAX>>3);
     287    bool fixGeneralIntegers=false;
     288    int maxIterations = maxIterations_;
     289    int saveSwitches = switches_;
     290    if ((maxIterations_%10)!=0) {
     291      int digit = maxIterations_%10;
     292      maxIterations -= digit;
     293      switches_ |= 65536;
     294      if ((digit&3)!=0)
     295        fixGeneralIntegers=true;
     296    }
     297
    212298    OsiSolverInterface * solver = cloneBut(6); // was model_->solver()->clone();
    213299# ifdef COIN_HAS_CLP
     
    218304      int oneSolveIts = clpSimplex->maximumIterations();
    219305      oneSolveIts = CoinMin(1000+2*(clpSimplex->numberRows()+clpSimplex->numberColumns()),oneSolveIts);
     306      if (maxSimplexIterations>1000000)
     307        maxIterationsInOneSolve=oneSolveIts;
    220308      clpSimplex->setMaximumIterations(oneSolveIts);
    221309      if (!nodes) {
     
    271359
    272360    // vectors to store the latest variables fixed at their bounds
    273     int* columnFixed = new int [numberIntegers];
     361    int* columnFixed = new int [numberIntegers+numberColumns];
     362    int * back = columnFixed + numberIntegers;
    274363    double* originalBound = new double [numberIntegers+2*numberColumns];
    275364    double * lowerBefore = originalBound+numberIntegers;
     
    287376    // count how many fractional variables
    288377    int numberFractionalVariables = 0;
     378    for (int i=0;i<numberColumns;i++)
     379      back[i]=-1;
    289380    for (int i = 0; i < numberIntegers; i++) {
    290381        random[i] = randomNumberGenerator_.randomDouble() + 0.3;
    291382        int iColumn = integerVariable[i];
     383        back[iColumn]=i;
    292384        double value = newSolution[iColumn];
    293385        // clean
     
    302394    const double* reducedCost = NULL;
    303395    // See if not NLP
    304     if (model_->solverCharacteristics()->reducedCostsAccurate())
     396    if (!model_->solverCharacteristics() ||
     397        model_->solverCharacteristics()->reducedCostsAccurate())
    305398        reducedCost = solver->getReducedCost();
    306399
    307400    int iteration = 0;
     401    int numberAtBoundFixed = 0;
     402    int numberGeneralFixed = 0; // fixed as satisfied but not at bound
     403    int numberReducedCostFixed = 0;
    308404    while (numberFractionalVariables) {
    309405        iteration++;
     
    345441            }
    346442            if (direction*(solver->getObjValue() + delta) < solutionValue) {
    347 #ifdef DIVE_DEBUG
     443#ifdef DIVE_PRINT
    348444                nRoundFeasible++;
    349445#endif
     
    392488                }
    393489            }
    394 #ifdef DIVE_DEBUG
     490#ifdef DIVE_PRINT
    395491            else
    396492                nRoundInfeasible++;
     
    399495
    400496        // do reduced cost fixing
    401 #ifdef DIVE_DEBUG
    402         int numberFixed = reducedCostFix(solver);
    403         std::cout << "numberReducedCostFixed = " << numberFixed << std::endl;
     497#ifdef DIVE_PRINT
     498        numberReducedCostFixed = reducedCostFix(solver);
    404499#else
    405500        reducedCostFix(solver);
    406501#endif
    407502
    408         int numberAtBoundFixed = 0;
     503        numberAtBoundFixed = 0;
     504        numberGeneralFixed = 0; // fixed as satisfied but not at bound
    409505#ifdef DIVE_FIX_BINARY_VARIABLES
    410506        // fix binary variables based on pseudo reduced cost
     
    484580        double gap = 1.0e30;
    485581#endif
     582        int fixPriority=COIN_INT_MAX;
    486583        if (reducedCost && true) {
    487584#ifndef JJF_ONE
    488585            cnt = fixOtherVariables(solver, solution, candidate, random);
     586            if (priority_) {
     587              for (int i = 0; i < cnt; i++) {
     588                int iColumn = candidate[i].var;
     589                if (upper[iColumn] > lower[iColumn]) {
     590                  int j=back[iColumn];
     591                  fixPriority = CoinMin(fixPriority,static_cast<int>(priority_[j].priority));
     592                }
     593              }
     594            }
    489595#else
    490596#ifdef GAP
     
    508614                if (upper[iColumn] > lower[iColumn]) {
    509615                    numberFree++;
     616                    if (priority_) {
     617                      fixPriority = CoinMin(fixPriority,static_cast<int>(priority_[i].priority));
     618                    }
    510619                    double value = newSolution[iColumn];
    511620                    if (fabs(floor(value + 0.5) - value) <= integerTolerance) {
     
    543652                int iColumn = integerVariable[i];
    544653                if (upper[iColumn] > lower[iColumn]) {
     654                    if (priority_) {
     655                      fixPriority = CoinMin(fixPriority,static_cast<int>(priority_[i].priority));
     656                    }
    545657                    double value = newSolution[iColumn];
    546658                    if (fabs(floor(value + 0.5) - value) <= integerTolerance) {
     
    552664        }
    553665        std::sort(candidate, candidate + cnt, compareBinaryVars);
     666        // If getting on fix all
     667        if (iteration*3>maxIterations_*2)
     668          fixPriority=COIN_INT_MAX;
    554669        for (int i = 0; i < cnt; i++) {
    555670            int iColumn = candidate[i].var;
     
    559674                        numberAtBoundFixed < maxNumberAtBoundToFix) {
    560675                    // fix the variable at one of its bounds
    561                     if (fabs(lower[iColumn] - value) <= integerTolerance) {
    562                         columnFixed[numberAtBoundFixed] = iColumn;
    563                         originalBound[numberAtBoundFixed] = upper[iColumn];
    564                         fixedAtLowerBound[numberAtBoundFixed] = true;
    565                         solver->setColUpper(iColumn, lower[iColumn]);
     676                    if (fabs(lower[iColumn] - value) <= integerTolerance ||
     677                        fixGeneralIntegers) {
     678                        if (priority_) {
     679                          int j=back[iColumn];
     680                          if (priority_[j].priority>fixPriority)
     681                            continue; // skip - only fix ones at high priority
     682                          int thisRound=static_cast<int>(priority_[j].direction);
     683                          if ((thisRound&1)!=0) {
     684                            // for now force way
     685                            if((thisRound&2)!=0)
     686                              continue;
     687                          }
     688                        }
     689                        if (fabs(lower[iColumn] - value) <= integerTolerance) {
     690                          columnFixed[numberAtBoundFixed] = iColumn;
     691                          originalBound[numberAtBoundFixed] = upper[iColumn];
     692                          fixedAtLowerBound[numberAtBoundFixed] = true;
     693                          solver->setColUpper(iColumn, lower[iColumn]);
     694                        } else {
     695                          // fix to interior value
     696                          numberGeneralFixed++;
     697                          double fixValue = floor(value + 0.5);
     698                          columnFixed[numberAtBoundFixed] = iColumn;
     699                          originalBound[numberAtBoundFixed] = upper[iColumn];
     700                          fixedAtLowerBound[numberAtBoundFixed] = true;
     701                          solver->setColUpper(iColumn, fixValue);
     702                          numberAtBoundFixed++;
     703                          columnFixed[numberAtBoundFixed] = iColumn;
     704                          originalBound[numberAtBoundFixed] = lower[iColumn];
     705                          fixedAtLowerBound[numberAtBoundFixed] = false;
     706                          solver->setColLower(iColumn, fixValue);
     707                        }
     708                        //if (priority_)
     709                        //printf("fixing %d (priority %d) to lower bound of %g\n",
     710                        //       iColumn,priority_[back[iColumn]].priority,lower[iColumn]);
    566711                        numberAtBoundFixed++;
    567712                    } else if (fabs(upper[iColumn] - value) <= integerTolerance) {
     713                        if (priority_) {
     714                          int j=back[iColumn];
     715                          if (priority_[j].priority>fixPriority)
     716                            continue; // skip - only fix ones at high priority
     717                          int thisRound=static_cast<int>(priority_[j].direction);
     718                          if ((thisRound&1)!=0) {
     719                            // for now force way
     720                            if((thisRound&2)==0)
     721                              continue;
     722                          }
     723                        }
    568724                        columnFixed[numberAtBoundFixed] = iColumn;
    569725                        originalBound[numberAtBoundFixed] = lower[iColumn];
    570726                        fixedAtLowerBound[numberAtBoundFixed] = false;
    571727                        solver->setColLower(iColumn, upper[iColumn]);
     728                        //if (priority_)
     729                        //printf("fixing %d (priority %d) to upper bound of %g\n",
     730                        //       iColumn,priority_[back[iColumn]].priority,upper[iColumn]);
    572731                        numberAtBoundFixed++;
    573732                    }
     
    577736            }
    578737        }
    579 #ifdef DIVE_DEBUG
    580         std::cout << "numberAtBoundFixed = " << numberAtBoundFixed << std::endl;
    581 #endif
    582738
    583739        double originalBoundBestColumn;
     
    589745                originalBoundBestColumn = upper[bestColumn];
    590746                solver->setColUpper(bestColumn, floor(bestColumnValue));
     747#ifdef DIVE_DEBUG
     748                if (priority_) {
     749                  printf("setting %d (priority %d) upper bound to %g (%g)\n",
     750                         bestColumn,priority_[back[bestColumn]].priority,floor(bestColumnValue),bestColumnValue);
     751                }
     752#endif
    591753                whichWay=0;
    592754            } else {
    593755                originalBoundBestColumn = lower[bestColumn];
    594756                solver->setColLower(bestColumn, ceil(bestColumnValue));
     757#ifdef DIVE_DEBUG
     758                if (priority_) {
     759                  printf("setting %d (priority %d) lower bound to %g (%g)\n",
     760                         bestColumn,priority_[back[bestColumn]].priority,ceil(bestColumnValue),bestColumnValue);
     761                }
     762#endif
    595763                whichWay=1;
    596764            }
     
    600768        int originalBestRound = bestRound;
    601769        int saveModelOptions = model_->specialOptions();
    602        
    603770        while (1) {
    604771
    605772            model_->setSpecialOptions(saveModelOptions | 2048);
    606773            solver->resolve();
     774#ifdef DIVE_PRINT
     775            int numberFractionalVariables = 0;
     776            double sumFractionalVariables=0.0;
     777            int numberFixed=0;
     778            for (int i = 0; i < numberIntegers; i++) {
     779              int iColumn = integerVariable[i];
     780              double value = newSolution[iColumn];
     781              double away = fabs(floor(value + 0.5) - value);
     782              if (away > integerTolerance) {
     783                numberFractionalVariables++;
     784                sumFractionalVariables += away;
     785              }
     786              if (upper[iColumn]==lower[iColumn])
     787                  numberFixed++;
     788            }
     789            printf("pass %d obj %g %s its %d total %d fixed %d +(%d,%d)",iteration,
     790                   solver->getObjValue(),solver->isProvenOptimal() ? "opt" : "infeasible",
     791                   solver->getIterationCount(),
     792                   solver->getIterationCount()+numberSimplexIterations,
     793                   numberFixed,
     794                   numberReducedCostFixed,
     795                   numberAtBoundFixed-numberGeneralFixed);
     796            if (solver->isProvenOptimal()) {
     797              printf(" - %d at bound, %d away (sum %g)\n",
     798                     numberIntegers-numberFixed-numberFractionalVariables,
     799                     numberFractionalVariables,sumFractionalVariables);
     800            } else {
     801              printf("\n");
     802              if (fixGeneralIntegers) {
     803                int digit = maxIterations_%10;
     804                if (digit==1) {
     805                  // switch off for now
     806                  switches_=saveSwitches;
     807                  fixGeneralIntegers=false;
     808                } else if (digit==2) {
     809                  // switch off always
     810                  switches_=saveSwitches;
     811                  fixGeneralIntegers=false;
     812                  maxIterations_ -= digit;
     813                }
     814              }
     815            }
     816#else
     817            if (!solver->isProvenOptimal()) {
     818              if (fixGeneralIntegers) {
     819                int digit = maxIterations_%10;
     820                if (digit==1) {
     821                  // switch off for now
     822                  switches_=saveSwitches;
     823                  fixGeneralIntegers=false;
     824                } else if (digit==2) {
     825                  // switch off always
     826                  switches_=saveSwitches;
     827                  fixGeneralIntegers=false;
     828                  maxIterations_ -= digit;
     829                }
     830              }
     831            }
     832#endif
    607833            model_->setSpecialOptions(saveModelOptions);
    608834            if (!solver->isAbandoned()&&!solver->isIterationLimitReached()) {
     
    676902            reasonToStop += 4;
    677903            // also switch off
    678 #ifdef CLP_INVESTIGATE
     904#ifdef DIVE_PRINT
    679905            printf("switching off diving as too many iterations %d, %d allowed\n",
    680906                   numberSimplexIterations, maxSimplexIterations);
    681907#endif
    682908            when_ = 0;
    683         } else if (solver->getIterationCount() > 1000 && iteration > 3 && !nodes) {
     909        } else if (solver->getIterationCount() > maxIterationsInOneSolve && iteration > 3 && !nodes) {
    684910            reasonToStop += 5;
    685911            // also switch off
    686 #ifdef CLP_INVESTIGATE
     912#ifdef DIVE_PRINT
    687913            printf("switching off diving one iteration took %d iterations (total %d)\n",
    688914                   solver->getIterationCount(), numberSimplexIterations);
     
    8501076    }
    8511077
    852 #ifdef DIVE_DEBUG
     1078#ifdef DIVE_PRINT
    8531079    std::cout << "nRoundInfeasible = " << nRoundInfeasible
    8541080              << ", nRoundFeasible = " << nRoundFeasible
     
    8691095    upArray_ = NULL;
    8701096    delete solver;
     1097    switches_ = saveSwitches;
    8711098    return returnCode;
    8721099}
     
    8811108    if (feasibilityPumpOptions_>0 && (nodeCount % feasibilityPumpOptions_) != 0)
    8821109        return 0;
    883 #ifdef DIVE_DEBUG
    884     std::cout << "solutionValue = " << solutionValue << std::endl;
    885 #endif
    8861110    ++numCouldRun_;
    8871111
     
    8951119            (when() % 10 == 2 && (model_->phase() != 2 && model_->phase() != 3)))
    8961120        return 0; // switched off
     1121#endif
     1122#ifdef DIVE_DEBUG
     1123    std::cout << "solutionValue = " << solutionValue << std::endl;
    8971124#endif
    8981125    // Get solution array for heuristic solution
  • trunk/Cbc/src/CbcHeuristicDive.hpp

    r1899 r2093  
    6262                         double * newSolution);
    6363    /// inner part of dive
    64   int solution(double & objectiveValue, int & numberNodes,
     64    int solution(double & objectiveValue, int & numberNodes,
    6565                 int & numberCuts, OsiRowCut ** cuts,
    6666                 CbcSubProblem ** & nodes,
     
    7575    /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
    7676    virtual void validate();
     77
     78    /// Sets priorities if any
     79    void setPriorities();
    7780
    7881    /// Select candidate binary variables for fixing
     
    154157    double * upArray_;
    155158
     159    /// Array of priorities
     160    typedef struct {
     161      unsigned int direction:3; //  0 bit off, 1 bit (0 down first, 1 up first) 2 bit non zero don't try other way
     162      unsigned int priority:29;
     163    } PriorityType;
     164    PriorityType * priority_;
    156165    // Indexes of binary variables with 0 objective coefficient
    157166    // and in variable bound constraints
     
    164173    double percentageToFix_;
    165174
     175    // Maximum time allowed
     176    double maxTime_;
     177
     178    // Small objective (i.e. treat zero objective as this)
     179    double smallObjective_;
     180
    166181    // Maximum number of major iterations
    167182    int maxIterations_;
     
    173188    int maxSimplexIterationsAtRoot_;
    174189
    175     // Maximum time allowed
    176     double maxTime_;
    177 
    178190};
    179191#endif
  • trunk/Cbc/src/CbcHeuristicDiveCoefficient.cpp

    r1899 r2093  
    8181    int bestLocks = COIN_INT_MAX;
    8282    bool allTriviallyRoundableSoFar = true;
     83    int bestPriority = COIN_INT_MAX;
    8384    for (int i = 0; i < numberIntegers; i++) {
    8485        int iColumn = integerVariable[i];
     
    117118                    fraction *= 1000.0;
    118119
     120                // if priorities then use
     121                if (priority_) {
     122                  int thisRound=static_cast<int>(priority_[i].direction);
     123                  if ((thisRound&1)!=0)
     124                    round = ((thisRound&2)==0) ? -1 : +1;
     125                  if (priority_[i].priority>bestPriority) {
     126                    nLocks=COIN_INT_MAX;
     127                  } else if (priority_[i].priority<bestPriority) {
     128                    bestPriority=static_cast<int>(priority_[i].priority);
     129                    bestLocks=COIN_INT_MAX;
     130                  }
     131                }
    119132                if (nLocks < bestLocks || (nLocks == bestLocks &&
    120133                                           fraction < bestFraction)) {
  • trunk/Cbc/src/CbcHeuristicDiveFractional.cpp

    r1899 r2093  
    7878    double bestFraction = COIN_DBL_MAX;
    7979    bool allTriviallyRoundableSoFar = true;
     80    int bestPriority = COIN_INT_MAX;
    8081    for (int i = 0; i < numberIntegers; i++) {
    8182        int iColumn = integerVariable[i];
     
    103104                    fraction *= 1000.0;
    104105
     106                // if priorities then use
     107                if (priority_) {
     108                  int thisRound=static_cast<int>(priority_[i].direction);
     109                  if ((thisRound&1)!=0)
     110                    round = ((thisRound&2)==0) ? -1 : +1;
     111                  if (priority_[i].priority>bestPriority) {
     112                    fraction=COIN_DBL_MAX;
     113                  } else if (priority_[i].priority<bestPriority) {
     114                    bestPriority=static_cast<int>(priority_[i].priority);
     115                    bestFraction=COIN_DBL_MAX;
     116                  }
     117                }
    105118                if (fraction < bestFraction) {
    106119                    bestColumn = iColumn;
  • trunk/Cbc/src/CbcHeuristicDiveGuided.cpp

    r1899 r2093  
    9090    double bestFraction = COIN_DBL_MAX;
    9191    bool allTriviallyRoundableSoFar = true;
     92    int bestPriority = COIN_INT_MAX;
    9293    for (int i = 0; i < numberIntegers; i++) {
    9394        int iColumn = integerVariable[i];
     
    114115                    fraction *= 1000.0;
    115116
     117                // if priorities then use
     118                if (priority_) {
     119                  int thisRound=static_cast<int>(priority_[i].direction);
     120                  if ((thisRound&1)!=0)
     121                    round = ((thisRound&2)==0) ? -1 : +1;
     122                  if (priority_[i].priority>bestPriority) {
     123                    fraction=COIN_DBL_MAX;
     124                  } else if (priority_[i].priority<bestPriority) {
     125                    bestPriority=static_cast<int>(priority_[i].priority);
     126                    bestFraction=COIN_DBL_MAX;
     127                  }
     128                }
    116129                if (fraction < bestFraction) {
    117130                    bestColumn = iColumn;
  • trunk/Cbc/src/CbcHeuristicDiveLineSearch.cpp

    r1899 r2093  
    8181    double bestRelDistance = COIN_DBL_MAX;
    8282    bool allTriviallyRoundableSoFar = true;
     83    int bestPriority = COIN_INT_MAX;
    8384    for (int i = 0; i < numberIntegers; i++) {
    8485        int iColumn = integerVariable[i];
     
    111112                    relDistance *= 1000.0;
    112113
     114                // if priorities then use
     115                if (priority_) {
     116                  int thisRound=static_cast<int>(priority_[i].direction);
     117                  if ((thisRound&1)!=0)
     118                    round = ((thisRound&2)==0) ? -1 : +1;
     119                  if (priority_[i].priority>bestPriority) {
     120                    relDistance=COIN_DBL_MAX;
     121                  } else if (priority_[i].priority<bestPriority) {
     122                    bestPriority=static_cast<int>(priority_[i].priority);
     123                    bestRelDistance=COIN_DBL_MAX;
     124                  }
     125                }
    113126                if (relDistance < bestRelDistance) {
    114127                    bestColumn = iColumn;
  • trunk/Cbc/src/CbcHeuristicDivePseudoCost.cpp

    r1923 r2093  
    8686    double bestScore = -1.0;
    8787    bool allTriviallyRoundableSoFar = true;
     88    int bestPriority = COIN_INT_MAX;
    8889    for (int i = 0; i < numberIntegers; i++) {
    8990        int iColumn = integerVariable[i];
     
    132133                    score *= 1000.0;
    133134
     135                // if priorities then use
     136                if (priority_) {
     137                  int thisRound=static_cast<int>(priority_[i].direction);
     138                  if ((thisRound&1)!=0)
     139                    round = ((thisRound&2)==0) ? -1 : +1;
     140                  if (priority_[i].priority>bestPriority) {
     141                    score=COIN_DBL_MAX;
     142                  } else if (priority_[i].priority<bestPriority) {
     143                    bestPriority=static_cast<int>(priority_[i].priority);
     144                    bestScore=COIN_DBL_MAX;
     145                  }
     146                }
    134147                if (score > bestScore) {
    135148                    bestColumn = iColumn;
     
    198211    const int * integerVariable = model_->integerVariable();
    199212    const double* reducedCost = solver->getReducedCost();
     213    bool fixGeneralIntegers = (switches_&65536)!=0;
    200214    // fix other integer variables that are at their bounds
    201215    int cnt = 0;
     
    215229                candidate[cnt++].pseudoRedCost = CoinMax(-1.0e-2 * reducedCost[iColumn],
    216230                                                 downArray_[i]) * random[i];
     231            } else if (fixGeneralIntegers &&
     232                       fabs(floor(value + 0.5) - value) <= integerTolerance) {
     233                candidate[cnt].var = iColumn;
     234                candidate[cnt++].pseudoRedCost = CoinMax(-1.0e-6 * reducedCost[iColumn],
     235                                                 1.0e-4*downArray_[i]) * random[i];
    217236            }
    218237        } else {
  • trunk/Cbc/src/CbcHeuristicDiveVectorLength.cpp

    r1899 r2093  
    8282    double bestScore = COIN_DBL_MAX;
    8383    bool allTriviallyRoundableSoFar = true;
     84    int bestPriority = COIN_INT_MAX;
    8485    for (int i = 0; i < numberIntegers; i++) {
    8586        int iColumn = integerVariable[i];
     
    9798                // the variable cannot be rounded
    9899                double obj = direction * objective[iColumn];
    99                 if (obj >= 0.0)
     100                if (obj > smallObjective_) {
    100101                    round = 1; // round up
    101                 else
     102                } else if (obj < -smallObjective_) {
    102103                    round = -1; // round down
     104                } else {
     105                  if (fraction<0.4)
     106                    round = -1;
     107                  else
     108                    round = 1;
     109                }
    103110                double objDelta;
    104111                if (round == 1)
    105                     objDelta = (1.0 - fraction) * obj;
     112                    objDelta = (1.0 - fraction) * CoinMax(obj,smallObjective_);
    106113                else
    107                     objDelta = - fraction * obj;
     114                    objDelta = - fraction * CoinMin(obj,-smallObjective_);
    108115
    109116                // we want the smaller score
     
    114121                    score *= 1000.0;
    115122
     123                // if priorities then use
     124                if (priority_) {
     125                  int thisRound=static_cast<int>(priority_[i].direction);
     126                  if ((thisRound&1)!=0)
     127                    round = ((thisRound&2)==0) ? -1 : +1;
     128                  if (priority_[i].priority>bestPriority) {
     129                    score=COIN_DBL_MAX;
     130                  } else if (priority_[i].priority<bestPriority) {
     131                    bestPriority=static_cast<int>(priority_[i].priority);
     132                    bestScore=COIN_DBL_MAX;
     133                  }
     134                }
    116135                if (score < bestScore) {
    117136                    bestColumn = iColumn;
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r2072 r2093  
    273273            good = false;
    274274        }
    275         if (passNumber != 1 && !good)
     275        if (passNumber > 1 && !good)
    276276            return 0;
    277277    } else {
    278         if (passNumber != 1)
     278        if (passNumber > 1)
    279279            return 0;
    280280    }
  • trunk/Cbc/src/CbcHeuristicGreedy.cpp

    r1886 r2093  
    121121    bool atRoot = model_->getNodeCount() == 0;
    122122    int passNumber = model_->getCurrentPassNumber();
    123     if (atRoot && passNumber != 1)
     123    if (atRoot && passNumber > 1)
    124124        return 0;
    125125    OsiSolverInterface * solver = model_->solver();
     
    537537    bool atRoot = model_->getNodeCount() == 0;
    538538    int passNumber = model_->getCurrentPassNumber();
    539     if (atRoot && passNumber != 1)
     539    if (atRoot && passNumber > 1)
    540540        return 0;
    541541    OsiSolverInterface * solver = model_->solver();
     
    973973    bool atRoot = model_->getNodeCount() == 0;
    974974    int passNumber = model_->getCurrentPassNumber();
    975     if (atRoot && passNumber != 1)
     975    if (atRoot && passNumber > 1)
    976976        return 0;
    977977    OsiSolverInterface * solver = model_->solver();
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r1943 r2093  
    12921292    bool atRoot = model_->getNodeCount() == 0;
    12931293    int passNumber = model_->getCurrentPassNumber();
    1294     if (!when() || (when() == 1 && model_->phase() != 1) || !atRoot || passNumber != 1)
     1294    if (!when() || (when() == 1 && model_->phase() != 1) || !atRoot || passNumber > 1)
    12951295        return 0; // switched off
    12961296    // Don't do if it was this heuristic which found solution!
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r1943 r2093  
    198198        numberNodes = howOften_;
    199199    }
    200     if ((numberNodes % howOften_) == 0 && (model_->getCurrentPassNumber() == 1 ||
     200    if ((numberNodes % howOften_) == 0 && (model_->getCurrentPassNumber() <= 1 ||
    201201                                           model_->getCurrentPassNumber() == 999999)) {
    202202        lastNode_ = model_->getNodeCount();
  • trunk/Cbc/src/CbcHeuristicRandRound.cpp

    r1899 r2093  
    108108    int passNumber = model_->getCurrentPassNumber();
    109109    //    Just do once
    110     if (!atRoot || passNumber != 1) {
     110    if (!atRoot || passNumber > 1) {
    111111        // std::cout << "Leaving the Randomized Rounding Heuristic" << std::endl;
    112112        return 0;
  • trunk/Cbc/src/CbcHeuristicVND.cpp

    r1899 r2093  
    199199            numberNodes = howOften_;
    200200    }
    201     if ((numberNodes % howOften_) == 0 && (model_->getCurrentPassNumber() == 1 ||
     201    if ((numberNodes % howOften_) == 0 && (model_->getCurrentPassNumber() <= 1 ||
    202202                                           model_->getCurrentPassNumber() == 999999)) {
    203203        lastNode_ = model_->getNodeCount();
  • trunk/Cbc/src/CbcSolver.cpp

    r2092 r2093  
    18361836            int iParam;
    18371837            iParam = whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_);
    1838             parameters_[iParam].setIntValue(3);
     1838            parameters_[iParam].setIntValue(2);
    18391839            iParam = whichParam(CBC_PARAM_INT_FPUMPITS, numberParameters_, parameters_);
    18401840            parameters_[iParam].setIntValue(30);
     
    32193219                              model_.flipModel();
    32203220                            //if we do then - fix priorities in clonebutmodel_.convertToDynamic();
     3221                            bool objectsExist = model_.objects() != NULL;
     3222                            if (!objectsExist) {
     3223                              model_.findIntegers(false);
     3224                              model_.convertToDynamic();
     3225                            }
     3226                            // set priorities etc
     3227                            if (priorities) {
     3228                              OsiObject ** objects = model_.objects();
     3229                              int numberObjects = model_.numberObjects();
     3230                              for (int iObj = 0; iObj < numberObjects; iObj++) {
     3231                                CbcSimpleInteger * obj =
     3232                                  dynamic_cast <CbcSimpleInteger *>(objects[iObj]) ;
     3233                                if (!obj)
     3234                                  continue;
     3235                                int iColumn = obj->columnNumber();
     3236                                if (branchDirection) {
     3237                                  obj->setPreferredWay(branchDirection[iColumn]);
     3238                                }
     3239                                if (priorities) {
     3240                                  int iPriority = priorities[iColumn];
     3241                                  if (iPriority > 0)
     3242                                    obj->setPriority(iPriority);
     3243                                }
     3244                                if (pseudoUp && pseudoUp[iColumn]) {
     3245                                  CbcSimpleIntegerPseudoCost * obj1a =
     3246                                    dynamic_cast <CbcSimpleIntegerPseudoCost *>(objects[iObj]) ;
     3247                                  assert (obj1a);
     3248                                  if (pseudoDown[iColumn] > 0.0)
     3249                                    obj1a->setDownPseudoCost(pseudoDown[iColumn]);
     3250                                  if (pseudoUp[iColumn] > 0.0)
     3251                                    obj1a->setUpPseudoCost(pseudoUp[iColumn]);
     3252                                }
     3253                              }
     3254                            }
    32213255                            doHeuristics(&model_, 2, parameters_,
    32223256                                         numberParameters_, noPrinting_, initialPumpTune);
     3257                            if (!objectsExist) {
     3258                              model_.deleteObjects(false);
     3259                            }
    32233260                            if (needFlip)
    32243261                              model_.flipModel();
     
    79748011                                int got[] = { -1, -1, -1, -1, -1, -1, -1, -1};
    79758012                                int order[8];
     8013                                bool useMasks = false;
     8014                                if (strstr(fileName.c_str(),"mask_")) {
     8015                                  // look more closely
     8016                                  const char * name = fileName.c_str();
     8017                                  int length = strlen(name);
     8018                                  for (int i=length-1;i>=0;i--) {
     8019                                    if (name[i]==dirsep) {
     8020                                      name += i+1;
     8021                                      break;
     8022                                    }
     8023                                  }
     8024                                  useMasks = !strncmp(name,"mask_",5);
     8025                                }
    79768026                                assert(sizeof(got) == sizeof(order));
    79778027                                int nAcross = 0;
     
    80408090                                    if (good) {
    80418091                                        char ** columnNames = new char * [numberColumns];
    8042                                         pseudoDown = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
    8043                                         pseudoUp = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
    8044                                         branchDirection = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
     8092                                        //pseudoDown = NULL;
     8093                                        //pseudoUp = NULL;
     8094                                        //branchDirection = NULL;
     8095                                        //if (got[5]!=-1)
     8096                                          pseudoDown = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
     8097                                          //if (got[4]!=-1)
     8098                                          pseudoUp = reinterpret_cast<double *> (malloc(numberColumns * sizeof(double)));
     8099                                          //if (got[2]!=-1)
     8100                                          branchDirection = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
    80458101                                        priorities = reinterpret_cast<int *> (malloc(numberColumns * sizeof(int)));
    80468102                                        free(solutionIn);
     
    80628118                                            columnNames[iColumn] =
    80638119                                                CoinStrdup(lpSolver->columnName(iColumn).c_str());
    8064                                             pseudoDown[iColumn] = 0.0;
    8065                                             pseudoUp[iColumn] = 0.0;
    8066                                             branchDirection[iColumn] = 0;
    8067                                             priorities[iColumn] = 0;
     8120                                            //if (got[5]!=-1)
     8121                                              pseudoDown[iColumn] = 0.0;
     8122                                              //if (got[4]!=-1)
     8123                                              pseudoUp[iColumn] = 0.0;
     8124                                              //if (got[2]!=-1)
     8125                                              branchDirection[iColumn] = 0;
     8126                                            priorities[iColumn] = useMasks ? -123456789 : 0;
    80688127                                        }
    80698128                                        int nBadPseudo = 0;
     
    80738132                                        int nBadLine = 0;
    80748133                                        int nLine = 0;
    8075                                         while (fgets(line, 1000, fp)) {
     8134                                        iColumn = -1;
     8135                                        int lowestPriority=-COIN_INT_MAX;
     8136                                        while (iColumn>=0 || fgets(line, 1000, fp)) {
    80768137                                            if (!strncmp(line, "ENDATA", 6))
    80778138                                                break;
    80788139                                            nLine++;
    8079                                             iColumn = -1;
     8140                                            if (!useMasks)
     8141                                              iColumn = -1;
    80808142                                            double up = 0.0;
    80818143                                            double down = 0.0;
     
    81158177                                                    // name
    81168178                                                case 0:
    8117                                                     for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     8179                                                  iColumn++;
     8180                                                  for (; iColumn < numberColumns; iColumn++) {
     8181                                                      if (priorities[iColumn]!=-123456789) {
    81188182                                                        if (!strcmp(columnNames[iColumn], pos))
    81198183                                                            break;
     8184                                                      } else {
     8185                                                        // mask (at present ? and trailing *)
     8186                                                        const char * name = columnNames[iColumn];
     8187                                                        int length=strlen(name);
     8188                                                        int lengthMask=strlen(pos);
     8189                                                        bool asterisk = pos[lengthMask-1]=='*';
     8190                                                        if (asterisk)
     8191                                                          length=lengthMask-1;
     8192                                                        int i;
     8193                                                        for (i=0;i<length;i++) {
     8194                                                          if (name[i]!=pos[i]) {
     8195                                                            if (pos[i]!='?')
     8196                                                              break;
     8197                                                          }
     8198                                                        }
     8199                                                        if (i==length)
     8200                                                          break;
     8201                                                      }
    81208202                                                    }
    81218203                                                    if (iColumn == numberColumns)
     
    81488230                                                case 3:
    81498231                                                    pri = atoi(pos);
     8232                                                    lowestPriority=CoinMax(lowestPriority,pri);
    81508233                                                    break;
    81518234                                                    // up
     
    81928275                                                    pri = 0;
    81938276                                                }
    8194                                                 pseudoDown[iColumn] = down;
    8195                                                 pseudoUp[iColumn] = up;
    8196                                                 branchDirection[iColumn] = dir;
     8277                                                //if (got[5]!=-1)
     8278                                                  pseudoDown[iColumn] = down;
     8279                                                  //if (got[4]!=-1)
     8280                                                  pseudoUp[iColumn] = up;
     8281                                                  //if (got[2]!=-1)
     8282                                                  branchDirection[iColumn] = dir;
    81978283                                                priorities[iColumn] = pri;
    81988284                                                if (solValue != COIN_DBL_MAX) {
     
    82048290                                                    prioritiesIn[iColumn] = priValue;
    82058291                                                }
    8206                                             } else {
     8292                                            } else if (!useMasks) {
    82078293                                                nBadName++;
    82088294                                            }
     8295                                        }
     8296                                        for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     8297                                          if (priorities[iColumn] == -123456789)
     8298                                            priorities[iColumn] = lowestPriority+1;
    82098299                                        }
    82108300                                        if (!noPrinting_) {
  • trunk/Cbc/src/CbcSolverHeuristics.cpp

    r2092 r2093  
    14671467
    14681468    if (useDIVING > 0) {
    1469         int majorIterations=64;
     1469        int majorIterations=parameters_[whichParam(CBC_PARAM_INT_DIVEOPTSOLVES, numberParameters_, parameters_)].intValue();
    14701470        int diveOptions2 = parameters_[whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_)].intValue();
    14711471        int diveOptions;
     
    14951495            heuristicDV.setHeuristicName("DiveVectorLength");
    14961496            heuristicDV.setWhen(diveOptionsNotC);
     1497            heuristicDV.setMaxIterations(majorIterations);
    14971498            if (diveOptions2) {
    1498               heuristicDV.setMaxIterations(majorIterations);
    14991499              heuristicDV.setPercentageToFix(0.0);
    15001500              heuristicDV.setMaxSimplexIterations(COIN_INT_MAX);
     
    15071507            heuristicDG.setHeuristicName("DiveGuided");
    15081508            heuristicDG.setWhen(diveOptionsNotC);
     1509            heuristicDG.setMaxIterations(majorIterations);
    15091510            if (diveOptions2) {
    1510               heuristicDG.setMaxIterations(majorIterations);
    15111511              heuristicDG.setPercentageToFix(0.0);
    15121512              heuristicDG.setMaxSimplexIterations(COIN_INT_MAX);
     
    15191519            heuristicDF.setHeuristicName("DiveFractional");
    15201520            heuristicDF.setWhen(diveOptionsNotC);
     1521            heuristicDF.setMaxIterations(majorIterations);
    15211522            if (diveOptions2) {
    1522               heuristicDF.setMaxIterations(majorIterations);
    15231523              heuristicDF.setPercentageToFix(0.0);
    15241524              heuristicDF.setMaxSimplexIterations(COIN_INT_MAX);
     
    15311531            heuristicDC.setHeuristicName("DiveCoefficient");
    15321532            heuristicDC.setWhen(diveOptions);
     1533            heuristicDC.setMaxIterations(majorIterations);
    15331534            if (diveOptions2) {
    1534               heuristicDC.setMaxIterations(majorIterations);
    15351535              heuristicDC.setPercentageToFix(0.0);
    15361536              heuristicDC.setMaxSimplexIterations(COIN_INT_MAX);
     
    15431543            heuristicDL.setHeuristicName("DiveLineSearch");
    15441544            heuristicDL.setWhen(diveOptionsNotC);
     1545            heuristicDL.setMaxIterations(majorIterations);
    15451546            if (diveOptions2) {
    1546               heuristicDL.setMaxIterations(majorIterations);
    15471547              heuristicDL.setPercentageToFix(0.0);
    15481548              heuristicDL.setMaxSimplexIterations(COIN_INT_MAX);
     
    15551555            heuristicDP.setHeuristicName("DivePseudoCost");
    15561556            heuristicDP.setWhen(diveOptionsNotC /*+ diveOptions2*/);
     1557            heuristicDP.setMaxIterations(majorIterations);
    15571558            if (diveOptions2) {
    1558               heuristicDP.setMaxIterations(majorIterations);
    15591559              heuristicDP.setPercentageToFix(0.0);
    15601560              heuristicDP.setMaxSimplexIterations(COIN_INT_MAX);
Note: See TracChangeset for help on using the changeset viewer.