Changeset 1132


Ignore:
Timestamp:
Mar 16, 2009 6:30:25 AM (10 years ago)
Author:
forrest
Message:

chnages to try and make faster

Location:
trunk/Cbc/src
Files:
24 edited

Legend:

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

    r1121 r1132  
    44714471  : CbcGeneral(),
    44724472    maximumDepth_(0),
     4473    maximumNodes_(0),
    44734474    whichSolution_(-1),
    44744475    numberNodes_(0),
     
    44814482  : CbcGeneral(model),
    44824483    maximumDepth_(maximumDepth),
     4484    maximumNodes_(0),
    44834485    whichSolution_(-1),
    44844486    numberNodes_(0),
    44854487    nodeInfo_(NULL)
    44864488{
    4487   int nNodes = maximumNodes();
    4488   if (nNodes) {
     4489  assert(maximumDepth_<1000000);
     4490  if (maximumDepth_>0)
     4491    maximumNodes_ = (1<<maximumDepth_)+1+maximumDepth_;
     4492  else if (maximumDepth_<0)
     4493    maximumNodes_ = 1+1-maximumDepth_;
     4494  else
     4495    maximumNodes_ = 0;
     4496#define MAX_NODES 100
     4497  maximumNodes_ = CoinMin(maximumNodes_,1+maximumDepth_+MAX_NODES);
     4498  if (maximumNodes_) {
    44894499    nodeInfo_ = new ClpNodeStuff();
     4500    nodeInfo_->maximumNodes_=maximumNodes_;
    44904501    ClpNodeStuff * info = nodeInfo_;
    44914502    // for reduced costs and duals
     
    44974508      info->solverOptions_ |= 32;
    44984509    }
    4499     ClpNode ** nodeInfo = new ClpNode * [nNodes];
    4500     for (int i=0;i<nNodes;i++)
     4510    ClpNode ** nodeInfo = new ClpNode * [maximumNodes_];
     4511    for (int i=0;i<maximumNodes_;i++)
    45014512      nodeInfo[i]=NULL;
    45024513    info->nodeInfo_ = nodeInfo;
     
    45114522{
    45124523  maximumDepth_ = rhs.maximumDepth_;
     4524  maximumNodes_ = rhs.maximumNodes_;
    45134525  whichSolution_ = -1;
    45144526  numberNodes_ = 0;
    4515   int nNodes = maximumNodes();
    4516   if (nNodes) {
     4527  if (maximumNodes_) {
    45174528    assert (rhs.nodeInfo_);
    45184529    nodeInfo_ = new ClpNodeStuff(*rhs.nodeInfo_);
     4530    nodeInfo_->maximumNodes_=maximumNodes_;
    45194531    ClpNodeStuff * info = nodeInfo_;
    45204532    if (maximumDepth_>0) {
     
    45254537    }
    45264538    if (!info->nodeInfo_) {
    4527       ClpNode ** nodeInfo = new ClpNode * [nNodes];
    4528       for (int i=0;i<nNodes;i++)
     4539      ClpNode ** nodeInfo = new ClpNode * [maximumNodes_];
     4540      for (int i=0;i<maximumNodes_;i++)
    45294541        nodeInfo[i]=NULL;
    45304542      info->nodeInfo_ = nodeInfo;
     
    45504562    delete nodeInfo_;
    45514563    maximumDepth_ = rhs.maximumDepth_;
     4564    maximumNodes_ = rhs.maximumNodes_;
    45524565    whichSolution_ = -1;
    45534566    numberNodes_ = 0;
     
    45554568      assert (rhs.nodeInfo_);
    45564569      nodeInfo_ = new ClpNodeStuff(*rhs.nodeInfo_);
     4570      nodeInfo_->maximumNodes_=maximumNodes_;
    45574571    } else {
    45584572      nodeInfo_ = NULL;
     
    45674581  delete nodeInfo_;
    45684582}
    4569 // Return maximum number of nodes
    4570 int
    4571 CbcGeneralDepth::maximumNodes() const
    4572 {
    4573   int n;
    4574   if (maximumDepth_>0)
    4575     n = (1<<maximumDepth_)+1+maximumDepth_;
    4576   else if (maximumDepth_<0)
    4577     n = 1+1-maximumDepth_;
    4578   else
    4579     n = 0;
    4580   return n;
    4581 }
    4582 
    45834583// Infeasibility - large is 0.5
    45844584double
     
    46264626      clpSolver->setBasis();
    46274627      whichSolution_ = simplex->fathomMany(info);
     4628      //printf("FAT %d nodes, %d iterations\n",
     4629      //info->numberNodesExplored_,info->numberIterations_);
     4630      //printf("CbcBranch %d rows, %d columns\n",clpSolver->getNumRows(),
     4631      //     clpSolver->getNumCols());
    46284632      model_->incrementExtra(info->numberNodesExplored_,
    46294633                             info->numberIterations_);
     
    48914895{
    48924896  double cutoff=model_->getCutoff();
     4897  //printf("GenB %x whichNode %d numberLeft %d which %d\n",
     4898  // this,whichNode_,numberBranchesLeft(),branchIndex());
    48934899  if (whichNode_<0) {
    48944900    assert (node_);
     
    49324938    OsiSolverInterface * solver = model_->solver();
    49334939    thisProb->apply(solver);
    4934     OsiClpSolverInterface * clpSolver
    4935       = dynamic_cast<OsiClpSolverInterface *> (solver);
    4936     assert (clpSolver);
     4940    //OsiClpSolverInterface * clpSolver
     4941    //= dynamic_cast<OsiClpSolverInterface *> (solver);
     4942    //assert (clpSolver);
    49374943    // Move status to basis
    4938     clpSolver->setWarmStart(NULL);
     4944    //clpSolver->setWarmStart(NULL);
    49394945  }
    49404946  return 0.0;
     
    51925198  // Current basis
    51935199  status_ = clpSolver->getBasis(status);
     5200  assert (status_->fullBasis());
     5201  //status_->print();
    51945202}
    51955203
  • trunk/Cbc/src/CbcBranchActual.hpp

    r1121 r1132  
    15141514  virtual CbcBranchingObject * createBranch(int way) ;
    15151515  /// Return maximum number of nodes
    1516   int maximumNodes() const;
     1516  inline int maximumNodes() const
     1517  { return maximumNodes_;}
    15171518  /// Get maximum depth
    15181519  inline int maximumDepth() const
     
    15351536  /// Maximum depth
    15361537  int maximumDepth_;
     1538  /// Maximum nodes
     1539  int maximumNodes_;
    15371540  /// Which node has solution (or -1)
    15381541  mutable int whichSolution_;
  • trunk/Cbc/src/CbcBranchDynamic.cpp

    r1130 r1132  
    17831783  double value=0.0;
    17841784  if (!bestObject_) {
    1785     bestCriterion_=-1.0;
     1785    bestCriterion_=-1.0e30;
    17861786    bestNumberUp_=COIN_INT_MAX;
    17871787    bestNumberDown_=COIN_INT_MAX;
     
    17891789  // maybe branch up more if no solution or not many nodes done?
    17901790  if (stateOfSearch<=2) {
    1791 //#define TRY_STUFF 1
     1791    //#define TRY_STUFF 1
    17921792#ifdef TRY_STUFF
    17931793    // before solution - choose smallest number
     
    18501850    changeDown += perInf * numInfDown;
    18511851    changeUp += perInf * numInfUp;
     1852#if 0
     1853    if (numInfDown==1) {
     1854      if (numInfUp==1) {
     1855        changeUp += 1.0e6;
     1856        changeDown += 1.0e6;
     1857      } else if (changeDown<=1.5*changeUp) {
     1858        changeUp += 1.0e6;
     1859      }
     1860    } else if (numInfUp==1&&changeUp<=1.5*changeDown) {
     1861      changeDown += 1.0e6;
     1862    }
     1863#endif
    18521864#endif
    18531865    double minValue = CoinMin(changeDown,changeUp);
  • trunk/Cbc/src/CbcCompareActual.cpp

    r1121 r1132  
    142142    weight_(-1.0),
    143143    saveWeight_(0.0),
     144    cutoff_(COIN_DBL_MAX),
     145    bestPossible_(-COIN_DBL_MAX),
    144146    numberSolutions_(0),
    145147    treeSize_(0),
     
    154156    weight_(weight) ,
    155157    saveWeight_(0.0),
     158    cutoff_(COIN_DBL_MAX),
     159    bestPossible_(-COIN_DBL_MAX),
    156160    numberSolutions_(0),
    157161    treeSize_(0),
     
    169173  weight_=rhs.weight_;
    170174  saveWeight_ = rhs.saveWeight_;
     175  cutoff_ = rhs.cutoff_;
     176  bestPossible_ = rhs.bestPossible_;
    171177  numberSolutions_=rhs.numberSolutions_;
    172178  treeSize_ = rhs.treeSize_;
     
    189195    weight_=rhs.weight_;
    190196    saveWeight_ = rhs.saveWeight_;
     197    cutoff_ = rhs.cutoff_;
     198    bestPossible_ = rhs.bestPossible_;
    191199    numberSolutions_=rhs.numberSolutions_;
    192200    treeSize_ = rhs.treeSize_;
     
    244252  }
    245253#else
     254  //weight_=0.0;
    246255  if ((weight_==-1.0&&(y->depth()>breadthDepth_&&x->depth()>breadthDepth_))||weight_==-3.0||weight_==-2.0) {
    247256    int adjust =  (weight_==-3.0) ? 10000 : 0;
     
    280289    }
    281290    // after solution
     291    assert (cutoff_<1.0e40);
     292#define THRESH2 0.999
     293#define TRY_THIS 0
     294#if TRY_THIS==0
    282295    double weight = CoinMax(weight_,0.0);
    283296    double testX =  x->objectiveValue()+ weight*x->numberUnsatisfied();
    284297    double testY = y->objectiveValue() + weight*y->numberUnsatisfied();
    285     if (testX!=testY)
     298#elif TRY_THIS==1
     299    /* compute what weight would have to be to hit target
     300       then reverse sign as large weight good */
     301    double target = (1.0-THRESH2)*bestPossible_ + THRESH2*cutoff_;
     302    double weight;
     303    weight = (target-x->objectiveValue())/
     304      static_cast<double>(x->numberUnsatisfied());
     305    double testX = - weight;
     306    weight = (target-y->objectiveValue())/
     307      static_cast<double>(y->numberUnsatisfied());
     308    double testY = - weight;
     309#elif TRY_THIS==2
     310    // Use estimates
     311    double testX = x->guessedObjectiveValue();
     312    double testY = y->guessedObjectiveValue();
     313#elif THY_THIS==3
     314#define THRESH 0.95
     315    if (x->objectiveValue()-bestPossible_>THRESH*(cutoff_-bestPossible_))
     316      testX *= 2.0; // make worse
     317    if (y->objectiveValue()-bestPossible_>THRESH*(cutoff_-bestPossible_))
     318      testY *= 2.0; // make worse
     319#endif
     320    if (testX!=testY)
    286321      return testX > testY;
    287322    else
     
    309344  if (numberSolutions_>5)
    310345    weight_ =0.0; // this searches on objective
     346  cutoff_ = model->getCutoff();
    311347}
    312348// This allows method to change behavior
  • trunk/Cbc/src/CbcCompareActual.hpp

    r930 r1132  
    104104  inline void setWeight(double weight)
    105105  { weight_ = weight;}
     106  /// Cutoff
     107  inline double getCutoff() const
     108  { return cutoff_;}
     109  inline void setCutoff(double cutoff)
     110  { cutoff_ = cutoff;}
     111  /// Best possible solution
     112  inline double getBestPossible() const
     113  { return bestPossible_;}
     114  inline void setBestPossible(double bestPossible)
     115  { bestPossible_ = bestPossible;}
    106116  // Depth above which want to explore first
    107117  inline void setBreadthDepth(int value)
     
    112122  // Weight for each infeasibility - computed from solution
    113123  double saveWeight_;
     124  /// Cutoff
     125  double cutoff_;
     126  /// Best possible solution
     127  double bestPossible_;
    114128  // Number of solutions
    115129  int numberSolutions_;
  • trunk/Cbc/src/CbcCutGenerator.cpp

    r1121 r1132  
    4141    timing_(false),
    4242    timeInCutGenerator_(0.0),
     43    inaccuracy_(0),
    4344    numberTimes_(0),
    4445    numberCuts_(0),
     
    6465    timing_(false),
    6566    timeInCutGenerator_(0.0),
     67    inaccuracy_(0),
    6668    numberTimes_(0),
    6769    numberCuts_(0),
     
    110112  timing_ = rhs.timing_;
    111113  timeInCutGenerator_ = rhs.timeInCutGenerator_;
     114  inaccuracy_ = rhs.inaccuracy_;
    112115  numberTimes_ = rhs.numberTimes_;
    113116  numberCuts_ = rhs.numberCuts_;
     
    142145    timing_ = rhs.timing_;
    143146    timeInCutGenerator_ = rhs.timeInCutGenerator_;
     147    inaccuracy_ = rhs.inaccuracy_;
    144148    numberTimes_ = rhs.numberTimes_;
    145149    numberCuts_ = rhs.numberCuts_;
     
    566570      //     nCuts,nEls);
    567571      int nElsNow = solver->getMatrixByCol()->getNumElements();
    568       int nAdd = model_->parentModel() ? 200 : 10000;
    569572      int numberColumns = solver->getNumCols();
    570       int nAdd2 = model_->parentModel() ? 2*numberColumns : 5*numberColumns;
     573      int numberRows = solver->getNumRows();
     574      //double averagePerRow = static_cast<double>(nElsNow)/
     575      //static_cast<double>(numberRows);
     576      int nAdd;
     577      int nAdd2;
     578      int nReasonable;
     579      if (!model_->parentModel()&&depth<2) {
     580        if (inaccuracy_<3) {
     581          nAdd=10000;
     582          if (pass>0&&numberColumns>-500)
     583            nAdd = CoinMin(nAdd,nElsNow+2*numberRows);
     584        } else {
     585          nAdd=10000;
     586          if (pass>0)
     587            nAdd = CoinMin(nAdd,nElsNow+2*numberRows);
     588        }
     589        nAdd2 = 5*numberColumns;
     590        nReasonable = CoinMax(nAdd2,nElsNow/8+nAdd);
     591      } else {
     592        nAdd = 200;
     593        nAdd2 = 2*numberColumns;
     594        nReasonable = CoinMax(nAdd2,nElsNow/8+nAdd);
     595      }
     596      //#define UNS_WEIGHT 0.1
     597#ifdef UNS_WEIGHT
     598      const double * colLower = solver->getColLower();
     599      const double * colUpper = solver->getColUpper();
     600#endif
    571601      if (/*nEls>CoinMax(nAdd2,nElsNow/8+nAdd)*/nCuts&&feasible) {
    572602        //printf("need to remove cuts\n");
    573603        // just add most effective
    574         int nReasonable = CoinMax(nAdd2,nElsNow/8+nAdd);
    575604        int nDelete = nEls - nReasonable;
    576605       
     
    589618            const double * element = thisCut->row().getElements();
    590619            assert (n);
    591             double norm=0.0;
     620#ifdef UNS_WEIGHT
     621            double normU=0.0;
     622            double norm=1.0e-3;
     623            int nU=0;
     624            for (int i=0;i<n;i++) {
     625              double value = element[i];
     626              int iColumn = column[i];
     627              double solValue = solution[iColumn];
     628              sum += value*solValue;
     629              value *= value;
     630              norm += value;
     631              if (solValue>colLower[iColumn]+1.0e-6&&
     632                  solValue<colUpper[iColumn]-1.0e-6) {
     633                normU += value;
     634                nU++;
     635              }
     636            }
     637#if 0
     638            int nS=n-nU;
     639            if (numberColumns>20000) {
     640              if (nS>50) {
     641                double ratio = 50.0/nS;
     642                normU /= ratio;
     643              }
     644            }
     645#endif
     646            norm += UNS_WEIGHT*(normU-norm);
     647#else
     648            double norm=1.0e-3;
    592649            for (int i=0;i<n;i++) {
    593650              double value = element[i];
     
    595652              norm += value*value;
    596653            }
     654#endif
    597655            if (sum>thisCut->ub()) {
    598656              sum= sum-thisCut->ub();
     
    604662            // normalize
    605663            sum /= sqrt(norm);
     664            //sum /= pow(norm,0.3);
    606665            // adjust for length
     666            //sum /= pow(reinterpret_cast<double>(n),0.2);
    607667            //sum /= sqrt((double) n);
    608668            // randomize
  • trunk/Cbc/src/CbcCutGenerator.hpp

    r1121 r1132  
    126126  inline int howOftenInSub() const
    127127  { return whenCutGeneratorInSub_;}
     128  /// Get level of cut inaccuracy (0 means exact e.g. cliques)
     129  inline int inaccuracy() const
     130  { return inaccuracy_;}
     131  /// Set level of cut inaccuracy (0 means exact e.g. cliques)
     132  inline void setInaccuracy(int level)
     133  { inaccuracy_=level;}
    128134
    129135  /** Set the cut generation depth
     
    296302  /// Time in cut generator
    297303  double timeInCutGenerator_;
    298  
     304  /// Level of cut inaccuracy (0 means exact e.g. cliques)
     305  int inaccuracy_;
    299306  /// Number times cut generator entered
    300307  int numberTimes_;
  • trunk/Cbc/src/CbcHeuristic.cpp

    r1121 r1132  
    496496extern bool getHistoryStatistics_;
    497497#endif
     498static double sizeRatio(int numberRowsNow,int numberColumnsNow,
     499                        int numberRowsStart,int numberColumnsStart)
     500{
     501  double valueNow;
     502  if (numberRowsNow*10>numberColumnsNow||numberColumnsNow<200) {
     503    valueNow = 2*numberRowsNow+numberColumnsNow;
     504  } else {
     505    // long and thin - rows are more important
     506    if (numberRowsNow*40>numberColumnsNow)
     507      valueNow = 10*numberRowsNow+numberColumnsNow;
     508    else
     509      valueNow = 200*numberRowsNow+numberColumnsNow;
     510  }
     511  double valueStart;
     512  if (numberRowsStart*10>numberColumnsStart||numberColumnsStart<200) {
     513    valueStart = 2*numberRowsStart+numberColumnsStart;
     514  } else {
     515    // long and thin - rows are more important
     516    if (numberRowsStart*40>numberColumnsStart)
     517      valueStart = 10*numberRowsStart+numberColumnsStart;
     518    else
     519      valueStart = 200*numberRowsStart+numberColumnsStart;
     520  }
     521  //printf("sizeProblem Now %g, %d rows, %d columns\nsizeProblem Start %g, %d rows, %d columns\n",
     522  // valueNow,numberRowsNow,numberColumnsNow,
     523  // valueStart,numberRowsStart,numberColumnsStart);
     524  if (10*numberRowsNow<8*numberRowsStart)
     525    return valueNow/valueStart;
     526  else if (10*numberRowsNow<9*numberRowsStart)
     527    return 1.1*(valueNow/valueStart);
     528  else if (numberRowsNow<numberRowsStart)
     529    return 1.5*(valueNow/valueStart);
     530  else
     531    return 2.0*(valueNow/valueStart);
     532}
     533   
     534
    498535// Do mini branch and bound (return 1 if solution)
    499536int
     
    503540{
    504541  // size before
    505   double before = 2*solver->getNumRows()+solver->getNumCols();
     542  int shiftRows=0;
     543  if (numberNodes<0)
     544    shiftRows = solver->getNumRows()-numberNodes_;
     545  int numberRowsStart = solver->getNumRows()-shiftRows;
     546  int numberColumnsStart = solver->getNumCols();
    506547#ifdef CLP_INVESTIGATE
    507548  printf("%s has %d rows, %d columns\n",
     
    510551  // Use this fraction
    511552  double fractionSmall = fractionSmall_;
     553  double before = 2*numberRowsStart+numberColumnsStart;
    512554  if (before>40000.0) {
    513555    // fairly large - be more conservative
     
    582624#endif
    583625      delete presolvedModel;
     626      double ratio = sizeRatio(afterRows-shiftRows,afterCols,
     627                                 numberRowsStart,numberColumnsStart);
    584628      double after = 2*afterRows+afterCols;
    585       if (after>fractionSmall*before&&after>300&&numberNodes>=0) {
     629      if (ratio>fractionSmall&&after>300&&numberNodes>=0) {
    586630        // Need code to try again to compress further using used
    587631        const int * used =  model_->usedInSolution();
     
    634678            int afterCols2 = presolvedModel->getNumCols();
    635679            delete presolvedModel;
     680            double ratio = sizeRatio(afterRows2-shiftRows,afterCols2,
     681                                 numberRowsStart,numberColumnsStart);
    636682            double after = 2*afterRows2+afterCols2;
    637             if (after>fractionSmall*before&&(after>300||numberNodes<0)) {
     683            if (ratio>fractionSmall&&(after>300||numberNodes<0)) {
    638684              sprintf(generalPrint,"Full problem %d rows %d columns, reduced to %d rows %d columns - %d fixed gives %d, %d - still too large",
    639685                      solver->getNumRows(),solver->getNumCols(),
    640686                      afterRows,afterCols,nFix,afterRows2,afterCols2);
    641687              // If much too big - give up
    642               if (after>0.75*before)
     688              if (ratio>0.75)
    643689                returnCode=-1;
    644690            } else {
     
    654700          }
    655701        }
     702      } else if (ratio>fractionSmall&&after>300) {
     703        returnCode=-1;
    656704      }
    657705    } else {
     
    666714    getHistoryStatistics_=true;
    667715#endif
     716    //printf("small no good\n");
    668717    return returnCode;
    669718  }
     
    708757#endif
    709758      // see if too big
     759      double ratio = sizeRatio(solver2->getNumRows()-shiftRows,solver2->getNumCols(),
     760                                 numberRowsStart,numberColumnsStart);
    710761      double after = 2*solver2->getNumRows()+solver2->getNumCols();
    711       if (after>fractionSmall*before&&(after>300||numberNodes<0)) {
     762      if (ratio>fractionSmall&&(after>300||numberNodes<0)) {
    712763        sprintf(generalPrint,"Full problem %d rows %d columns, reduced to %d rows %d columns - too large",
    713764                solver->getNumRows(),solver->getNumCols(),
     
    717768          <<CoinMessageEol;
    718769        returnCode = -1;
     770        //printf("small no good2\n");
    719771      } else {
    720772        sprintf(generalPrint,"Full problem %d rows %d columns, reduced to %d rows %d columns",
     
    741793          model.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
    742794          // Lightweight
    743           CbcStrategyDefaultSubTree strategy(model_,true,5,1,0);
     795          CbcStrategyDefaultSubTree strategy(model_,1,5,1,0);
    744796          model.setStrategy(strategy);
    745797          model.solver()->setIntParam(OsiMaxNumIterationHotStart,10);
     
    775827          model_->solver()->getHintParam(OsiDoReducePrint,takeHint,strength);
    776828          model.solver()->setHintParam(OsiDoReducePrint,takeHint,strength);
    777           CbcStrategyDefault strategy(true,model_->numberStrong(),
     829          CbcStrategyDefault strategy(1,model_->numberStrong(),
    778830                                      model_->numberBeforeTrust());
    779831          // Set up pre-processing - no
     
    787839            model.addCutGenerator(&cuts,1,"Stored from first");
    788840          }
    789         }
    790         if (inputSolution_) {
    791           // translate and add a serendipity heuristic
    792           int numberColumns = solver2->getNumCols();
    793           const int * which = process.originalColumns();
    794           OsiSolverInterface * solver3 = solver2->clone();
    795           for (int i=0;i<numberColumns;i++) {
    796             if (solver3->isInteger(i)) {
    797               int k=which[i];
    798               double value = inputSolution_[k];
    799               solver3->setColLower(i,value);
    800               solver3->setColUpper(i,value);
    801             }
    802           }
    803           solver3->setDblParam(OsiDualObjectiveLimit,COIN_DBL_MAX);
    804           solver3->resolve();
    805           if (solver3->isProvenOptimal()) {
    806             // good
    807             CbcSerendipity heuristic(model);
    808             double value = solver3->getObjSense()*solver3->getObjValue();
    809             heuristic.setInputSolution(solver3->getColSolution(),value);
    810             model.setCutoff(value+1.0e-7*(1.0+fabs(value)));
    811             model.addHeuristic(&heuristic,"previous solution");
    812           }
    813           delete solver3;
    814841        }
    815842        // Do search
     
    844871          if (!gotPump) {
    845872            CbcHeuristicFPump heuristic4;
    846             heuristic4.setMaximumPasses(30);
     873            heuristic4.setMaximumPasses(10);
    847874            int pumpTune=feasibilityPumpOptions_;
    848875            if (pumpTune>0) {
     
    904931          }
    905932        }
     933        //printf("sol %x\n",inputSolution_);
     934        if (inputSolution_) {
     935          // translate and add a serendipity heuristic
     936          int numberColumns = solver2->getNumCols();
     937          const int * which = process.originalColumns();
     938          OsiSolverInterface * solver3 = solver2->clone();
     939          for (int i=0;i<numberColumns;i++) {
     940            if (solver3->isInteger(i)) {
     941              int k=which[i];
     942              double value = inputSolution_[k];
     943              //if (value)
     944              //printf("orig col %d now %d val %g\n",
     945              //       k,i,value);
     946              solver3->setColLower(i,value);
     947              solver3->setColUpper(i,value);
     948            }
     949          }
     950          solver3->setDblParam(OsiDualObjectiveLimit,COIN_DBL_MAX);
     951          solver3->resolve();
     952          if (!solver3->isProvenOptimal()) {
     953            // Try just setting nonzeros
     954            OsiSolverInterface * solver4 = solver2->clone();
     955            for (int i=0;i<numberColumns;i++) {
     956              if (solver4->isInteger(i)) {
     957                int k=which[i];
     958                double value = floor(inputSolution_[k]+0.5);
     959                if (value) {
     960                  solver3->setColLower(i,value);
     961                  solver3->setColUpper(i,value);
     962                }
     963              }
     964            }
     965            solver4->setDblParam(OsiDualObjectiveLimit,COIN_DBL_MAX);
     966            solver4->resolve();
     967            int nBad=-1;
     968            if (solver4->isProvenOptimal()) {
     969              nBad=0;
     970              const double * solution = solver4->getColSolution();
     971              for (int i=0;i<numberColumns;i++) {
     972                if (solver4->isInteger(i)) {
     973                  double value = floor(solution[i]+0.5);
     974                  if (fabs(value-solution[i])>1.0e-6)
     975                    nBad++;
     976                }
     977              }
     978            }
     979            if (nBad) {
     980              delete solver4;
     981            } else {
     982              delete solver3;
     983              solver3=solver4;
     984            }
     985          }
     986          if (solver3->isProvenOptimal()) {
     987            // good
     988            CbcSerendipity heuristic(model);
     989            double value = solver3->getObjSense()*solver3->getObjValue();
     990            heuristic.setInputSolution(solver3->getColSolution(),value);
     991            model.setCutoff(value+1.0e-7*(1.0+fabs(value)));
     992            model.addHeuristic(&heuristic,"Previous solution",0);
     993            //printf("added seren\n");
     994          } else {
     995#ifdef CLP_INVESTIGATE
     996            printf("NOT added seren\n");
     997#endif
     998            solver3->writeMps("bad_seren");
     999            solver->writeMps("orig_seren");
     1000          }
     1001          delete solver3;
     1002        }
    9061003        if (model_->searchStrategy()==2) {
    9071004          model.setNumberStrong(5);
     
    9151012            // Not fast stuff
    9161013            model.setFastNodeDepth(-1);
     1014          } else if (model.fastNodeDepth()>=1000000) {
     1015            // already set
     1016            model.setFastNodeDepth(model.fastNodeDepth()-1000000);
    9171017          }
     1018          model.setWhenCuts(999998);
    9181019          model.branchAndBound();
    9191020#ifdef COIN_DEVELOP
     
    9711072#endif
    9721073          process.postProcess(*model.solver());
    973           if (solver->isProvenOptimal()) {
     1074          if (solver->isProvenOptimal()&&solver->getObjValue()<cutoff) {
    9741075            // Solution now back in solver
    9751076            int numberColumns = solver->getNumCols();
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r1129 r1132  
    576576          maximumPasses_)
    577577        exitAll=true;
     578      bool exitThis=false;
    578579      if (iterationLimit<0.0) {
    579580        if (numberPasses>=maximumPasses_) {
    580581          // If going well then keep going if maximumPasses_ small
    581582          if (lastMove<numberPasses-4||lastMove==1000000)
    582             exitAll=true;
     583            exitThis=true;
    583584          if (maximumPasses_>20||numberPasses>=40)
    584             exitAll=true;
    585         }
    586       } else if (totalNumberIterations>iterationLimit&&numberPasses>15) {
     585            exitThis=true;
     586        }
     587      }
     588      if (iterationLimit>0.0&&totalNumberIterations>iterationLimit
     589          &&numberPasses>15) {
    587590          // exiting on iteration count
    588591        exitAll=true;
     
    593596      if (maximumTime_>0.0&&CoinCpuTime()>=startTime_+maximumTime_)
    594597        exitAll=true;
    595       if (exitAll)
     598      if (exitAll||exitThis)
    596599        break;
    597600      memcpy(newSolution,solution,numberColumns*sizeof(double));
  • trunk/Cbc/src/CbcHeuristicLocal.cpp

    r1103 r1132  
    574574  delete [] mark;
    575575  if (numberSolutions_>1&&swap_==1) {
     576    int i;
     577    for ( i=0;i<numberColumns;i++) {
     578      if (used_[i]>1)
     579        break;
     580    }
     581    if (i==numberColumns) {
     582      // modify used_ if just one
     583      const int * used = model_->usedInSolution();
     584      for (int i=0;i<numberColumns;i++)
     585        used_[i]= CoinMin(used[i],255);
     586    }
    576587    // try merge
    577588    int returnCode2=solutionFix( solutionValue, betterSolution,NULL);
  • trunk/Cbc/src/CbcModel.cpp

    r1130 r1132  
    10531053extern const double * debuggerSolution_Z;
    10541054extern int numberColumns_Z;
     1055#endif
     1056#ifdef COIN_HAS_CPX
     1057#include "OsiCpxSolverInterface.hpp"
    10551058#endif
    10561059void CbcModel::branchAndBound(int doStatistics)
     
    17151718  (problems which require further exploration).
    17161719*/
     1720  CbcCompareDefault * compareActual
     1721      = dynamic_cast<CbcCompareDefault *> (nodeCompare_);
     1722  if (compareActual) {
     1723    compareActual->setBestPossible(direction*solver_->getObjValue());
     1724    compareActual->setCutoff(getCutoff());
     1725    if (false&&!numberThreads_&&!parentModel_) {
     1726      printf("CbcTreeArray ? threads ? parentArray\n");
     1727      // Setup new style tree
     1728      delete tree_;
     1729      tree_ = new CbcTreeArray();
     1730    }
     1731  }
    17171732  tree_->setComparison(*nodeCompare_) ;
    17181733/*
     
    17741789*/
    17751790  numberIterations_ = 0 ;
     1791  numberSolves_ = 0 ;
    17761792  numberNodes_ = 0 ;
    17771793  numberNodes2_ = 0 ;
     
    18591875  if (eventHappened_)
    18601876    feasible=false;
     1877#if defined(COIN_HAS_CLP)&&defined(COIN_HAS_CPX)
     1878  if (feasible&&(specialOptions_&16384)!=0&&fastNodeDepth_==-2&&!parentModel_) {
     1879    // Use Cplex to do search!
     1880    double time1 = CoinCpuTime();
     1881    OsiClpSolverInterface * clpSolver
     1882      = dynamic_cast<OsiClpSolverInterface *> (solver_);
     1883    OsiCpxSolverInterface cpxSolver;
     1884    double direction = clpSolver->getObjSense();
     1885    cpxSolver.setObjSense(direction);
     1886    // load up cplex
     1887    const CoinPackedMatrix * matrix = continuousSolver_->getMatrixByCol();
     1888    const double * rowLower = continuousSolver_->getRowLower();
     1889    const double * rowUpper = continuousSolver_->getRowUpper();
     1890    const double * columnLower = continuousSolver_->getColLower();
     1891    const double * columnUpper = continuousSolver_->getColUpper();
     1892    const double * objective = continuousSolver_->getObjCoefficients();
     1893    cpxSolver.loadProblem(*matrix,columnLower,columnUpper,
     1894                          objective, rowLower,rowUpper);
     1895    double * setSol = new double [numberIntegers_];
     1896    int * setVar = new int [numberIntegers_];
     1897    // cplex doesn't know about objective offset
     1898    double offset = clpSolver->getModelPtr()->objectiveOffset();
     1899    for (int i=0;i<numberIntegers_;i++) {
     1900      int iColumn = integerVariable_[i];
     1901      cpxSolver.setInteger(iColumn);
     1902      if (bestSolution_) {
     1903        setSol[i]=bestSolution_[iColumn];
     1904        setVar[i]=iColumn;
     1905      }
     1906    }
     1907    CPXENVptr env = cpxSolver.getEnvironmentPtr();
     1908    CPXLPptr lpPtr = cpxSolver.getLpPtr(OsiCpxSolverInterface::KEEPCACHED_ALL);
     1909    cpxSolver.switchToMIP();
     1910    if (bestSolution_) {
     1911      CPXcopymipstart(env,lpPtr,numberIntegers_,setVar,setSol);
     1912    }
     1913    if (clpSolver->getNumRows()>continuousSolver_->getNumRows()&&false) {
     1914      // add cuts
     1915      const CoinPackedMatrix * matrix = clpSolver->getMatrixByRow();
     1916      const double * rhs = clpSolver->getRightHandSide();
     1917      const char * rowSense = clpSolver->getRowSense();
     1918      const double * elementByRow = matrix->getElements();
     1919      const int * column = matrix->getIndices();
     1920      const CoinBigIndex * rowStart = matrix->getVectorStarts();
     1921      const int * rowLength = matrix->getVectorLengths();
     1922      int nStart = continuousSolver_->getNumRows();
     1923      int nRows = clpSolver->getNumRows();
     1924      int size = rowStart[nRows-1]+rowLength[nRows-1]-
     1925        rowStart[nStart];
     1926      int nAdd=0;
     1927      double * rmatval = new double [size];
     1928      int * rmatind = new int [size];
     1929      int * rmatbeg = new int [nRows-nStart+1];
     1930      size=0;
     1931      rmatbeg[0]=0;
     1932      for (int i=nStart;i<nRows;i++) {
     1933        for (int k=rowStart[i];k<rowStart[i]+rowLength[i];k++) {
     1934          rmatind[size] = column[k];
     1935          rmatval[size++] = elementByRow[k];
     1936        }
     1937        nAdd++;
     1938        rmatbeg[nAdd]=size;
     1939      }
     1940      CPXaddlazyconstraints(env, lpPtr, nAdd, size,
     1941                            rhs, rowSense, rmatbeg,
     1942                            rmatind, rmatval, NULL);
     1943      CPXsetintparam( env, CPX_PARAM_REDUCE,
     1944                      // CPX_PREREDUCE_NOPRIMALORDUAL (0)
     1945                      CPX_PREREDUCE_PRIMALONLY);
     1946    }
     1947    if (getCutoff()<1.0e50) {
     1948      double useCutoff = getCutoff()+offset;
     1949      if (bestObjective_<1.0e50)
     1950        useCutoff = bestObjective_+offset+1.0e-7;
     1951      cpxSolver.setDblParam(OsiDualObjectiveLimit,useCutoff*
     1952                            direction);
     1953      if( direction >0.0 )
     1954        CPXsetdblparam( env, CPX_PARAM_CUTUP, useCutoff ) ; // min
     1955      else
     1956        CPXsetdblparam( env, CPX_PARAM_CUTLO, useCutoff ) ; // max
     1957    }
     1958    CPXsetdblparam(env, CPX_PARAM_EPGAP,dblParam_[CbcAllowableFractionGap]);
     1959    delete [] setSol;
     1960    delete [] setVar;
     1961    char printBuffer[200];
     1962    if (offset) {
     1963      sprintf(printBuffer,"Add %g to all Cplex messages for true objective",
     1964              -offset);
     1965      messageHandler()->message(CBC_GENERAL,messages())
     1966        << printBuffer << CoinMessageEol ;
     1967      cpxSolver.setDblParam(OsiObjOffset,offset);
     1968    }
     1969    cpxSolver.branchAndBound();
     1970    static double totalTime=0.0;
     1971    double timeTaken = CoinCpuTime()-time1;
     1972    totalTime += timeTaken;
     1973    sprintf(printBuffer,"Cplex took %g seconds - total %g",
     1974            timeTaken,totalTime);
     1975    messageHandler()->message(CBC_GENERAL,messages())
     1976      << printBuffer << CoinMessageEol ;
     1977    numberExtraNodes_ = CPXgetnodecnt(env,lpPtr);
     1978    numberExtraIterations_ = CPXgetmipitcnt(env,lpPtr);
     1979    double value = cpxSolver.getObjValue()*direction;
     1980    if (cpxSolver.isProvenOptimal()&&value<=getCutoff()) {
     1981      feasible=true;
     1982      clpSolver->setWarmStart(NULL);
     1983      // try and do solution
     1984      double * newSolution =
     1985        CoinCopyOfArray(cpxSolver.getColSolution(),
     1986                        getNumCols());
     1987      setBestSolution(CBC_STRONGSOL,value,newSolution) ;
     1988      delete [] newSolution;
     1989    }
     1990    feasible=false;
     1991  }
     1992#endif
    18611993  if(fastNodeDepth_>=0&&/*!parentModel_*/(specialOptions_&2048)==0) {
    18621994    // add in a general depth object doClp
     
    18942026 // Save copy of solver
    18952027 OsiSolverInterface * saveSolver = NULL;
    1896  if (!parentModel_&&(specialOptions_&(512+2048))!=0)
     2028 if (!parentModel_&&(specialOptions_&(512+32768))!=0)
    18972029   saveSolver = solver_->clone();
    1898  if (saveSolver&&(specialOptions_&2048)!=0) {
     2030 double checkCutoffForRestart=1.0e100;
     2031 if (saveSolver&&(specialOptions_&32768)!=0) {
    18992032   // See if worth trying reduction
    1900    bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate();
     2033   checkCutoffForRestart=getCutoff();
     2034   bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate()&&
     2035     (checkCutoffForRestart<1.0e20);
    19012036   int numberColumns = getNumCols();
    19022037   if (tryNewSearch) {
    1903      double cutoff = getCutoff() ;
     2038#ifdef CLP_INVESTIGATE
     2039     printf("after %d nodes, cutoff %g - looking\n",
     2040            numberNodes_,getCutoff());
     2041#endif
    19042042     saveSolver->resolve();
    19052043     double direction = saveSolver->getObjSense() ;
    1906      double gap = cutoff - saveSolver->getObjValue()*direction ;
     2044     double gap = checkCutoffForRestart - saveSolver->getObjValue()*direction ;
    19072045     double tolerance;
    19082046     saveSolver->getDblParam(OsiDualTolerance,tolerance) ;
     
    19522090   }
    19532091   if (tryNewSearch) {
    1954      // back to solver without cuts?
    1955 #if 0
     2092     // back to solver without cuts? 
     2093#if 1
    19562094     OsiSolverInterface * solver2 = continuousSolver_->clone();
    19572095#else
     
    19692107     saveSolver=solver2;
    19702108     double * newSolution = new double[numberColumns];
    1971      double objectiveValue=cutoff;
     2109     double objectiveValue=checkCutoffForRestart;
    19722110     CbcSerendipity heuristic(*this);
    19732111     if (bestSolution_)
    19742112       heuristic.setInputSolution(bestSolution_,bestObjective_);
    1975      heuristic.setFractionSmall(0.9);
     2113     heuristic.setFractionSmall(0.5);
    19762114     heuristic.setFeasibilityPumpOptions(1008013);
    19772115     // Use numberNodes to say how many are original rows
     
    19792117#ifdef COIN_DEVELOP
    19802118     if (continuousSolver_->getNumRows()<
    1981          solver_->getNumRows())
     2119         saveSolver->getNumRows())
    19822120       printf("%d rows added ZZZZZ\n",
    19832121              solver_->getNumRows()-continuousSolver_->getNumRows());
     
    19862124                                                   -1,newSolution,
    19872125                                                   objectiveValue,
    1988                                                    cutoff,"Reduce");
     2126                                                   checkCutoffForRestart,"Reduce");
    19892127     if (returnCode<0) {
    19902128#ifdef COIN_DEVELOP
     
    24002538  bool locked=false;
    24012539  int threadStats[6];
    2402   int defaultParallelIterations=500;
     2540  int defaultParallelIterations=400;
    24032541  int defaultParallelNodes=10;
    24042542  memset(threadStats,0,sizeof(threadStats));
     
    25532691        = dynamic_cast<OsiClpSolverInterface *> (solver_);
    25542692      if (clpSolver&&numberNodes_>=100&&numberNodes_<200) {
    2555         if (numberIterations_<numberNodes_*20) {
     2693        if (numberIterations_<(numberSolves_+numberNodes_)*10) {
     2694          //if (numberIterations_<numberNodes_*20) {
    25562695          ClpSimplex * simplex = clpSolver->getModelPtr();
    25572696          ClpDualRowPivot * pivotMethod=simplex->dualRowPivot();
     
    26952834#endif
    26962835    // If done 100 nodes see if worth trying reduction
    2697     if (numberNodes_==100&&saveSolver) {
    2698       bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate();
     2836    if ((numberNodes_==50||numberNodes_==100)&&saveSolver) {
     2837      bool tryNewSearch=solverCharacteristics_->reducedCostsAccurate()&&
     2838        (getCutoff()<1.0e20&&getCutoff()<checkCutoffForRestart);
    26992839      int numberColumns = getNumCols();
    27002840      if (tryNewSearch) {
    2701         double cutoff = getCutoff() ;
     2841        checkCutoffForRestart = getCutoff() ;
     2842#ifdef CLP_INVESTIGATE
     2843        printf("after %d nodes, cutoff %g - looking\n",
     2844               numberNodes_,getCutoff());
     2845#endif
    27022846        saveSolver->resolve();
    27032847        double direction = saveSolver->getObjSense() ;
    2704         double gap = cutoff - saveSolver->getObjValue()*direction ;
     2848        double gap = checkCutoffForRestart - saveSolver->getObjValue()*direction ;
    27052849        double tolerance;
    27062850        saveSolver->getDblParam(OsiDualTolerance,tolerance) ;
     
    27812925        saveSolver=solver2;
    27822926        double * newSolution = new double[numberColumns];
    2783         double objectiveValue=cutoff;
     2927        double objectiveValue=checkCutoffForRestart;
    27842928        CbcSerendipity heuristic(*this);
    27852929        if (bestSolution_)
     
    27982942                                                      -1,newSolution,
    27992943                                                      objectiveValue,
    2800                                                       cutoff,"Reduce");
     2944                                                      checkCutoffForRestart,"Reduce");
    28012945        if (returnCode<0) {
    28022946#ifdef COIN_DEVELOP
     
    29073051          = dynamic_cast<OsiClpSolverInterface *> (solver_);
    29083052        if (clpSolver&&numberNodes_>=1000&&numberNodes_<2000) {
    2909           if (numberIterations_<numberNodes_*20) {
     3053          if (numberIterations_<(numberSolves_+numberNodes_)*10) {
    29103054            ClpSimplex * simplex = clpSolver->getModelPtr();
    29113055            ClpDualRowPivot * pivotMethod=simplex->dualRowPivot();
     
    34523596  if ( numberStoppedSubTrees_)
    34533597    status_=1;
     3598  numberNodes_ += numberExtraNodes_;
     3599  numberIterations_ += numberExtraIterations_;
    34543600  if (!status_) {
    34553601    // Set best possible unless stopped on gap
     
    39224068  numberNodes2_(0),
    39234069  numberIterations_(0),
     4070  numberSolves_(0),
    39244071  status_(-1),
    39254072  secondaryStatus_(-1),
     
    40864233  numberNodes2_(0),
    40874234  numberIterations_(0),
     4235  numberSolves_(0),
    40884236  status_(-1),
    40894237  secondaryStatus_(-1),
     
    43534501  numberNodes2_(rhs.numberNodes2_),
    43544502  numberIterations_(rhs.numberIterations_),
     4503  numberSolves_(rhs.numberSolves_),
    43554504  status_(rhs.status_),
    43564505  secondaryStatus_(rhs.secondaryStatus_),
     
    46814830    numberNodes2_ = rhs.numberNodes2_;
    46824831    numberIterations_ = rhs.numberIterations_;
     4832    numberSolves_ = rhs.numberSolves_;
    46834833    status_ = rhs.status_;
    46844834    secondaryStatus_ = rhs.secondaryStatus_;
     
    50595209  numberNodes2_=0;
    50605210  numberIterations_=0;
     5211  numberSolves_ = 0;
    50615212  status_=-1;
    50625213  secondaryStatus_=-1;
     
    51865337  numberNodes2_ = rhs.numberNodes2_;
    51875338  numberIterations_ = rhs.numberIterations_;
     5339  numberSolves_ = rhs.numberSolves_;
    51885340  status_ = rhs.status_;
    51895341  secondaryStatus_ = rhs.secondaryStatus_;
     
    57695921      lastws->compressRows(numberToDrop,cutsToDrop) ;
    57705922      lastws->resize(numberRowsNow,numberColumns);
     5923      assert (lastws->fullBasis());
    57715924#ifdef NODE_LAST
    57725925      bool canMissStuff=false;
     
    77177870          }
    77187871        }
     7872        // Set bit to say don't try too hard if seems reasonable
     7873        if (maximumCutPasses_<=5)
     7874          whenCuts_ += 100000;
    77197875        //// end
    77207876#ifdef CLP_INVESTIGATE
     
    83898545          //double cutoff = getCutoff();
    83908546          if (bestObjective_-getCutoffIncrement()<testValue) {
    8391 #ifdef CLP_INVESTIGATE
     8547#ifdef CLP_INVESTIGATE 
    83928548            double value ;
    83938549            solver_->getDblParam(OsiDualObjectiveLimit,value) ;
     
    96199775      CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis*>(saveSolver->getWarmStart()) ;
    96209776      assert(basis != NULL);
     9777#if 0 //ndef CBC_OTHER_SOLVER
    96219778      for (i=0;i<numberObjects_;i++) {
    96229779        CbcSimpleInteger * obj =
     
    96309787        }
    96319788      }
     9789#endif
    96329790      delete basis;
    96339791    }
     
    1003610194    assert(basis != NULL);
    1003710195    objectiveValue =checkSolution(cutoff,solution,fixVariables,objectiveValue);
    10038     if (saveObjectiveValue+1.0e-5<objectiveValue) {
     10196    if (saveObjectiveValue+1.0e-3<objectiveValue) {
    1003910197#if COIN_DEVELOP>1
    1004010198      printf("First try at solution had objective %.16g, rechecked as %.16g\n",
     
    1191112069CbcModel::resolve(OsiSolverInterface * solver)
    1191212070{
     12071  numberSolves_++;
    1191312072#ifdef COIN_HAS_CLP
    1191412073  OsiClpSolverInterface * clpSolver
     
    1211412273      if (!doCutsNow(1))
    1211512274        doClp=true;
    12116       doClp = true;
    12117       int testDepth=10;
     12275      //doClp = true;
     12276      int testDepth=5;
    1211812277      // Don't do if many iterations per node
    1211912278      int totalNodes = numberNodes_+numberExtraNodes_;
    1212012279      int totalIterations = numberIterations_ + numberExtraIterations_;
    12121       if (totalNodes*40<totalIterations)
     12280      if (totalNodes*40<totalIterations||numberNodes_<1000) {
    1212212281        doClp=false;
     12282        //} else if (oldNode&&fastNodeDepth_>=0&&oldNode->depth()>=testDepth&&(specialOptions_&2048)==0) {
     12283        //printf("size %d %d - cuts %d - nodes %d its %d\n",solver_->getNumRows(),
     12284        //     solver_->getNumCols(),cuts.sizeRowCuts(),
     12285        //     totalNodes,totalIterations);
     12286      }
    1212312287      if (oldNode&&fastNodeDepth_>=0&&oldNode->depth()>=testDepth&&/*!parentModel_*/(specialOptions_&2048)==0
    1212412288          &&doClp&&!cuts.sizeRowCuts()) {
     
    1324213406      OsiClpSolverInterface * clpSolver
    1324313407        = dynamic_cast<OsiClpSolverInterface *> (solver_);
    13244       if (clpSolver&&fastNodeDepth_<-1) {
    13245 #define FATHOM_BIAS 1
     13408      if ((clpSolver||(specialOptions_&16384)!=0)&&fastNodeDepth_<-1
     13409          &&!parentModel_) {
     13410#define FATHOM_BIAS -2
    1324613411        //#ifdef COIN_DEVELOP
    1324713412        if (numberNodes_==1) {
     
    1327613441        }
    1327713442        int go_fathom = FATHOM_BIAS+fastNodeDepth1;
     13443        if((specialOptions_&16384)!=0)
     13444          numberNodesBeforeFathom = 0;
    1327813445        if (node->depth()>=go_fathom &&!parentModel_
    1327913446            //if (node->depth()>=FATHOM_BIAS-fastNodeDepth_&&!parentModel_
    13280             &&numberNodes_>numberNodesBeforeFathom) {
    13281           info->integerTolerance_=getIntegerTolerance();
    13282           info->integerIncrement_=getCutoffIncrement();
    13283           double * down = new double[numberIntegers_];
    13284           double * up = new double[numberIntegers_];
    13285           int * numberDown = new int[numberIntegers_];
    13286           int * numberUp = new int[numberIntegers_];
    13287           int * numberDownInfeasible = new int[numberIntegers_];
    13288           int * numberUpInfeasible = new int[numberIntegers_];
    13289           fillPseudoCosts(down,up,numberDown,numberUp,
    13290                           numberDownInfeasible,numberUpInfeasible);
    13291           info->fillPseudoCosts(down,up,numberDown,numberUp,
    13292                                 numberDownInfeasible,
    13293                                 numberUpInfeasible,numberIntegers_);
    13294           info->presolveType_=1;
    13295           // for reduced costs and duals
    13296           info->solverOptions_ |= 7;
    13297           delete [] down;
    13298           delete [] up;
    13299           delete [] numberDown;
    13300           delete [] numberUp;
    13301           delete [] numberDownInfeasible;
    13302           delete [] numberUpInfeasible;
    13303           bool takeHint;
    13304           OsiHintStrength strength;
    13305           solver_->getHintParam(OsiDoReducePrint,takeHint,strength);
    13306           ClpSimplex * simplex = clpSolver->getModelPtr();
    13307           int saveLevel = simplex->logLevel();
    13308           if (strength!=OsiHintIgnore&&takeHint&&saveLevel==1)
    13309             simplex->setLogLevel(0);
    13310           clpSolver->setBasis();
    13311           feasible = simplex->fathom(info)!=0;
    13312           numberExtraNodes_ += info->numberNodesExplored_;
    13313           numberExtraIterations_ += info->numberIterations_;
    13314           if (info->nNodes_<0) {
    13315             // we gave up
    13316             //abort();
    13317             fastNodeDepth_ -= 2;
     13447            &&numberNodes_>=numberNodesBeforeFathom) {
     13448#ifndef COIN_HAS_CPX
     13449          specialOptions_ &= ~16384;
     13450#endif
     13451          if ((specialOptions_&16384)==0) {
     13452            info->integerTolerance_=getIntegerTolerance();
     13453            info->integerIncrement_=getCutoffIncrement();
     13454            double * down = new double[numberIntegers_];
     13455            double * up = new double[numberIntegers_];
     13456            int * numberDown = new int[numberIntegers_];
     13457            int * numberUp = new int[numberIntegers_];
     13458            int * numberDownInfeasible = new int[numberIntegers_];
     13459            int * numberUpInfeasible = new int[numberIntegers_];
     13460            fillPseudoCosts(down,up,numberDown,numberUp,
     13461                            numberDownInfeasible,numberUpInfeasible);
     13462            info->fillPseudoCosts(down,up,numberDown,numberUp,
     13463                                  numberDownInfeasible,
     13464                                  numberUpInfeasible,numberIntegers_);
     13465            info->presolveType_=1;
     13466            // for reduced costs and duals
     13467            info->solverOptions_ |= 7;
     13468            delete [] down;
     13469            delete [] up;
     13470            delete [] numberDown;
     13471            delete [] numberUp;
     13472            delete [] numberDownInfeasible;
     13473            delete [] numberUpInfeasible;
     13474            bool takeHint;
     13475            OsiHintStrength strength;
     13476            solver_->getHintParam(OsiDoReducePrint,takeHint,strength);
     13477            ClpSimplex * simplex = clpSolver->getModelPtr();
     13478            int saveLevel = simplex->logLevel();
     13479            if (strength!=OsiHintIgnore&&takeHint&&saveLevel==1)
     13480              simplex->setLogLevel(0);
     13481            clpSolver->setBasis();
     13482            feasible = simplex->fathom(info)!=0;
     13483            numberExtraNodes_ += info->numberNodesExplored_;
     13484            numberExtraIterations_ += info->numberIterations_;
     13485            if (info->nNodes_<0) {
     13486              // we gave up
     13487              //abort();
     13488              fastNodeDepth_ -= 2;
    1331813489#ifdef COIN_DEVELOP
    13319             printf("fastNodeDepth now %d - so at depth >= %d\n",
    13320                    fastNodeDepth_,FATHOM_BIAS-fastNodeDepth_);
    13321 #endif
    13322             if (feasible) {
     13490              printf("fastNodeDepth now %d - so at depth >= %d\n",
     13491                     fastNodeDepth_,FATHOM_BIAS-fastNodeDepth_);
     13492#endif
     13493              if (feasible) {
     13494                // Save bounds round bestSolution
     13495                //double * saveLower = CoinCopyOfArray(solver_->getColLower(),
     13496                //                           numberColumns);
     13497                //double * saveUpper = CoinCopyOfArray(solver_->getColUpper(),
     13498                //                           numberColumns);
     13499                clpSolver->setWarmStart(NULL);
     13500                // try and do solution
     13501                double value = simplex->objectiveValue()*
     13502                  simplex->optimizationDirection();
     13503                double * newSolution =
     13504                  CoinCopyOfArray(simplex->primalColumnSolution(),
     13505                                  numberColumns);
     13506                setBestSolution(CBC_STRONGSOL,value,newSolution) ;
     13507                delete [] newSolution;
     13508                //solver_->setColLower(saveLower);
     13509                //solver_->setColUpper(saveUpper);
     13510                //delete [] saveLower;
     13511                //delete [] saveUpper;
     13512              }
     13513              // say feasible so will redo node
     13514              feasible=true;
     13515            } else {
     13516              if (feasible) {
     13517                clpSolver->setWarmStart(NULL);
     13518                // try and do solution
     13519                double value = simplex->objectiveValue()*
     13520                  simplex->optimizationDirection();
     13521                double * newSolution =
     13522                  CoinCopyOfArray(simplex->primalColumnSolution(),
     13523                                  numberColumns);
     13524                setBestSolution(CBC_STRONGSOL,value,newSolution) ;
     13525                delete [] newSolution;
     13526              }
     13527              // update pseudo costs
     13528              double smallest=1.0e50;
     13529              double largest=-1.0;
     13530              for (int i=0;i<numberIntegers_;i++) {
     13531#ifndef NDEBUG
     13532                CbcSimpleIntegerDynamicPseudoCost * obj =
     13533                  dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
     13534                assert (obj&&obj->columnNumber()==integerVariable_[i]);
     13535#else
     13536                CbcSimpleIntegerDynamicPseudoCost * obj =
     13537                  static_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
     13538#endif
     13539                if (info->numberUp_[i]>0) {
     13540                  if (info->downPseudo_[i]>largest)
     13541                    largest=info->downPseudo_[i];
     13542                  if (info->downPseudo_[i]<smallest)
     13543                    smallest=info->downPseudo_[i];
     13544                  if (info->upPseudo_[i]>largest)
     13545                    largest=info->upPseudo_[i];
     13546                  if (info->upPseudo_[i]<smallest)
     13547                    smallest=info->upPseudo_[i];
     13548                  obj->updateAfterMini(info->numberDown_[i],
     13549                                       info->numberDownInfeasible_[i],
     13550                                       info->downPseudo_[i],
     13551                                       info->numberUp_[i],
     13552                                       info->numberUpInfeasible_[i],
     13553                                       info->upPseudo_[i]);
     13554                }
     13555              }
     13556              //printf("range of costs %g to %g\n",smallest,largest);
     13557              // If value of objective borderline then may not be feasible
     13558              double value = simplex->objectiveValue()*simplex->optimizationDirection();
     13559              if (value-getCutoff()<-1.0e-1)
     13560                fathomDone=true;
     13561            }
     13562            simplex->setLogLevel(saveLevel);
     13563#ifdef COIN_HAS_CPX
     13564          } else {
     13565            // try cplex
     13566            OsiCpxSolverInterface cpxSolver;
     13567            double direction = clpSolver->getObjSense();
     13568            cpxSolver.setObjSense(direction);
     13569            // load up cplex
     13570            const CoinPackedMatrix * matrix = clpSolver->getMatrixByCol();
     13571            const double * rowLower = clpSolver->getRowLower();
     13572            const double * rowUpper = clpSolver->getRowUpper();
     13573            const double * columnLower = clpSolver->getColLower();
     13574            const double * columnUpper = clpSolver->getColUpper();
     13575            const double * objective = clpSolver->getObjCoefficients();
     13576            cpxSolver.loadProblem(*matrix,columnLower,columnUpper,
     13577                                  objective, rowLower,rowUpper);
     13578            double * setSol = new double [numberIntegers_];
     13579            int * setVar = new int [numberIntegers_];
     13580            // cplex doesn't know about objective offset
     13581            double offset = clpSolver->getModelPtr()->objectiveOffset();
     13582            for (int i=0;i<numberIntegers_;i++) {
     13583              int iColumn = integerVariable_[i];
     13584              cpxSolver.setInteger(iColumn);
     13585              if (bestSolution_) {
     13586                setSol[i]=bestSolution_[iColumn];
     13587                setVar[i]=iColumn;
     13588              }
     13589            }
     13590            CPXENVptr env = cpxSolver.getEnvironmentPtr();
     13591            CPXLPptr lpPtr = cpxSolver.getLpPtr(OsiCpxSolverInterface::KEEPCACHED_ALL);
     13592            cpxSolver.switchToMIP();
     13593            if (bestSolution_) {
     13594              CPXcopymipstart(env,lpPtr,numberIntegers_,setVar,setSol);
     13595            }
     13596            if (getCutoff()<1.0e50) {
     13597              double useCutoff = getCutoff()+offset;
     13598              if (bestObjective_<1.0e50)
     13599                useCutoff = bestObjective_+offset+1.0e-7;
     13600              cpxSolver.setDblParam(OsiDualObjectiveLimit,useCutoff*
     13601                                    direction);
     13602              if( direction >0.0 )
     13603                CPXsetdblparam( env, CPX_PARAM_CUTUP, useCutoff ) ; // min
     13604              else
     13605                CPXsetdblparam( env, CPX_PARAM_CUTLO, useCutoff ) ; // max
     13606            }
     13607            CPXsetdblparam(env, CPX_PARAM_EPGAP,dblParam_[CbcAllowableFractionGap]);
     13608            delete [] setSol;
     13609            delete [] setVar;
     13610            if (offset) {
     13611              char printBuffer[200];
     13612              sprintf(printBuffer,"Add %g to all Cplex messages for true objective",
     13613                      -offset);
     13614              messageHandler()->message(CBC_GENERAL,messages())
     13615                << printBuffer << CoinMessageEol ;
     13616              cpxSolver.setDblParam(OsiObjOffset,offset);
     13617            }
     13618            cpxSolver.branchAndBound();
     13619            numberExtraNodes_ += CPXgetnodecnt(env,lpPtr);
     13620            numberExtraIterations_ += CPXgetmipitcnt(env,lpPtr);
     13621            double value = cpxSolver.getObjValue()*direction;
     13622            if (cpxSolver.isProvenOptimal()&&value<=getCutoff()) {
     13623              feasible=true;
    1332313624              clpSolver->setWarmStart(NULL);
    1332413625              // try and do solution
    13325               double value = simplex->objectiveValue()*
    13326                 simplex->optimizationDirection();
    1332713626              double * newSolution =
    13328                 CoinCopyOfArray(simplex->primalColumnSolution(),
    13329                                 numberColumns);
     13627                CoinCopyOfArray(cpxSolver.getColSolution(),
     13628                                getNumCols());
    1333013629              setBestSolution(CBC_STRONGSOL,value,newSolution) ;
    1333113630              delete [] newSolution;
     13631              fathomDone=true;
     13632            } else {
     13633              feasible=false;
    1333213634            }
    13333             // say feasible so will redo node
    13334             feasible=true;
    13335           } else {
    13336             if (feasible) {
    13337               clpSolver->setWarmStart(NULL);
    13338               // try and do solution
    13339               double value = simplex->objectiveValue()*
    13340                 simplex->optimizationDirection();
    13341               double * newSolution =
    13342                 CoinCopyOfArray(simplex->primalColumnSolution(),
    13343                                 numberColumns);
    13344               setBestSolution(CBC_STRONGSOL,value,newSolution) ;
    13345               delete [] newSolution;
    13346             }
    13347             // update pseudo costs
    13348             double smallest=1.0e50;
    13349             double largest=-1.0;
    13350             for (int i=0;i<numberIntegers_;i++) {
    13351 #ifndef NDEBUG
    13352               CbcSimpleIntegerDynamicPseudoCost * obj =
    13353                 dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
    13354               assert (obj&&obj->columnNumber()==integerVariable_[i]);
    13355 #else
    13356               CbcSimpleIntegerDynamicPseudoCost * obj =
    13357                 static_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[i]) ;
    13358 #endif
    13359               if (info->numberUp_[i]>0) {
    13360                 if (info->downPseudo_[i]>largest)
    13361                   largest=info->downPseudo_[i];
    13362                 if (info->downPseudo_[i]<smallest)
    13363                   smallest=info->downPseudo_[i];
    13364                 if (info->upPseudo_[i]>largest)
    13365                   largest=info->upPseudo_[i];
    13366                 if (info->upPseudo_[i]<smallest)
    13367                   smallest=info->upPseudo_[i];
    13368                 obj->updateAfterMini(info->numberDown_[i],
    13369                                      info->numberDownInfeasible_[i],
    13370                                      info->downPseudo_[i],
    13371                                      info->numberUp_[i],
    13372                                      info->numberUpInfeasible_[i],
    13373                                      info->upPseudo_[i]);
    13374               }
    13375             }
    13376             //printf("range of costs %g to %g\n",smallest,largest);
    13377             // If value of objective borderline then may not be feasible
    13378             double value = simplex->objectiveValue()*simplex->optimizationDirection();
    13379             if (value-getCutoff()<-1.0e-1)
    13380               fathomDone=true;
     13635#endif
    1338113636          }
    13382           simplex->setLogLevel(saveLevel);
    1338313637        }
    1338413638      }
    1338513639      if (feasible) {
    13386         feasible = solveWithCuts(cuts,maximumCutPasses_,node);
     13640        //int numberPasses = doCutsNow(1) ? maximumCutPasses_ : 0;
     13641        int numberPasses = /*doCutsNow(1) ?*/ maximumCutPasses_ /*: 0*/;
     13642        feasible = solveWithCuts(cuts,numberPasses,node);
    1338713643        if (fathomDone)
    1338813644          assert (feasible);
     
    1396414220  */
    1396514221#if 1
    13966   int numberToDelete = getNumRows()-numberRowsAtContinuous_ ;
    13967   if (numberToDelete) {
    13968     int * delRows = new int[numberToDelete] ;
    13969     int i ;
    13970     for (i = 0 ; i < numberToDelete ; i++)
    13971       delRows[i] = i+numberRowsAtContinuous_ ;
    13972     solver_->deleteRows(numberToDelete,delRows) ;
    13973     delete [] delRows ;
     14222  //if (numberThreads_)
     14223  {
     14224    int numberToDelete = getNumRows()-numberRowsAtContinuous_ ;
     14225    if (numberToDelete) {
     14226      int * delRows = new int[numberToDelete] ;
     14227      int i ;
     14228      for (i = 0 ; i < numberToDelete ; i++)
     14229        delRows[i] = i+numberRowsAtContinuous_ ;
     14230      solver_->deleteRows(numberToDelete,delRows) ;
     14231      delete [] delRows ;
     14232    }
    1397414233  }
    1397514234#endif
     
    1416414423    numberIterations_ = baseModel->numberIterations_;
    1416514424    numberFixedAtRoot_ = numberIterations_; // for statistics
     14425    numberSolves_=0;
    1416614426    phase_ = baseModel->phase_;
    1416714427    assert (!nextRowCut_);
     
    1423214492    baseModel->numberIterations_ +=
    1423314493      numberIterations_ - numberFixedAtRoot_;
     14494    baseModel->numberSolves_ += numberSolves_;
    1423414495#ifdef PUSH_LATER
    1423514496    if (stuff->node)
     
    1449114752        int nodesThisTime=thisModel->getNodeCount();
    1449214753        int iterationsThisTime=thisModel->getIterationCount();
     14754        int strongThisTime=thisModel->numberStrongIterations();
    1449314755        thisModel->setStopNumberIterations(thisModel->getIterationCount()+numberIterations);
    1449414756        int numberColumns = thisModel->getNumCols();
     
    1449814760          if (thisModel->tree()->empty()) {
    1449914761            returnCode=1+1;
     14762#ifdef CLP_INVESTIGATE
     14763            printf("%x tree empty - time %18.6f\n",thisModel,CoinGetTimeOfDay()-1.2348e9);
     14764#endif
    1450014765            break;
    1450114766          }
    14502           if (thisModel->getIterationCount()>thisModel->getStopNumberIterations()) {
     14767#define NODE_ITERATIONS 2
     14768          int nodesNow = thisModel->getNodeCount();
     14769          int iterationsNow = thisModel->getIterationCount();
     14770          int strongNow=thisModel->numberStrongIterations();
     14771          bool exit1 = (NODE_ITERATIONS*((nodesNow-nodesThisTime)+
     14772                                         ((strongNow-strongThisTime)>>1))+
     14773                        (iterationsNow-iterationsThisTime)>numberIterations);
     14774          //bool exit2 =(thisModel->getIterationCount()>thisModel->getStopNumberIterations()) ;
     14775          //assert (exit1==exit2);
     14776          if (exit1&&nodesNow-nodesThisTime>=10) {
    1450314777            // out of loop
    1450414778            //printf("out of loop\n");
     14779#ifdef CLP_INVESTIGATE
     14780            printf("%x tree %d nodes left, done %d and %d its - time %18.6f\n",thisModel,
     14781                   thisModel->tree()->size(),nodesNow-nodesThisTime,
     14782                   iterationsNow-iterationsThisTime,CoinGetTimeOfDay()-1.2348e9);
     14783#endif
    1450514784            break;
    1450614785          }
     
    1496515244CbcModel::doCutsNow(int allowForTopOfTree) const
    1496615245{
     15246  int whenCutsUse = whenCuts_;
     15247  int alwaysReturnAt10 = whenCutsUse%100000;
     15248  if (whenCutsUse>0&&alwaysReturnAt10) {
     15249    whenCutsUse -= alwaysReturnAt10;
     15250    if (currentDepth_>10)
     15251    return false;
     15252  }
     15253  //if (currentDepth_>10)
     15254  //return false;
     15255#define TRY_IDEA1 2
    1496715256  int size = continuousSolver_->getNumRows()+continuousSolver_->getNumCols();
    1496815257
    14969   if (whenCuts_<0||(size<=500&&allowForTopOfTree!=3)) {
     15258  if (true&&(whenCutsUse<0||(size<=500-500*TRY_IDEA1&&allowForTopOfTree!=3))) {
    1497015259    int whenCuts = (size<=500) ? -1 :1;
     15260    //whenCuts = (size<=500) ? 1 :1;
    1497115261    if (parentModel_)
    1497215262      whenCuts=1;
    1497315263    //int nodeDepth = currentDepth_-1;
    1497415264    bool doCuts2 =  !(currentDepth_>11&&(currentDepth_&1)==whenCuts);
    14975     //printf("when %d node %d depth %d size %d doing cuts %s\n",whenCuts_,
     15265    if (fastNodeDepth_>0&&currentDepth_>10)
     15266      doCuts2=false;
     15267    //printf("when %d node %d depth %d size %d doing cuts %s\n",whenCutsUse,
    1497615268    //   numberNodes_,currentDepth_,size,doCuts2 ? "yes" : "no");
    1497715269    return doCuts2;
     
    1497915271  //if (!parentModel_&&currentDepth_==7)
    1498015272  //printf("q\n");
    14981   int top=whenCuts_/1000000;
     15273  int top=whenCutsUse/1000000;
    1498215274  int shallow = top ? (top-1) : 9;
    14983   int when = whenCuts_ -1000000*top;
     15275  int when = whenCutsUse -1000000*top;
     15276#if TRY_IDEA1
     15277  if (when<15&&when>1&&size<=500)
     15278    when /= 2;
     15279#endif
    1498415280  if ((when>15||(top&&top<5))&&currentDepth_>when)
    1498515281    when=100000; // off
     
    1498915285  } else if (allowForTopOfTree==2&&shallow>=1) {
    1499015286    doCuts=true;
     15287#if TRY_IDEA1<2
    1499115288  } else if (allowForTopOfTree==3&&doCuts) {
    1499215289    // only if first
    1499315290    if(currentDepth_<=shallow||currentDepth_-when>shallow)
    1499415291      doCuts=false;
     15292#else
     15293  } else if (allowForTopOfTree==3) {
     15294    // only exactly at 10
     15295    doCuts = (currentDepth_==10);
     15296#endif
    1499515297  }
    1499615298  //if (!doCuts&&currentDepth_&&!parentModel_)
  • trunk/Cbc/src/CbcModel.hpp

    r1121 r1132  
    15141514      12 bit (4096) - Funny cuts so do slow way (in some places)
    15151515      13 bit (8192) - Funny cuts so do slow way (in other places)
     1516      14 bit (16384) - Use Cplex! for fathoming
     1517      15 bit (32768) - Try reduced model after 0 nodes
    15161518  */
    15171519  /// Set special options
     
    18181820  { numberExtraNodes_ += nodes; numberExtraIterations_ += iterations;}
    18191821#endif
     1822  /// Number of extra iterations
     1823  inline int numberExtraIterations() const
     1824  { return numberExtraIterations_;}
    18201825  /// Increment strong info
    18211826  void incrementStrongInfo(int numberTimes, int numberIterations,
     
    19561961  /// Cumulative number of iterations
    19571962  int numberIterations_;
     1963  /// Cumulative number of solves
     1964  int numberSolves_;
    19581965  /// Status of problem - 0 finished, 1 stopped, 2 difficulties
    19591966  int status_;
  • trunk/Cbc/src/CbcNode.cpp

    r1121 r1132  
    32033203      break;
    32043204    //bool skipAll = (numberBeforeTrust>20&&numberNodes>20000&&numberNotTrusted==0);
    3205     bool skipAll = numberNotTrusted==0||numberToDo==1;
     3205    int skipAll = (numberNotTrusted==0||numberToDo==1) ? 1 : 0;
    32063206    bool doneHotStart=false;
    32073207    int searchStrategy = saveSearchStrategy>=0 ? (saveSearchStrategy%10) : -1;
     
    32153215#ifndef CBC_WEAK_STRONG
    32163216    if (((numberNodes%20)==0&&searchStrategy!=2)||(model->specialOptions()&8)!=0)
    3217       skipAll=false;
     3217      skipAll=0;
    32183218#endif
    32193219    if (!newWay) {
     
    32283228            if (numberStrongIterations>numberIterations+10000) {
    32293229              searchStrategy=2;
    3230               //skipAll=true;
     3230              //skipAll=1;
    32313231            } else if (numberStrongIterations*4+1000<numberIterations||depth_<5) {
    32323232              searchStrategy=3;
    3233               skipAll=false;
     3233              skipAll=0;
    32343234            }
    32353235          } else {
    32363236            searchStrategy=3;
    3237             skipAll=false;
     3237            skipAll=0;
    32383238          }
    32393239        } else {
    3240           //skipAll=true;
     3240          //skipAll=1;
    32413241        }
    32423242      }
     
    32683268    }
    32693269    if (searchStrategy<3&&(!numberNotTrusted||!searchStrategy))
    3270       skipAll=true;
     3270      skipAll=1;
    32713271    else
    3272       skipAll=false;
     3272      skipAll=0;
    32733273    }
    32743274    // worth trying if too many times
     
    34233423      } else {
    34243424#endif          /* RANGING */
     3425#define SKIPM1
     3426#ifdef SKIPM1
     3427        {
     3428          int numberIterations = model->getIterationCount();
     3429          //numberIterations += (model->numberExtraIterations()>>2);
     3430          const int * strongInfo = model->strongInfo();
     3431          //int numberDone = strongInfo[0]-strongInfo[3];
     3432          int numberFixed = strongInfo[1]-strongInfo[4];
     3433          int numberInfeasible = strongInfo[2]-strongInfo[5];
     3434          assert (!strongInfo[3]);
     3435          assert (!strongInfo[4]);
     3436          assert (!strongInfo[5]);
     3437          int numberStrongIterations = model->numberStrongIterations();
     3438          int numberRows = solver->getNumRows();
     3439          if (numberStrongIterations>numberIterations+CoinMin(100,10*numberRows)&&depth_>=4&&numberNodes>100) {
     3440            if (20*numberInfeasible+4*numberFixed<numberNodes) {
     3441              // Say never do
     3442              skipAll=-1;
     3443            }
     3444          }
     3445          //if (model->parentModel()&&depth_>=4)
     3446          //skipAll=-1;
     3447        }
     3448#endif
    34253449      if (!skipAll) {
    34263450        // Mark hot start
     
    34283452        solver->markHotStart();
    34293453        xMark++;
     3454#ifdef CLP_INVESTIGATE
     3455        if (kkPass==1&&!solver->isProvenOptimal()) {
     3456          printf("Solver says infeasible on markHotStart?\n");
     3457        }
     3458#endif
    34303459      }
    34313460      // make sure best will be first
     
    34603489      //printf("todo %d, strong %d\n",numberToDo,numberStrong);
    34613490      int numberTest=numberNotTrusted>0 ? numberStrong : (numberStrong+1)/2;
    3462       int numberTest2 = 2*numberStrong;
    34633491      //double distanceToCutoff2 = model->getCutoff()-objectiveValue_;
    34643492      if (!newWay) {
     
    34673495        doQuickly=false;
    34683496        numberTest = numberStrong;
    3469         //numberTest2 = 1000000;
    34703497      }
    34713498      //if (searchStrategy<0||searchStrategy==1)
    3472         //numberTest2 = 1000000;
    34733499#if 0
    34743500      if (numberBeforeTrust>20&&(numberNodes>20000||(numberNodes>200&&numberNotTrusted==0))) {
     
    34803506#else
    34813507      // Try nearly always off
    3482       if (searchStrategy<2) {
    3483         if ((numberNodes%20)!=0) {
    3484           if ((model->specialOptions()&8)==0) {
    3485             numberTest=0;
    3486             doQuickly=true;
    3487           }
    3488         } else {
    3489           doQuickly=false;
    3490           numberTest=2*numberStrong;
    3491           skipAll=false;
    3492         }
    3493       } else if (searchStrategy!=3) {
    3494         doQuickly=true;
    3495         numberTest=numberStrong;
    3496       }
    3497 #endif
    3498       if (depth_<8&&numberStrong) {
     3508#ifdef SKIPM1
     3509      if (skipAll>=0) {
     3510#endif
     3511        if (searchStrategy<2) {
     3512          if ((numberNodes%20)!=0) {
     3513            if ((model->specialOptions()&8)==0) {
     3514              numberTest=0;
     3515              doQuickly=true;
     3516            }
     3517          } else {
     3518            doQuickly=false;
     3519            numberTest=2*numberStrong;
     3520            skipAll=0;
     3521          }
     3522        } else if (searchStrategy!=3) {
     3523          doQuickly=true;
     3524          numberTest=numberStrong;
     3525        }
     3526#ifdef SKIPM1
     3527      } else {
     3528        // Just take first
     3529        doQuickly=true;
     3530        numberTest=1;
     3531      }
     3532#endif
     3533#endif
     3534#ifdef SKIPM1
     3535      int testDepth = (skipAll>=0) ? 8 : 4;
     3536#else
     3537      int testDepth = 8;
     3538#endif
     3539      if (depth_<testDepth&&numberStrong) {
    34993540        if (searchStrategy!=2) {
    35003541          doQuickly=false;
     
    35083549          }
    35093550          numberTest=numberStrong;
    3510           skipAll=false;
     3551          skipAll=0;
    35113552        }
    35123553        //model->setStateOfSearch(2); // use min min
     
    35263567        distanceToCutoff *= 100.0;
    35273568      }
    3528         distanceToCutoff = -COIN_DBL_MAX;
     3569      distanceToCutoff = -COIN_DBL_MAX;
    35293570      // Do at least 5 strong
    35303571      if (numberColumns<1000&&(depth_<15||numberNodes<1000000))
     
    35463587        }
    35473588      int numberTest=numberNotTrusted>0 ? numberStrong : (numberStrong+1)/2;
    3548       int numberTest2 = 2*numberStrong;
    35493589      if (searchStrategy>=3) {
    35503590        // Previously decided we need strong
     
    35553595          numberStrong=CoinMin(6*numberStrong,numberToDo);
    35563596        numberTest = numberStrong;
    3557         numberTest2 *= 2;
    35583597      } else if (searchStrategy==2||(searchStrategy==1&&depth_<6)) {
    35593598        numberStrong *=2;
     
    35653604      } else {
    35663605        numberTest=0;
    3567         skipAll=true;
     3606#ifdef SKIPM1
     3607        if (skipAll==0)
     3608#endif
     3609          skipAll=1;
    35683610      }
    35693611      distanceToCutoff=model->getCutoff()-objectiveValue_;
     
    35803622      }
    35813623      }
    3582       // temp - always switch off
    3583       if (0) {
    3584         int numberIterations = model->getIterationCount();
    3585         int numberStrongIterations = model->numberStrongIterations();
    3586         int numberRows = solver->getNumRows();
    3587         if (numberStrongIterations>numberIterations+CoinMin(100,10*numberRows)&&depth_>=5) {
    3588           skipAll=true;
    3589           newWay=false;
    3590           numberTest=0;
    3591           doQuickly=true;
    3592         }
    3593       }
     3624#ifdef SKIPM1
     3625      // see if switched off
     3626      if (skipAll<0) {
     3627        newWay=false;
     3628        numberTest=0;
     3629        doQuickly=true;
     3630      }
     3631#endif
    35943632#if 0
    35953633      // temp - always switch on
     
    35983636        int numberStrongIterations = model->numberStrongIterations();
    35993637        if (2*numberStrongIterations<numberIterations||depth_<=5) {
    3600           skipAll=false;
     3638          skipAll=0;
    36013639          newWay=false;
    36023640          numberTest=CoinMax(numberTest,numberStrong);
     
    36063644#endif
    36073645      px[0]=numberTest;
    3608       px[1]=numberTest2;
     3646      px[1]=0;
    36093647      px[2]= doQuickly ? 1 : -1;
    36103648      px[3]=numberStrong;
    36113649      if (!newWay) {
    36123650        if (numberColumns>8*solver->getNumRows()&&false) {
    3613           printf("skipAll %c doQuickly %c numberTest %d numberTest2 %d numberNot %d\n",
    3614                  skipAll ? 'Y' : 'N',doQuickly ? 'Y' : 'N',numberTest,numberTest2,numberNotTrusted);
     3651          printf("skipAll %c doQuickly %c numberTest %d numberNot %d\n",
     3652                 skipAll ? 'Y' : 'N',doQuickly ? 'Y' : 'N',numberTest,numberNotTrusted);
    36153653          numberTest = CoinMin(numberTest,model->numberStrong());
    3616           numberTest2 = CoinMin(numberTest2,model->numberStrong());
    3617           printf("new test,test2 %d %d\n",numberTest,numberTest2);
     3654          printf("new test %d\n",numberTest);
    36183655        }
    36193656      }
    3620       //printf("skipAll %c doQuickly %c numberTest %d numberTest2 %d numberNot %d\n",
    3621       //   skipAll ? 'Y' : 'N',doQuickly ? 'Y' : 'N',numberTest,numberTest2,numberNotTrusted);
    36223657      // See if we want mini tree
    36233658      bool wantMiniTree=false;
     
    36363671        saveLimit2=200;
    36373672        solver->setIntParam(OsiMaxNumIterationHotStart,saveLimit2);
     3673      }
     3674#endif
     3675#ifdef SKIPM1
     3676      if (skipAll<0)
     3677        numberToDo=1;
     3678#endif
     3679#ifdef DO_ALL_AT_ROOT
     3680      if (!numberNodes) {
     3681        printf("DOX %d test %d unsat %d - nobj %d\n",
     3682               numberToDo,numberTest,numberUnsatisfied_,
     3683               numberObjects);
     3684        numberTest=numberToDo;
    36383685      }
    36393686#endif
     
    36983745        if (sort[iDo]<distanceToCutoff)
    36993746          canSkip=0;
    3700         if (((numberTest2<=0&&numberTest<=0)||skipAll)&&sort[iDo]>distanceToCutoff) {
     3747        if ((numberTest<=0||skipAll)&&sort[iDo]>distanceToCutoff) {
    37013748          canSkip=1; // always skip
    37023749          if (iDo>20) {
     3750#ifdef DO_ALL_AT_ROOT
     3751            if (!numberNodes)
     3752              printf("DOY test %d - iDo %d\n",
     3753                     numberTest,iDo);
     3754#endif
    37033755            if (!choiceObject) {
    37043756              delete choice.possibleBranch;
     
    37093761        }
    37103762#else
    3711         if (((numberTest2<=0&&numberTest<=0)||skipAll)&&sort[iDo]>distanceToCutoff) {
     3763        if ((numberTest<=0||skipAll)&&sort[iDo]>distanceToCutoff) {
    37123764          //canSkip=1; // always skip
    37133765          if (iDo>20) {
     3766#ifdef DO_ALL_AT_ROOT
     3767            if (!numberNodes)
     3768              printf("DOY test %d - iDo %d\n",
     3769                     numberTest,iDo);
     3770#endif
    37143771            if (!choiceObject) {
    37153772              delete choice.possibleBranch;
     
    37223779        if (model->messageHandler()->logLevel()>3&&numberBeforeTrust&&dynamicObject)
    37233780          dynamicObject->print(1,choice.possibleBranch->value());
    3724         // was if (!canSkip)
    3725         if (newWay)
    3726         numberTest2--;
     3781#ifdef SKIPM1
     3782        if (skipAll<0)
     3783          canSkip=true;
     3784#endif
    37273785        if (!canSkip) {
    37283786          //#ifndef RANGING
     
    37363794          assert (!couldChooseFirst);
    37373795          numberTest--;
    3738           if (!newWay)
    3739           numberTest2--;
    37403796          // just do a few
    37413797#if NODE_NEW == 5  || NODE_NEW == 2
     
    38913947            solver->markHotStart();
    38923948          }
    3893           //printf("Down on %d, status is %d, obj %g its %d cost %g finished %d inf %d infobj %d\n",
    3894           //printf("Down on %d, status is %d, obj %g its %d cost %g finished %d inf %d infobj %d\n",
    3895           //     choice.objectNumber,iStatus,newObjectiveValue,choice.numItersDown,
    3896           //     choice.downMovement,choice.finishedDown,choice.numIntInfeasDown,
    3897           //     choice.numObjInfeasDown);
     3949#ifdef DO_ALL_AT_ROOT
     3950          if (!numberNodes)
     3951          printf("Down on %d, status is %d, obj %g its %d cost %g finished %d inf %d infobj %d\n",
     3952               choice.objectNumber,iStatus,newObjectiveValue,choice.numItersDown,
     3953               choice.downMovement,choice.finishedDown,choice.numIntInfeasDown,
     3954               choice.numObjInfeasDown);
     3955#endif
    38983956         
    38993957          // repeat the whole exercise, forcing the variable up
     
    40234081          }
    40244082         
    4025           //printf("Up on %d, status is %d, obj %g its %d cost %g finished %d inf %d infobj %d\n",
    4026           //     choice.objectNumber,iStatus,newObjectiveValue,choice.numItersUp,
    4027           //     choice.upMovement,choice.finishedUp,choice.numIntInfeasUp,
    4028           //     choice.numObjInfeasUp);
     4083#ifdef DO_ALL_AT_ROOT
     4084          if (!numberNodes)
     4085          printf("Up on %d, status is %d, obj %g its %d cost %g finished %d inf %d infobj %d\n",
     4086               choice.objectNumber,iStatus,newObjectiveValue,choice.numItersUp,
     4087               choice.upMovement,choice.finishedUp,choice.numIntInfeasUp,
     4088               choice.numObjInfeasUp);
     4089#endif
    40294090        }
    40304091   
     
    44384499  model->incrementStrongInfo(numberStrongDone,numberStrongIterations,
    44394500                             anyAction==-2 ? 0:numberToFix,anyAction==-2);
     4501#if 0
     4502  if (!numberNodes&&!model->parentModel()) {
     4503    printf("DOZ %d strong, %d iterations, %d unfinished\n",
     4504           numberStrongDone,numberStrongIterations,numberUnfinished);
     4505    if (numberUnfinished>10&&4*numberUnfinished>numberStrongDone)
     4506    /model->setNumberBeforeTrust(CoinMin(numberBeforeTrust,5));
     4507  }
     4508#endif
    44404509  if (!newWay) {
    44414510  if (((model->searchStrategy()+1)%1000)==0) {
  • trunk/Cbc/src/CbcSolver.cpp

    r1131 r1132  
    790790#endif
    791791#endif
     792#ifdef CPX_KEEP_RESULTS
     793#define CBC_OTHER_SOLVER 1
     794#endif
     795#ifdef COIN_HAS_CPX
     796#include "OsiCpxSolverInterface.hpp"
     797#endif
     798#ifdef CBC_OTHER_SOLVER
     799#if CBC_OTHER_SOLVER==1
     800#include "OsiCpxSolverInterface.hpp"
     801#endif
     802#undef NEW_STYLE_SOLVER
     803#define NEW_STYLE_SOLVER 0
     804#endif
    792805//#undef COIN_HAS_ASL
    793806#ifdef COIN_HAS_ASL
     
    849862FILE * CbcOrClpReadCommand=stdin;
    850863static bool noPrinting=false;
     864#ifndef CBC_OTHER_SOLVER
    851865#if NEW_STYLE_SOLVER
    852866int * CbcSolver::analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment,
     
    11571171  }
    11581172}
     1173#endif
    11591174#if 1
    11601175#include "ClpSimplexOther.hpp"
     
    31013116void CbcMain0 (CbcModel  & model)
    31023117{
     3118#ifndef CBC_OTHER_SOLVER
    31033119  OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model.solver());
     3120#elif CBC_OTHER_SOLVER==1
     3121  OsiCpxSolverInterface * originalSolver = dynamic_cast<OsiCpxSolverInterface *> (model.solver());
     3122  // Dummy solvers
     3123  OsiClpSolverInterface dummySolver;
     3124  ClpSimplex * lpSolver = dummySolver.getModelPtr();
     3125  OsiCpxSolverInterface * clpSolver = originalSolver;
     3126#endif
    31043127  assert (originalSolver);
    31053128  CoinMessageHandler * generalMessageHandler = originalSolver->messageHandler();
    31063129  generalMessageHandler->setPrefix(true);
     3130#ifndef CBC_OTHER_SOLVER
    31073131  OsiSolverInterface * solver = model.solver();
    31083132  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
     
    31103134  lpSolver->setPerturbation(50);
    31113135  lpSolver->messageHandler()->setPrefix(false);
     3136#endif
    31123137  establishParams(numberParameters,parameters) ;
    31133138  const char dirsep =  CoinFindDirSeparator();
     
    35563581    bool cleanModel = !model2.numberIntegers()&&!model2.numberObjects();
    35573582    model2.findIntegers(false);
    3558     int heurOptions=parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/100;
     3583    int heurOptions=(parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/100)%100;
    35593584    if (heurOptions==0||heurOptions==2) {
    35603585      model2.doHeuristicsAtRoot(1);
    35613586    } else if (heurOptions==1||heurOptions==3) {
    35623587      model2.setMaximumNodes(-1);
    3563       CbcStrategyDefault strategy(false,5,5);
     3588      CbcStrategyDefault strategy(0,5,5);
    35643589      strategy.setupPreProcessing(1,0);
    35653590      model2.setStrategy(strategy);
     
    37213746     It should only have one solver known to it.
    37223747  */
     3748  CoinMessageHandler * generalMessageHandler = model_.messageHandler();
     3749  generalMessageHandler->setPrefix(false);
     3750#ifndef CBC_OTHER_SOLVER
    37233751  OsiClpSolverInterface * originalSolver = dynamic_cast<OsiClpSolverInterface *> (model_.solver());
    37243752  assert (originalSolver);
    3725   CoinMessageHandler * generalMessageHandler = model_.messageHandler();
    3726   generalMessageHandler->setPrefix(false);
    37273753  // Move handler across if not default
    37283754  if (!originalSolver->defaultHandler()&&originalSolver->getModelPtr()->defaultHandler())
     
    37323758  if (originalSolver->getModelPtr()->logLevel()==0)
    37333759    noPrinting=true;
     3760#elif CBC_OTHER_SOLVER==1
     3761  OsiCpxSolverInterface * originalSolver = dynamic_cast<OsiCpxSolverInterface *> (model_.solver());
     3762  assert (originalSolver);
     3763  OsiClpSolverInterface dummySolver;
     3764  OsiCpxSolverInterface * clpSolver = originalSolver;
     3765  CoinMessages generalMessages = dummySolver.getModelPtr()->messages();
     3766  char generalPrint[10000];
     3767  noPrinting=true;
     3768#endif
    37343769#if NEW_STYLE_SOLVER==0
    37353770  bool noPrinting_=noPrinting;
     
    37713806    int complicatedInteger=0;
    37723807    OsiSolverInterface * solver = model_.solver();
     3808    if (noPrinting_)
     3809      setCbcOrClpPrinting(false);
     3810#ifndef CBC_OTHER_SOLVER
    37733811    OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    37743812    ClpSimplex * lpSolver = clpSolver->getModelPtr();
    37753813    if (noPrinting_) {
    3776       setCbcOrClpPrinting(false);
    37773814      lpSolver->setLogLevel(0);
    37783815    }
     3816#else
     3817    ClpSimplex * lpSolver = NULL;
     3818#endif
    37793819    // For priorities etc
    37803820    int * priorities=NULL;
     
    38103850          goodModel=true;
    38113851          solver = model_.solver();
     3852#ifndef CBC_OTHER_SOLVER
    38123853          clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    38133854          lpSolver = clpSolver->getModelPtr();
     3855#endif
    38143856        } else {
    38153857          printf("Bad input from user function %s\n",userFunction_[iUser]->name().c_str());
     
    39143956#ifdef COIN_HAS_LINK
    39153957      } else {
     3958#ifndef CBC_OTHER_SOLVER
    39163959        // save
    39173960        saveCoinModel = *coinModel;
     
    39714014          delete [] whichRow;
    39724015        }
     4016#endif
    39734017      }
    39744018#endif
     
    40364080    bool preSolveFile=false;
    40374081    bool strongChanged=false;
     4082    bool pumpChanged=false;
    40384083   
    40394084    double djFix=1.0e100;
     
    40724117    int slog = whichParam(SOLVERLOGLEVEL,numberParameters_,parameters_);
    40734118    int log = whichParam(LOGLEVEL,numberParameters_,parameters_);
     4119#ifndef CBC_OTHER_SOLVER
    40744120    double normalIncrement=model_.getCutoffIncrement();;
     4121#endif
    40754122    if (testOsiParameters>=0) {
    40764123      // trying nonlinear - switch off some stuff
     
    41084155    CglKnapsackCover knapsackGen;
    41094156    //knapsackGen.switchOnExpensive();
     4157    //knapsackGen.setMaxInKnapsack(100);
    41104158    // set default action (0=off,1=on,2=root)
    41114159    int knapsackAction=3;
     
    41814229#ifdef MORE_CUTS
    41824230      gomoryGen.setAwayAtRoot(0.005);
     4231      twomirGen.setAwayAtRoot(0.005);
     4232      twomirGen.setAway(0.01);
    41834233#else
    41844234      gomoryGen.setAwayAtRoot(0.01);
     4235      twomirGen.setAwayAtRoot(0.01);
     4236      twomirGen.setAway(0.01);
    41854237#endif
    41864238      int iParam;
     
    42984350        if (type==BAB&&goodModel) {
    42994351          // check if any integers
     4352#ifndef CBC_OTHER_SOLVER
    43004353#ifdef COIN_HAS_ASL
    43014354          if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
     
    43084361              !clpSolver->numberSOS()&&!model_.numberObjects()&&!clpSolver->numberObjects())
    43094362            type=DUALSIMPLEX;
     4363#endif
    43104364        }
    43114365        if (type==GENERALQUERY) {
     
    44604514              case DJFIX:
    44614515                djFix=value;
     4516#ifndef CBC_OTHER_SOLVER
    44624517                if (goodModel&&djFix<1.0e20) {
    44634518                  // do some fixing
     
    44984553                    <<CoinMessageEol;
    44994554                }
     4555#endif
    45004556                break;
    45014557              case TIGHTENFACTOR:
     
    45624618                       parameters_[iParam].type()==NUMBERBEFORE)
    45634619                strongChanged=true;
     4620              else if (parameters_[iParam].type()==FPUMPTUNE||
     4621                       parameters_[iParam].type()==FPUMPITS)
     4622                pumpChanged=true;
    45644623              else if (parameters_[iParam].type()==EXPERIMENT) {
    45654624                if (value>=1) {
     
    45864645                  parameters_[iParam].setIntValue(30);
    45874646                  iParam = whichParam(FPUMPTUNE,numberParameters_,parameters_);
    4588                   parameters_[iParam].setIntValue(8043);
     4647                  parameters_[iParam].setIntValue(1005043);
    45894648                  iParam = whichParam(PROCESSTUNE,numberParameters_,parameters_);
    45904649                  parameters_[iParam].setIntValue(6);
     
    48874946            case LOCALTREE:
    48884947            case NAIVE:
     4948            case CPX:
    48894949              defaultSettings=false; // user knows what she is doing
    48904950              break;
     
    51935253                model_.setProblemStatus(iStatus);
    51945254                model_.setSecondaryStatus(iStatus2);
    5195                 assert (lpSolver==clpSolver->getModelPtr());
     5255                //assert (lpSolver==clpSolver->getModelPtr());
    51965256                assert (clpSolver==model_.solver());
    51975257                clpSolver->setWarmStart(NULL);
     
    55215581              int logLevel = parameters_[slog].intValue();
    55225582              // Reduce printout
    5523               if (logLevel<=1)
     5583              if (logLevel<=1) {
    55245584                model_.solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
    5525               else
     5585              } else {
    55265586                model_.solver()->setHintParam(OsiDoReducePrint,false,OsiHintTry);
     5587              }
    55275588              {
    55285589                OsiSolverInterface * solver = model_.solver();
     5590#ifndef CBC_OTHER_SOLVER
    55295591                OsiClpSolverInterface * si =
    55305592                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
    55315593                assert (si != NULL);
    55325594                si->getModelPtr()->scaling(doScaling);
    5533                 statistics_nrows=si->getNumRows();
    5534                 statistics_ncols=si->getNumCols();
    5535                 statistics_nprocessedrows=si->getNumRows();
    5536                 statistics_nprocessedcols=si->getNumCols();
    55375595                ClpSimplex * lpSolver = si->getModelPtr();
    55385596                if (doVector) {
     
    55435601                  }
    55445602                }
     5603#elif CBC_OTHER_SOLVER==1
     5604                OsiCpxSolverInterface * si =
     5605                  dynamic_cast<OsiCpxSolverInterface *>(solver) ;
     5606                assert (si != NULL);
     5607#endif
     5608                statistics_nrows=si->getNumRows();
     5609                statistics_ncols=si->getNumCols();
     5610                statistics_nprocessedrows=si->getNumRows();
     5611                statistics_nprocessedcols=si->getNumCols();
    55455612                // See if quadratic
     5613#ifndef CBC_OTHER_SOLVER
    55465614#ifdef COIN_HAS_LINK
    55475615                if (!complicatedInteger) {
     
    57505818                }
    57515819#endif
     5820#endif
    57525821                if (logLevel<=1)
    57535822                  si->setHintParam(OsiDoReducePrint,true,OsiHintTry);
     5823#ifndef CBC_OTHER_SOLVER
    57545824                si->setSpecialOptions(0x40000000);
     5825#endif
    57555826              }
    57565827              if (!miplib) {
     
    57625833                model_.initialSolve();
    57635834                OsiSolverInterface * solver = model_.solver();
     5835#ifndef CBC_OTHER_SOLVER
    57645836                OsiClpSolverInterface * si =
    57655837                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     
    58045876                }
    58055877                clpSolver->setSpecialOptions(clpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
     5878#elif CBC_OTHER_SOLVER==1
     5879#endif
    58065880                if (!noPrinting_) {
    58075881                  sprintf(generalPrint,"Continuous objective value is %g - %.2f seconds",
     
    58415915                  }
    58425916                }
     5917#ifndef CBC_OTHER_SOLVER
    58435918                if (!complicatedInteger&&preProcess==0&&clpSolver->tightenPrimalBounds(0.0,0,true)!=0) {
    58445919#ifndef DISALLOW_PRINTING
     
    59276002                }
    59286003                si->resolve();  // clean up
     6004#endif
    59296005              }
    59306006              // If user made settings then use them
     
    59336009                if (!doScaling)
    59346010                  solver->setHintParam(OsiDoScale,false,OsiHintTry);
     6011#ifndef CBC_OTHER_SOLVER
    59356012                OsiClpSolverInterface * si =
    59366013                  dynamic_cast<OsiClpSolverInterface *>(solver) ;
     
    59586035                  }
    59596036                }
     6037#endif
    59606038              }
    59616039              // See if we want preprocessing
     
    59666044              delete babModel_;
    59676045              babModel_ = new CbcModel(model_);
     6046#ifndef CBC_OTHER_SOLVER
     6047              int numberChanged=0;
    59686048              OsiSolverInterface * solver3 = clpSolver->clone();
    59696049              babModel_->assignSolver(solver3);
    59706050              OsiClpSolverInterface * clpSolver2 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    5971               int numberChanged=0;
    59726051              if (clpSolver2->messageHandler()->logLevel())
    59736052                clpSolver2->messageHandler()->setLogLevel(1);
     
    59946073                lpSolver->setFactorizationFrequency(CoinMin(maximum,frequency));
    59956074              }
     6075#elif CBC_OTHER_SOLVER==1
     6076              OsiSolverInterface * solver3 = model_.solver()->clone();
     6077              babModel_->assignSolver(solver3);
     6078#endif
    59966079              time2 = CoinCpuTime();
    59976080              totalTime += time2-time1;
     
    60136096              }
    60146097              if (preProcess&&type==BAB) {
     6098#ifndef CBC_OTHER_SOLVER
    60156099                // See if sos from mps file
    60166100                if (numberSOS==0&&clpSolver->numberSOS()&&doSOS) {
     
    60446128                  }
    60456129                }
     6130#endif
    60466131                saveSolver=babModel_->solver()->clone();
    60476132                /* Do not try and produce equality cliques and
     
    61416226                    tunePreProcess = tunePreProcess % 1000;
    61426227                  }
     6228#ifndef CBC_OTHER_SOLVER
    61436229                  if (doSprint>0) {
    61446230                    // Sprint for primal solves
     
    61616247                    osiclp->getModelPtr()->setInfeasibilityCost(1.0e11);
    61626248                  }
     6249#endif
     6250#ifndef CBC_OTHER_SOLVER
    61636251                  {
    61646252                    OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (saveSolver);
     
    61736261                    osiclp->getModelPtr()->setPerturbation(savePerturbation);
    61746262                  }
     6263#elif CBC_OTHER_SOLVER==1
     6264                  solver2 = process.preProcessNonDefault(*saveSolver,translate[preProcess],numberPasses,
     6265                                                         tunePreProcess);
     6266#endif
    61756267                  integersOK=false; // We need to redo if CbcObjects exist
    61766268                  // Tell solver we are not in Branch and Cut
     
    62656357              // now tighten bounds
    62666358              if (!miplib) {
     6359#ifndef CBC_OTHER_SOLVER
    62676360                OsiClpSolverInterface * si =
    62686361                  dynamic_cast<OsiClpSolverInterface *>(babModel_->solver()) ;
     
    62866379                }
    62876380                si->resolve();
     6381#elif CBC_OTHER_SOLVER==1
     6382#endif
    62886383              }
    62896384              if (debugValues) {
     
    63286423                                                                   saveTightenedModel);
    63296424                      if (solver) {
     6425#ifndef CBC_OTHER_SOLVER
    63306426                        clpSolver = dynamic_cast< OsiClpSolverInterface*> (solver);
    63316427                        assert (clpSolver);
    63326428                        lpSolver = clpSolver->getModelPtr();
     6429#endif
    63336430                        babModel_->assignSolver(solver);
    63346431                        testOsiOptions=0;
     
    64176514              // add cut generators if wanted
    64186515              int switches[20];
     6516              int accuracyFlag[20];
    64196517              int numberGenerators=0;
    64206518              int translate[]={-100,-1,-99,-98,1,-1001,-1099,1,1,1,-1};
     
    64446542                  iAction=1;
    64456543                babModel_->addCutGenerator(&probingGen,iAction,"Probing");
     6544                accuracyFlag[numberGenerators]=5;
    64466545                switches[numberGenerators++]=0;
    64476546              }
     
    64766575                }
    64776576                babModel_->addCutGenerator(&gomoryGen,translate[gomoryAction],"Gomory");
     6577                accuracyFlag[numberGenerators]=3;
    64786578                switches[numberGenerators++]=0;
    64796579              }
     
    64866586              if (knapsackAction) {
    64876587                babModel_->addCutGenerator(&knapsackGen,translate[knapsackAction],"Knapsack");
     6588                accuracyFlag[numberGenerators]=1;
    64886589                switches[numberGenerators++]=-2;
    64896590              }
    64906591              if (redsplitAction&&!complicatedInteger) {
    64916592                babModel_->addCutGenerator(&redsplitGen,translate[redsplitAction],"Reduce-and-split");
     6593                accuracyFlag[numberGenerators]=5;
    64926594                switches[numberGenerators++]=1;
    64936595              }
    64946596              if (cliqueAction) {
    64956597                babModel_->addCutGenerator(&cliqueGen,translate[cliqueAction],"Clique");
     6598                accuracyFlag[numberGenerators]=0;
    64966599                switches[numberGenerators++]=0;
    64976600              }
    64986601              if (mixedAction) {
    64996602                babModel_->addCutGenerator(&mixedGen,translate[mixedAction],"MixedIntegerRounding2");
     6603                accuracyFlag[numberGenerators]=2;
    65006604                switches[numberGenerators++]=0;
    65016605              }
    65026606              if (flowAction) {
    65036607                babModel_->addCutGenerator(&flowGen,translate[flowAction],"FlowCover");
     6608                accuracyFlag[numberGenerators]=2;
    65046609                switches[numberGenerators++]=1;
    65056610              }
     
    65156620                }
    65166621                babModel_->addCutGenerator(&twomirGen,translate[twomirAction],"TwoMirCuts");
     6622                accuracyFlag[numberGenerators]=4;
    65176623                switches[numberGenerators++]=1;
    65186624              }
     
    65206626              if (landpAction) {
    65216627                babModel_->addCutGenerator(&landpGen,translate[landpAction],"LiftAndProject");
     6628                accuracyFlag[numberGenerators]=5;
    65226629                switches[numberGenerators++]=1;
    65236630              }
     
    65256632              if (residualCapacityAction) {
    65266633                babModel_->addCutGenerator(&residualCapacityGen,translate[residualCapacityAction],"ResidualCapacity");
     6634                accuracyFlag[numberGenerators]=5;
    65276635                switches[numberGenerators++]=1;
    65286636              }
     
    65346642                }
    65356643                babModel_->addCutGenerator(&zerohalfGen,translate[zerohalfAction],"ZeroHalf");
    6536                 switches[numberGenerators++]=0;
     6644                accuracyFlag[numberGenerators]=5;
     6645                switches[numberGenerators++]=2;
    65376646              }
    65386647#endif
     
    65496658                if (howOften==-98||howOften==-99)
    65506659                  generator->setSwitchOffIfLessThan(switches[iGenerator]);
     6660                generator->setInaccuracy(accuracyFlag[iGenerator]);
    65516661                generator->setTiming(true);
    65526662                if (cutDepth>=0)
     
    65996709              babModel_->solver()->setIntParam(OsiMaxNumIterationHotStart,
    66006710                    parameters_[whichParam(MAXHOTITS,numberParameters_,parameters_)].intValue());
     6711#ifndef CBC_OTHER_SOLVER
    66016712              OsiClpSolverInterface * osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    66026713              // go faster stripes
     
    66206731              if (!miplib&&increment==normalIncrement)
    66216732                changed=analyze( osiclp,numberChanged,increment,false,generalMessageHandler);
     6733#elif CBC_OTHER_SOLVER==1
     6734              double increment=babModel_->getCutoffIncrement();;
     6735#endif
    66226736              if (debugValues) {
    66236737                int numberColumns = babModel_->solver()->getNumCols();
     
    66756789                  <<CoinMessageEol;
    66766790              }
     6791#ifndef CBC_OTHER_SOLVER
    66776792              osiclp->setSpecialOptions(mipOptions);
     6793#elif CBC_OTHER_SOLVER==1
     6794#endif
    66786795              // probably faster to use a basis to get integer solutions
    66796796              babModel_->setSpecialOptions(babModel_->specialOptions()|2);
     
    66846801                  // try reduced model
    66856802                  babModel_->setSpecialOptions(babModel_->specialOptions()|512);
    6686                 } else if (experimentFlag==3||strategyFlag==2) {
     6803                }
     6804                if (experimentFlag==3||strategyFlag==2) {
    66876805                  // try reduced model at root
    6688                   babModel_->setSpecialOptions(babModel_->specialOptions()|2048);
     6806                  babModel_->setSpecialOptions(babModel_->specialOptions()|32768);
    66896807                }
    66906808                {
     
    67326850                    if (extra1==-7777)
    67336851                      extra1=-1;
     6852                    else if (extra1==-8888)
     6853                      extra1=1;
    67346854                    babModel_->setWhenCuts(-extra1);
    67356855                  } else if (extra1<19000) {
     
    73617481                  babModel_->setNumberBeforeTrust(0);
    73627482                if (useStrategy) {
    7363                   CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust());
     7483                  CbcStrategyDefault strategy(1,babModel_->numberStrong(),babModel_->numberBeforeTrust());
    73647484                  strategy.setupPreProcessing(1);
    73657485                  babModel_->setStrategy(strategy);
     
    75907710                malloc_stats2();
    75917711#endif
     7712#ifndef CBC_OTHER_SOLVER
    75927713                if (outputFormat==5) {
    75937714                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     
    75957716                  lpSolver->setPersistenceFlag(1);
    75967717                }
     7718#endif
    75977719#ifdef COIN_HAS_ASL
    75987720                // add in lotsizing
     
    77157837                  return returnCode;
    77167838                }
     7839#ifndef CBC_OTHER_SOLVER
    77177840                osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    77187841                lpSolver = osiclp->getModelPtr();
     7842#elif CBC_OTHER_SOLVER==1
     7843#endif
    77197844                if (experimentFlag>=1||strategyFlag>=2) {
    7720                   if (lpSolver->numberColumns()<200&&lpSolver->numberRows()<40)
     7845                  if (babModel_->solver()->getNumCols()<200&&
     7846                      babModel_->solver()->getNumRows()<40)
    77217847                    babModel_->setFastNodeDepth(-9);
    77227848                }
     
    77257851                  babModel_->setSpecialOptions(babModel_->specialOptions()|8192);
    77267852               
     7853#ifndef CBC_OTHER_SOLVER
    77277854#ifdef CLP_MULTIPLE_FACTORIZATIONS   
    77287855                int denseCode = parameters_[whichParam(DENSE,numberParameters_,parameters_)].intValue();
     
    77347861                    smallCode=40;
    77357862                }
    7736                 if (denseCode>0)
     7863                if (denseCode>0) {
    77377864                  lpSolver->factorization()->setGoDenseThreshold(denseCode);
     7865                  assert (osiclp==babModel_->solver());
     7866                  osiclp->setSpecialOptions(osiclp->specialOptions()|1024);
     7867                }
    77387868                if (smallCode>0&&smallCode>denseCode)
    77397869                  lpSolver->factorization()->setGoSmallThreshold(smallCode);
     
    77417871                //lpSolver->factorization()->goDense();
    77427872                //}
     7873#endif
    77437874#endif
    77447875#ifdef CLIQUE_ANALYSIS
     
    77917922                exit(1);
    77927923#endif
     7924                int hOp1 = parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/100000;
     7925                if (hOp1%10) {
     7926                  CbcCompareDefault compare;
     7927                  compare.setBreadthDepth(hOp1%10);
     7928                  babModel_->setNodeComparison(compare);
     7929                }
     7930#if defined(CBC_OTHER_SOLVER)||defined(COIN_HAS_CPX)
     7931                if (dynamic_cast<OsiCpxSolverInterface *> (babModel_->solver()))
     7932                  babModel_->solver()->messageHandler()->setLogLevel(0);
     7933#endif
     7934                if (parameters_[whichParam(CPX,numberParameters_,parameters_)].currentOptionAsInteger()) {
     7935                  babModel_->setSpecialOptions(babModel_->specialOptions()|16384);
     7936                  //if (babModel_->fastNodeDepth()==-1)
     7937                    babModel_->setFastNodeDepth(-2); // Use Cplex at root
     7938                }
     7939                int hOp2 = parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/10000;
     7940                if (hOp2%10) {
     7941                  babModel_->setSpecialOptions(babModel_->specialOptions()|16384);
     7942                  if (babModel_->fastNodeDepth()==-1)
     7943                    babModel_->setFastNodeDepth(-2); // Use Cplex at root
     7944                }
    77937945                babModel_->branchAndBound(statistics);
    77947946                //#define CLP_FACTORIZATION_INSTRUMENT
     
    78387990                checkSOS(babModel_, babModel_->solver());
    78397991              } else if (type==MIPLIB) {
    7840                 CbcStrategyDefault strategy(true,babModel_->numberStrong(),babModel_->numberBeforeTrust());
     7992                int typeOfCuts = babModel_->numberCutGenerators() ? 1 : -1;
     7993                CbcStrategyDefault strategy(typeOfCuts,
     7994                                            babModel_->numberStrong(),
     7995                                            babModel_->numberBeforeTrust());
    78417996                // Set up pre-processing
    78427997                int translate2[]={9999,1,1,3,2,4,5,6,6};
     
    78498004                babModel_->setThreadMode(numberThreads/100);
    78508005#endif
     8006#ifndef CBC_OTHER_SOLVER
    78518007                if (outputFormat==5) {
    78528008                  osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     
    78548010                  lpSolver->setPersistenceFlag(1);
    78558011                }
     8012#endif
    78568013                if (testOsiOptions>=0) {
    78578014                  printf("Testing OsiObject options %d\n",testOsiOptions);
     
    78668023                }
    78678024                model_ = *babModel_;
     8025#ifndef CBC_OTHER_SOLVER
     8026                {
     8027                  osiclp = dynamic_cast< OsiClpSolverInterface*> (model_.solver());
     8028                  lpSolver = osiclp->getModelPtr();
     8029                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
     8030                }
     8031#endif
    78688032                /* LL: this was done in CoinSolve.cpp: main(argc, argv).
    78698033                   I have moved it here so that the miplib directory location
     
    78868050                stuff[9]=doVector;
    78878051                stuff[10] = parameters_[whichParam(SMALLFACT,numberParameters_,parameters_)].intValue();
     8052                if (parameters_[whichParam(CPX,numberParameters_,parameters_)].currentOptionAsInteger()) {
     8053                  model_.setSpecialOptions(model_.specialOptions()|16384);
     8054                  //if (model_.fastNodeDepth()==-1)
     8055                    model_.setFastNodeDepth(-2); // Use Cplex at root
     8056                }
     8057                int hOp2 = parameters_[whichParam(HOPTIONS,numberParameters_,parameters_)].intValue()/10000;
     8058                if (hOp2%10) {
     8059                  model_.setSpecialOptions(model_.specialOptions()|16384);
     8060                  if (model_.fastNodeDepth()==-1)
     8061                    model_.setFastNodeDepth(-2); // Use Cplex at root
     8062                }
     8063                if (!pumpChanged) {
     8064                  // Make more lightweight
     8065                  for (int iHeur=0;iHeur<model_.numberHeuristics();iHeur++) {
     8066                    CbcHeuristic * heuristic = model_.heuristic(iHeur);
     8067                    CbcHeuristicFPump* pump =
     8068                      dynamic_cast<CbcHeuristicFPump*>(heuristic);
     8069                    if (pump) {
     8070                      CbcHeuristicFPump heuristic4(model_);
     8071                      heuristic4.setFractionSmall(0.5);
     8072                      heuristic4.setMaximumPasses(5);
     8073                      heuristic4.setFeasibilityPumpOptions(30);
     8074                      heuristic4.setWhen(13);
     8075                      heuristic4.setHeuristicName("feasibility pump");
     8076                      //CbcHeuristicFPump & pump2 = pump;
     8077                      *pump = heuristic4;
     8078                    }
     8079                  }
     8080                }
    78888081                int returnCode=CbcClpUnitTest(model_, dirMiplib, extra1==1,stuff);
    78898082                babModel_=NULL;
     
    78938086              }
    78948087              currentBranchModel = NULL;
     8088#ifndef CBC_OTHER_SOLVER
    78958089              osiclp = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    78968090              if (debugFile=="createAfterPre"&&babModel_->bestSolution()) {
     
    79018095                saveSolution(osiclp->getModelPtr(),"debug.file");
    79028096              }
     8097#endif
    79038098              statistics_cut_time=0.0;
    79048099              if (!noPrinting_) {
     
    79748169                  n = saveSolver->getNumCols();
    79758170                  bestSolution = new double [n];
     8171#ifndef CBC_OTHER_SOLVER
    79768172                  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
     8173#else
     8174                  OsiCpxSolverInterface * clpSolver = dynamic_cast< OsiCpxSolverInterface*> (babModel_->solver());
     8175#endif
    79778176                  // Save bounds on processed model
    79788177                  const int * originalColumns = process.originalColumns();
     
    79958194                    upper2[jColumn]=columnUpper[i];
    79968195                  }
     8196#ifndef CBC_OTHER_SOLVER
    79978197                  ClpSimplex * lpSolver = clpSolver->getModelPtr();
    79988198                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
     8199#endif
    79998200                  process.postProcess(*babModel_->solver());
    80008201                  // Solution now back in saveSolver
     
    80528253                  assert (saveSolver->isProvenOptimal());
    80538254#if NEW_STYLE_SOLVER==0
     8255#ifndef CBC_OTHER_SOLVER
    80548256                  // and original solver
    80558257                  assert (n>=originalSolver->getNumCols());
     
    80718273                  assert (originalSolver->isProvenOptimal());
    80728274#endif
     8275#endif
    80738276                  babModel_->assignSolver(saveSolver);
    80748277                  memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
     
    80848287                babModel_->setBestSolution(bestSolution,n,babModel_->getMinimizationObjValue());
    80858288#if NEW_STYLE_SOLVER==0
     8289#ifndef CBC_OTHER_SOLVER
    80868290                // and put back in very original solver
    80878291                {
     
    81078311                }
    81088312#endif
     8313#endif
    81098314                checkSOS(babModel_, babModel_->solver());
    81108315              } else if (model_.bestSolution()&&type==BAB&&model_.getMinimizationObjValue()<1.0e50&&preProcess) {
     
    81208325                memcpy(bestSolution,babModel_->solver()->getColSolution(),n*sizeof(double));
    81218326#if NEW_STYLE_SOLVER==0
     8327#ifndef CBC_OTHER_SOLVER
    81228328                // and put back in very original solver
    81238329                {
     
    81418347                }
    81428348#endif
     8349#endif
    81438350              }
     8351#ifndef CBC_OTHER_SOLVER
    81448352              if (type==STRENGTHEN&&strengthenedModel)
    81458353                clpSolver = dynamic_cast< OsiClpSolverInterface*> (strengthenedModel);
     
    81568364                delete [] changed;
    81578365              }
     8366#endif
    81588367              if (type==BAB) {
     8368#ifndef CBC_OTHER_SOLVER
    81598369                //move best solution (should be there -- but ..)
    81608370                int n = lpSolver->getNumCols();
     
    81718381                  saveSolution(lpSolver,"debug.file");
    81728382                }
     8383#else
     8384                if (bestSolution) {
     8385                  model_.solver()->setColSolution(bestSolution);
     8386                }
     8387#endif
    81738388                delete [] bestSolution;
    81748389                std::string statusName[]={"Finished","Stopped on ","Difficulties",
     
    82838498                    free(info.primalSolution);
    82848499                    if (!numberKnapsack) {
    8285                       info.primalSolution = (double *) malloc(n*sizeof(double));
     8500                      info.primalSolution = reinterpret_cast<double *> (malloc(n*sizeof(double)));
    82868501                      CoinCopyN(lpSolver->primalColumnSolution(),n,info.primalSolution);
    82878502                      int numberRows = lpSolver->numberRows();
    82888503                      free(info.dualSolution);
    8289                       info.dualSolution = (double *) malloc(numberRows*sizeof(double));
     8504                      info.dualSolution = reinterpret_cast<double *> (malloc(numberRows*sizeof(double)));
    82908505                      CoinCopyN(lpSolver->dualRowSolution(),numberRows,info.dualSolution);
    82918506                    } else {
     
    82938508                      info.dualSolution=NULL;
    82948509                      int numberColumns = saveCoinModel.numberColumns();
    8295                       info.primalSolution = (double *) malloc(numberColumns*sizeof(double));
     8510                      info.primalSolution = reinterpret_cast<double *> (malloc(numberColumns*sizeof(double)));
    82968511                      // Fills in original solution (coinModel length)
    82978512                      afterKnapsack(saveTightenedModel,  whichColumn,  knapsackStart,
     
    84498664              if (canOpen) {
    84508665                int status;
     8666#ifndef CBC_OTHER_SOLVER
    84518667                ClpSimplex * lpSolver = clpSolver->getModelPtr();
    84528668                if (!gmpl) {
     
    84618677                  status= lpSolver->readLp(fileName.c_str(),1.0e-12);
    84628678                }
     8679#else
     8680                status =clpSolver->readMps(fileName.c_str(),"");
     8681#endif
    84638682                if (!status||(status>0&&allowImportErrors)) {
     8683#ifndef CBC_OTHER_SOLVER
    84648684                  if (keepImportNames&&gmpl<=0) {
    84658685                    lengthName = lpSolver->lengthNames();
     
    84788698                      clpSolver->setInteger(i);
    84798699                  }
     8700#else
     8701                  lengthName=0;
     8702                  goodModel=true;
     8703#endif
    84808704                  time2 = CoinCpuTime();
    84818705                  totalTime += time2-time1;
     
    85038727            break;
    85048728          case MODELIN:
     8729#ifndef CBC_OTHER_SOLVER
    85058730#ifdef COIN_HAS_LINK
    85068731            {
     
    85868811            }
    85878812#endif
     8813#endif
    85888814            break;
    85898815          case EXPORT:
     
    86368862                  model2->setOptimizationDirection(1.0);
    86378863                }
     8864#ifndef CBC_OTHER_SOLVER
    86388865#ifdef COIN_HAS_ASL
    86398866                if (info.numberSos&&doSOS&&statusUserFunction_[0]) {
     
    86468873                  clpSolver->setSOSData(numberSOS,info.sosType,sosStart,sosIndices,sosReference);
    86478874                }
     8875#endif
    86488876#endif
    86498877                if (preSolve) {
     
    87739001              }
    87749002              if (canOpen) {
     9003#ifndef CBC_OTHER_SOLVER
    87759004                int values = lpSolver->readBasis(fileName.c_str());
    87769005                if (values==0)
     
    87809009                assert (lpSolver==clpSolver->getModelPtr());
    87819010                clpSolver->setWarmStart(NULL);
     9011#endif
    87829012              }
    87839013            } else {
     
    91359365                if (numberDebugValues<200) {
    91369366                  for (int i=0;i<numberDebugValues;i++) {
    9137                     if (lpSolver->isInteger(i)&&debugValues[i])
     9367                    if (clpSolver->isInteger(i)&&debugValues[i])
    91389368                      printf("%d %g\n",i,debugValues[i]);
    91399369                  }
     
    97539983              }
    97549984              if (fp) {
     9985#ifndef CBC_OTHER_SOLVER
    97559986                if (printMode!=5) {
    97569987                  // Write solution header (suggested by Luigi Poderico)
     
    977710008                  fprintf(fp, " - objective value %15.8g\n", objValue);
    977810009                }
     10010#endif
    977910011                // make fancy later on
    978010012                int iRow;
    9781                 int numberRows=lpSolver->numberRows();
    9782                 double * dualRowSolution = lpSolver->dualRowSolution();
    9783                 double * primalRowSolution =
    9784                   lpSolver->primalRowSolution();
    9785                 double * rowLower = lpSolver->rowLower();
    9786                 double * rowUpper = lpSolver->rowUpper();
    9787                 double primalTolerance = lpSolver->primalTolerance();
     10013                int numberRows=clpSolver->getNumRows();
     10014                const double * dualRowSolution = clpSolver->getRowPrice();
     10015                const double * primalRowSolution =
     10016                  clpSolver->getRowActivity();
     10017                const double * rowLower = clpSolver->getRowLower();
     10018                const double * rowUpper = clpSolver->getRowUpper();
     10019                double primalTolerance ;
     10020                clpSolver->getDblParam(OsiPrimalTolerance,primalTolerance);
    978810021                char format[6];
    978910022                sprintf(format,"%%-%ds",CoinMax(lengthName,8));
     
    991210145                }
    991310146                int iColumn;
    9914                 int numberColumns=lpSolver->numberColumns();
    9915                 double * dualColumnSolution =
    9916                   lpSolver->dualColumnSolution();
    9917                 double * primalColumnSolution =
    9918                   lpSolver->primalColumnSolution();
    9919                 double * columnLower = lpSolver->columnLower();
    9920                 double * columnUpper = lpSolver->columnUpper();
     10147                int numberColumns=clpSolver->getNumCols();
     10148                const double * dualColumnSolution =
     10149                  clpSolver->getReducedCost();
     10150                const double * primalColumnSolution =
     10151                  clpSolver->getColSolution();
     10152                const double * columnLower = clpSolver->getColLower();
     10153                const double * columnUpper = clpSolver->getColUpper();
    992110154                if (printMode!=2) {
    992210155                  if (printMode==5) {
     
    993910172                    }
    994010173                    // see if integer
    9941                     if ((!lpSolver->isInteger(iColumn)||fabs(primalColumnSolution[iColumn])<1.0e-8)
     10174                    if ((!clpSolver->isInteger(iColumn)||fabs(primalColumnSolution[iColumn])<1.0e-8)
    994210175                         &&printMode==1)
    994310176                      type=0;
     
    1012210355  if (babModel_) {
    1012310356    model_.moveInfo(*babModel_);
     10357#ifndef CBC_OTHER_SOLVER
    1012410358    OsiClpSolverInterface * clpSolver0 = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    1012510359    ClpSimplex * lpSolver0 = clpSolver0->getModelPtr();
     
    1012910363      lpSolver->moveInfo(*lpSolver0);
    1013010364    //babModel_->setModelOwnsSolver(false);
     10365#endif
    1013110366  }
    1013210367#ifdef CBC_SIG_TRAP
     
    1053010765    if (preProcess) {
    1053110766      strcpy(line[numberLines++],"5  // Preprocessing using CbcStrategy");
    10532       strcpy(line[numberLines++],"5  CbcStrategyDefault strategy(true,5,5);");
     10767      strcpy(line[numberLines++],"5  CbcStrategyDefault strategy(1,5,5);");
    1053310768      strcpy(line[numberLines++],"5  strategy.setupPreProcessing(1);");
    1053410769      strcpy(line[numberLines++],"5  cbcModel->setStrategy(strategy);");
  • trunk/Cbc/src/CbcSolver.hpp

    r847 r1132  
    88#include "CoinMessageHandler.hpp"
    99#include "OsiClpSolverInterface.hpp"
     10#if CBC_OTHER_SOLVER==1
     11#include "OsiCpxSolverInterface.hpp"
     12//typedef OsiCpxSolverInterface OsiClpSolverInterface;
     13#endif
    1014#include "CbcModel.hpp"
    1115#include "CbcOrClpParam.hpp"
  • trunk/Cbc/src/CbcStrategy.cpp

    r1121 r1132  
    8989
    9090// Default Constructor
    91 CbcStrategyDefault::CbcStrategyDefault(bool cutsOnlyAtRoot,
     91CbcStrategyDefault::CbcStrategyDefault(int cutsOnlyAtRoot,
    9292                                       int numberStrong,
    9393                                       int numberBeforeTrust,
     
    134134CbcStrategyDefault::setupCutGenerators(CbcModel & model)
    135135{
     136  if (cutsOnlyAtRoot_<0)
     137    return; // no cuts wanted
    136138  // Set up some cut generators and defaults
    137139  // Probing first as gets tight bounds on continuous
     
    592594  fprintf(fp,"0#include \"CbcStrategy.hpp\"\n");
    593595  fprintf(fp,"3  CbcStrategyDefault strategy(%s,%d,%d,%d);\n",
    594           cutsOnlyAtRoot_ ? "true" : "false",
     596          cutsOnlyAtRoot_ ? "1" : "0",
    595597          numberStrong_,
    596598          numberBeforeTrust_,
     
    601603// Default Constructor
    602604CbcStrategyDefaultSubTree::CbcStrategyDefaultSubTree(CbcModel * parent ,
    603                                                      bool cutsOnlyAtRoot,
     605                                                     int cutsOnlyAtRoot,
    604606                                       int numberStrong,
    605607                                       int numberBeforeTrust,
     
    645647{
    646648  // Set up some cut generators and defaults
     649  if (cutsOnlyAtRoot_<0)
     650    return; // no cuts wanted
    647651  // Probing first as gets tight bounds on continuous
    648652
     
    694698    }
    695699  }
    696   if (found&&howOften>=0) {
     700
     701  if (found&&(howOften>=-1||howOften==-98)) {
    697702    found=false;
    698703    for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
     
    704709      }
    705710    }
    706     if (!found)
     711    if (!found) {
     712      if (howOften==-1)
     713        howOften=-98;
     714      else if (howOften==-98)
     715        howOften=-99;
    707716      model.addCutGenerator(&generator1,setting,"Probing");
     717      CbcCutGenerator * generator =
     718        model.cutGenerator(numberGenerators);
     719      generator->setHowOften(howOften);
     720      numberGenerators++;
     721    }
    708722  }
    709723  found=false;
  • trunk/Cbc/src/CbcStrategy.hpp

    r706 r1132  
    123123
    124124  // Default Constructor
    125   CbcStrategyDefault (bool cutsOnlyAtRoot=true,
     125  CbcStrategyDefault (int cutsOnlyAtRoot=1,
    126126                      int numberStrong=5,
    127127                      int numberBeforeTrust=0,
     
    160160  // Data
    161161
    162   // Whether to do cuts only at root
    163   bool cutsOnlyAtRoot_;
     162  // Whether to do cuts only at root (-1 -> switch off totally)
     163  int cutsOnlyAtRoot_;
    164164
    165165  // How much strong branching to do
     
    197197
    198198  // Default Constructor
    199   CbcStrategyDefaultSubTree (CbcModel * parent=NULL,bool cutsOnlyAtRoot=true,
     199  CbcStrategyDefaultSubTree (CbcModel * parent=NULL,int cutsOnlyAtRoot=1,
    200200                      int numberStrong=5,
    201201                      int numberBeforeTrust=0,
     
    223223  // Parent model
    224224  CbcModel * parentModel_;
    225   // Whether to do cuts only at root
    226   bool cutsOnlyAtRoot_;
     225  // Whether to do cuts only at root (-1 -> switch off totally)
     226  int cutsOnlyAtRoot_;
    227227
    228228  // How much strong branching to do
  • trunk/Cbc/src/CbcTree.cpp

    r1121 r1132  
    449449  return best;
    450450}
     451CbcTreeArray::CbcTreeArray()
     452  : CbcTree(),
     453    lastNode_(NULL),
     454    lastNodePopped_(NULL),
     455    switches_(0)
     456{
     457}
     458CbcTreeArray::~CbcTreeArray()
     459{
     460}
     461// Copy constructor
     462CbcTreeArray::CbcTreeArray ( const CbcTreeArray & rhs)
     463  : CbcTree(rhs),
     464    lastNode_(rhs.lastNode_),
     465    lastNodePopped_(rhs.lastNodePopped_),
     466    switches_(rhs.switches_)
     467{
     468}
     469// Assignment operator
     470CbcTreeArray &
     471CbcTreeArray::operator=(const CbcTreeArray & rhs)
     472{
     473  if (this != &rhs) {
     474    CbcTree::operator=(rhs);
     475    lastNode_ = rhs.lastNode_;
     476    lastNodePopped_ = rhs.lastNodePopped_;
     477    switches_ = rhs.switches_;
     478  }
     479  return *this;
     480}
     481// Clone
     482CbcTree *
     483CbcTreeArray::clone() const
     484{
     485  return new CbcTreeArray(*this);
     486}
     487// Set comparison function and resort heap
     488void
     489CbcTreeArray::setComparison(CbcCompareBase  &compare)
     490{
     491  comparison_.test_ = &compare;
     492  std::make_heap(nodes_.begin(), nodes_.end(), comparison_);
     493}
     494
     495// Add a node to the heap
     496void
     497CbcTreeArray::push(CbcNode * x) {
     498  /*printf("push obj %g, refcount %d, left %d, pointing to %d\n",
     499         x->objectiveValue(),x->nodeInfo()->decrement(0),
     500         x->nodeInfo()->numberBranchesLeft(),x->nodeInfo()->numberPointingToThis());*/
     501  assert(x->objectiveValue()!=COIN_DBL_MAX&&x->nodeInfo());
     502  x->setOnTree(true);
     503  if (lastNode_) {
     504    if (lastNode_->nodeInfo()->parent()==x->nodeInfo()) {
     505      // x is parent of lastNode_ so put x on heap
     506      //#define CBCTREE_PRINT
     507#ifdef CBCTREE_PRINT
     508      printf("pushX x %x (%x at depth %d n %d) is parent of lastNode_ %x (%x at depth %d n %d)\n",
     509             x,x->nodeInfo(),x->depth(),x->nodeNumber(),
     510             lastNode_,lastNode_->nodeInfo(),lastNode_->depth(),lastNode_->nodeNumber());
     511#endif
     512      nodes_.push_back(x);
     513    } else {
     514      x->setNodeNumber(maximumNodeNumber_);
     515      maximumNodeNumber_++;
     516#ifdef CBCTREE_PRINT
     517      printf("pushLast x %x (%x at depth %d n %d) is parent of lastNode_ %x (%x at depth %d n %d)\n",
     518             x,x->nodeInfo(),x->depth(),x->nodeNumber(),
     519             lastNode_,lastNode_->nodeInfo(),lastNode_->depth(),lastNode_->nodeNumber());
     520#endif
     521      nodes_.push_back(lastNode_);
     522      lastNode_ = x;
     523    }
     524    std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
     525  } else {
     526    x->setNodeNumber(maximumNodeNumber_);
     527    maximumNodeNumber_++;
     528    if (x!=lastNodePopped_) {
     529      lastNode_ = x;
     530#ifdef CBCTREE_PRINT
     531      printf("pushNULL x %x (%x at depth %d n %d)\n",
     532             x,x->nodeInfo(),x->depth(),x->nodeNumber());
     533#endif
     534    } else {
     535      // means other way was infeasible
     536#ifdef CBCTREE_PRINT
     537      printf("push_other_infeasible x %x (%x at depth %d n %d)\n",
     538             x,x->nodeInfo(),x->depth(),x->nodeNumber());
     539#endif
     540      nodes_.push_back(x);
     541      std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
     542    }
     543  }
     544}
     545
     546// Test if empty *** note may be overridden
     547bool
     548CbcTreeArray::empty()
     549{
     550  return nodes_.empty()&&(lastNode_==NULL);
     551}
     552// Gets best node and takes off heap
     553CbcNode *
     554CbcTreeArray::bestNode(double cutoff)
     555{
     556  CbcNode * best = NULL;
     557  // See if we want last node or best on heap
     558  if (lastNode_) {
     559#ifdef CBCTREE_PRINT
     560    printf("Best lastNode_ %x (%x at depth %d) - nodeNumber %d obj %g\n",
     561           lastNode_,lastNode_->nodeInfo(),lastNode_->depth(),
     562           lastNode_->nodeNumber(),lastNode_->objectiveValue());
     563#endif
     564    assert (lastNode_->onTree());
     565    int nodeNumber = lastNode_->nodeNumber();
     566    bool useLastNode=false;
     567    if (nodeNumber+1==maximumNodeNumber_) {
     568      // diving - look further
     569      CbcCompareDefault * compareDefault
     570        = dynamic_cast<CbcCompareDefault *> (comparison_.test_);
     571      assert (compareDefault);
     572      double bestPossible = compareDefault->getBestPossible();
     573      double cutoff = compareDefault->getCutoff();
     574      double objValue = lastNode_->objectiveValue();
     575      if (cutoff<1.0e20) {
     576        if (objValue-bestPossible<0.999*(cutoff-bestPossible))
     577          useLastNode=true;
     578      } else {
     579        useLastNode=true;
     580      }
     581    }
     582    if (useLastNode) {
     583      lastNode_->setOnTree(false);
     584      best = lastNode_;
     585      lastNode_=NULL;
     586      assert(best->objectiveValue()!=COIN_DBL_MAX&&best->nodeInfo());
     587      if (best->objectiveValue()!=COIN_DBL_MAX&&best->nodeInfo())
     588        assert (best->nodeInfo()->numberBranchesLeft());
     589      if (best->objectiveValue()>=cutoff) {
     590        // double check in case node can change its mind!
     591        best->checkIsCutoff(cutoff);
     592      }
     593      lastNodePopped_=best;
     594      return best;
     595    } else {
     596      // put on tree
     597      nodes_.push_back(lastNode_);
     598      lastNode_->setNodeNumber(maximumNodeNumber_);
     599      maximumNodeNumber_++;
     600      lastNode_ = NULL;
     601      std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
     602    }
     603  }
     604  while (!best&&nodes_.size()) {
     605    best = nodes_.front();
     606    if (best)
     607      assert(best->objectiveValue()!=COIN_DBL_MAX&&best->nodeInfo());
     608    if (best&&best->objectiveValue()!=COIN_DBL_MAX&&best->nodeInfo())
     609      assert (best->nodeInfo()->numberBranchesLeft());
     610    if (best&&best->objectiveValue()>=cutoff) {
     611      // double check in case node can change its mind!
     612      best->checkIsCutoff(cutoff);
     613    }
     614    if (!best||best->objectiveValue()>=cutoff) {
     615      // let code get rid of it
     616      assert (best);
     617    }
     618  }
     619  lastNodePopped_=best;
     620#ifdef CBCTREE_PRINT
     621  if (best)
     622    printf("Heap returning node %x (%x at depth %d) - nodeNumber %d - obj %g\n",
     623           best,best->nodeInfo(),best->depth(),
     624           best->nodeNumber(),best->objectiveValue());
     625  else
     626    printf("Heap returning Null\n");
     627#endif
     628  if (best) {
     629    // take off
     630    std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
     631    nodes_.pop_back();
     632  }
     633#ifdef DEBUG_CBC_HEAP
     634  if (best) {
     635    int n=nodes_.size();
     636    bool good=true;
     637    for (int i=0;i<n;i++) {
     638      // temp
     639      assert (nodes_[i]);
     640      if (!comparison_.compareNodes(nodes_[i],best)) {
     641        good=false;
     642        CbcNode * x = nodes_[i];
     643        printf("i=%d x is better nun %d depth %d obj %g, best nun %d depth %d obj %g\n",i,
     644               x->numberUnsatisfied(),x->depth(),x->objectiveValue(),
     645               best->numberUnsatisfied(),best->depth(),best->objectiveValue());
     646      }
     647    }
     648    if (!good) {
     649      // compare best to all
     650      int i;
     651      for (i=0;i<n;i++) {
     652        CbcNode * x = nodes_[i];
     653        printf("i=%d x is nun %d depth %d obj %g",i,
     654               x->numberUnsatisfied(),x->depth(),x->objectiveValue());
     655        if (!comparison_.compareNodes(x,best)) {
     656          printf(" - best is worse!\n");
     657        } else {
     658          printf("\n");
     659        }
     660      }
     661      // Now compare amongst rest
     662      for (i=0;i<n;i++) {
     663        CbcNode * x = nodes_[i];
     664        printf("For i=%d ",i);
     665        for (int j=i+1;j<n;j++) {
     666          CbcNode * y = nodes_[j];
     667          if (!comparison_.compareNodes(x,y)) {
     668            printf(" b %d",j);
     669          } else {
     670            printf(" w %d",j);
     671          }
     672        }
     673        printf("\n");
     674      }
     675      assert(good);
     676    }
     677  }
     678#endif
     679  if (best)
     680    best->setOnTree(false);
     681  return best;
     682}
     683
     684double
     685CbcTreeArray::getBestPossibleObjective(){
     686  double bestPossibleObjective = 1e100;
     687  for(int i = 0 ; i < static_cast<int> (nodes_.size()) ; i++){
     688    if(nodes_[i] && nodes_[i]->objectiveValue() < bestPossibleObjective){
     689      bestPossibleObjective = nodes_[i]->objectiveValue();
     690    }
     691  }
     692  if (lastNode_) {
     693    bestPossibleObjective = CoinMin(bestPossibleObjective,lastNode_->objectiveValue());
     694  }
     695  CbcCompareDefault * compareDefault
     696    = dynamic_cast<CbcCompareDefault *> (comparison_.test_);
     697  assert (compareDefault);
     698  compareDefault->setBestPossible(bestPossibleObjective);
     699  return bestPossibleObjective;
     700}
     701/*! \brief Prune the tree using an objective function cutoff
     702
     703  This routine removes all nodes with objective worst than the
     704  specified cutoff value.
     705*/
     706
     707void
     708CbcTreeArray::cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective)
     709{
     710  int j;
     711  int nNodes = size();
     712  int lastNode = nNodes+1;
     713  CbcNode ** nodeArray = new CbcNode * [lastNode];
     714  int * depth = new int [lastNode];
     715  int k=0;
     716  int kDelete=lastNode;
     717  bestPossibleObjective = 1.0e100 ;
     718/*
     719    Destructively scan the heap. Nodes to be retained go into the front of
     720    nodeArray, nodes to be deleted into the back. Store the depth in a
     721    correlated array for nodes to be deleted.
     722*/
     723  for (j=0;j<nNodes;j++) {
     724    CbcNode * node = nodes_.front();
     725    nodes_.front()->setOnTree(false);
     726    std::pop_heap(nodes_.begin(), nodes_.end(), comparison_);
     727    nodes_.pop_back();
     728    double value = node ? node->objectiveValue() : COIN_DBL_MAX;
     729    if (node&&value>=cutoff) {
     730      // double check in case node can change its mind!
     731      value=node->checkIsCutoff(cutoff);
     732    }
     733    if (value >= cutoff||!node->active()) {
     734      if (node) {
     735        nodeArray[--kDelete] = node;
     736        depth[kDelete] = node->depth();
     737      }
     738    } else {
     739      bestPossibleObjective = CoinMin(bestPossibleObjective,value);
     740      nodeArray[k++]=node;
     741    }
     742  }
     743  if (lastNode_) {
     744    double value = lastNode_->objectiveValue();
     745    bestPossibleObjective = CoinMin(bestPossibleObjective,value);
     746    if (value >= cutoff||!lastNode_->active()) {
     747      nodeArray[--kDelete] = lastNode_;
     748      depth[kDelete] = lastNode_->depth();
     749      lastNode_=NULL;
     750    }
     751  }
     752  CbcCompareDefault * compareDefault
     753    = dynamic_cast<CbcCompareDefault *> (comparison_.test_);
     754  assert (compareDefault);
     755  compareDefault->setBestPossible(bestPossibleObjective);
     756  compareDefault->setCutoff(cutoff);
     757/*
     758  Rebuild the heap using the retained nodes.
     759*/
     760  for (j=0;j<k;j++) {
     761    CbcNode * node = nodeArray[j];
     762    node->setOnTree(true);
     763    nodes_.push_back(node);
     764    std::push_heap(nodes_.begin(), nodes_.end(), comparison_);
     765  }
     766/*
     767  Sort the list of nodes to be deleted, nondecreasing.
     768*/
     769  CoinSort_2(depth+kDelete,depth+lastNode,nodeArray+kDelete);
     770/*
     771  Work back from deepest to shallowest. In spite of the name, addCuts1 is
     772  just a preparatory step. When it returns, the following will be true:
     773    * all cuts are removed from the solver's copy of the constraint system;
     774    * lastws will be a basis appropriate for the specified node;
     775    * variable bounds will be adjusted to be appropriate for the specified
     776      node;
     777    * addedCuts_ (returned via addedCuts()) will contain a list of cuts that
     778      should be added to the constraint system at this node (but they have
     779      not actually been added).
     780  Then we scan the cut list for the node. Decrement the reference count
     781  for the cut, and if it's gone to 0, really delete it.
     782
     783  I don't yet see why the checks for status != basic and addedCuts_[i] != 0
     784  are necessary. When reconstructing a node, these checks are used to skip
     785  over loose cuts, excluding them from the reconstituted basis. But here
     786  we're just interested in correcting the reference count. Tight/loose should
     787  make no difference.
     788
     789  Arguably a separate routine should be used in place of addCuts1. It's doing
     790  more work than needed, modifying the model to match a subproblem at a node
     791  that will be discarded.  Then again, we seem to need the basis.
     792*/
     793  for (j=lastNode-1;j >= kDelete;j--) {
     794    CbcNode * node = nodeArray[j];
     795    CoinWarmStartBasis *lastws = model->getEmptyBasis() ;
     796   
     797    model->addCuts1(node,lastws);
     798    // Decrement cut counts
     799    assert (node);
     800    //assert (node->nodeInfo());
     801    int numberLeft = (node->nodeInfo()) ? node->nodeInfo()->numberBranchesLeft() : 0;
     802    int i;
     803    for (i=0;i<model->currentNumberCuts();i++) {
     804      // take off node
     805      CoinWarmStartBasis::Status status =
     806        lastws->getArtifStatus(i+model->numberRowsAtContinuous());
     807      if (status != CoinWarmStartBasis::basic&&
     808          model->addedCuts()[i]) {
     809        if (!model->addedCuts()[i]->decrement(numberLeft))
     810          delete model->addedCuts()[i];
     811      }
     812    }
     813    // node should not have anything pointing to it
     814    if (node->nodeInfo())   
     815      node->nodeInfo()->throwAway();
     816    delete node ;
     817    delete lastws ;
     818  }
     819  delete [] nodeArray;
     820  delete [] depth;
     821}
    451822#else
    452823// Set comparison function and resort heap
  • trunk/Cbc/src/CbcTree.hpp

    r940 r1132  
    144144  int * newBound_;
    145145};
     146/*! \class tree
     147    \brief Implementation of live set as a managed array.
     148
     149    This class is used to hold the set of live nodes in the search tree.
     150*/
     151
     152class CbcTreeArray : public CbcTree {
     153
     154public:
     155
     156  // Default Constructor
     157  CbcTreeArray ();
     158
     159  // Copy constructor
     160  CbcTreeArray ( const CbcTreeArray & rhs);
     161  // = operator
     162  CbcTreeArray & operator=(const CbcTreeArray & rhs);
     163   
     164  virtual ~CbcTreeArray();
     165
     166  /// Clone
     167  virtual CbcTree * clone() const;
     168  /// Create C++ lines to get to current state
     169  virtual void generateCpp( FILE * fp) {}
     170
     171/*! \name Heap access and maintenance methods */
     172//@{
     173
     174  /// Set comparison function and resort heap
     175  void setComparison(CbcCompareBase  &compare);
     176
     177  /// Add a node to the heap
     178  virtual void push(CbcNode * x);
     179
     180  /// Gets best node and takes off heap
     181  virtual CbcNode * bestNode(double cutoff);
     182
     183//@}
     184/*! \name vector methods */
     185//@{
     186
     187  /// Test if empty *** note may be overridden
     188  virtual bool empty() ;
     189
     190//@}
     191
     192/*! \name Search tree maintenance */
     193//@{
     194
     195/*! \brief Prune the tree using an objective function cutoff
     196
     197  This routine removes all nodes with objective worst than the
     198  specified cutoff value.
     199  It also sets bestPossibleObjective to best
     200  of all on tree before deleting.
     201*/
     202
     203  void cleanTree(CbcModel * model, double cutoff, double & bestPossibleObjective);
     204  /// Get best possible objective function in the tree
     205  virtual double getBestPossibleObjective();
     206//@}
     207protected:
     208  /// Returns
     209  /// Last node
     210  CbcNode * lastNode_;
     211  /// Last node popped
     212  CbcNode * lastNodePopped_;
     213  /// Not used yet
     214  int switches_;
     215
     216};
    146217
    147218/// New style
  • trunk/Cbc/src/CoinSolve.cpp

    r931 r1132  
    77#include "CbcOrClpParam.hpp"
    88#include "OsiClpSolverInterface.hpp"
     9#ifdef CPX_KEEP_RESULTS
     10#define CBC_OTHER_SOLVER 1
     11#endif
     12#if CBC_OTHER_SOLVER==1
     13#include "OsiCpxSolverInterface.hpp"
     14#endif
    915
    1016#include <cassert>
     
    2531#endif
    2632#endif
     33#ifdef CBC_OTHER_SOLVER
     34#undef NEW_STYLE_SOLVER
     35#define NEW_STYLE_SOLVER 0
     36#endif
    2737#if NEW_STYLE_SOLVER==0
    2838  // define TEST_MESSAGE_HANDLER to check works on all messages
     
    206216int main (int argc, const char *argv[])
    207217{
     218#ifndef CBC_OTHER_SOLVER
    208219  OsiClpSolverInterface solver1;
     220#elif CBC_OTHER_SOLVER==1
     221  OsiCpxSolverInterface solver1;
     222#endif
    209223  CbcModel model(solver1);
    210224  // define TEST_MESSAGE_HANDLER at top of file to check works on all messages
  • trunk/Cbc/src/Makefile.am

    r1121 r1132  
    121121LIBS  += `cat $(CLPOBJDIR)/clp_addlibs.txt`
    122122
     123if COIN_HAS_CPX
     124  AM_CPPFLAGS += -I`$(CYGPATH_W) $(CPXINCDIR)` \
     125        -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiCpx`
     126  cbc_LDADD += $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
     127endif
     128
    123129# If we have the Ampl solver library, we need to add additional things
    124130if COIN_HAS_ASL
     
    173179  AM_CPPFLAGS += -I`$(CYGPATH_W) $(CPXINCDIR)` \
    174180        -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiCpx`
    175   cbc_generic_LDADD += $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
     181  cbc_generic_LDADD += $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la 
    176182endif
    177183
  • trunk/Cbc/src/Makefile.in

    r1121 r1132  
    6161
    6262@COIN_HAS_CLP_TRUE@am__append_3 = `cat $(CLPOBJDIR)/clp_addlibs.txt`
     63@COIN_HAS_CLP_TRUE@@COIN_HAS_CPX_TRUE@am__append_4 = -I`$(CYGPATH_W) $(CPXINCDIR)` \
     64@COIN_HAS_CLP_TRUE@@COIN_HAS_CPX_TRUE@  -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiCpx`
     65
     66@COIN_HAS_CLP_TRUE@@COIN_HAS_CPX_TRUE@am__append_5 = $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
    6367
    6468# If we have the Ampl solver library, we need to add additional things
    6569#cbc_SOURCES += Cbc_ampl.cpp Cbc_ampl.h
    66 @COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@am__append_4 = $(ASLLIB)
    67 @COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@am__append_5 = $(ASL_CPPFLAGS) -DCOIN_HAS_ASL
     70@COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@am__append_6 = $(ASLLIB)
     71@COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@am__append_7 = $(ASL_CPPFLAGS) -DCOIN_HAS_ASL
    6872
    6973########################################################################
     
    7377# Name of the executable compiled in this directory.  We want it to be
    7478# installed in the 'bin' directory
    75 @CBC_BUILD_CBC_GENERIC_TRUE@am__append_6 = cbc-generic
     79@CBC_BUILD_CBC_GENERIC_TRUE@am__append_8 = cbc-generic
    7680
    7781# List all additionally required solver and Osi libraries
    78 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__append_7 = -I`$(CYGPATH_W) $(CLPSRCDIR)/src` \
     82@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__append_9 = -I`$(CYGPATH_W) $(CLPSRCDIR)/src` \
    7983@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiClp` \
    8084@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@ -I`$(CYGPATH_W) $(CLPOBJDIR)/inc`
    8185
    82 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__append_8 = $(OSIOBJDIR)/src/OsiClp/libOsiClp.la \
     86@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__append_10 = $(OSIOBJDIR)/src/OsiClp/libOsiClp.la \
    8387@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@ $(CLPOBJDIR)/src/libClp.la
    8488
    85 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__append_9 = `cat $(CLPOBJDIR)/clp_addlibs.txt`
    86 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@am__append_10 = -I`$(CYGPATH_W) $(CPXINCDIR)` \
     89@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__append_11 = `cat $(CLPOBJDIR)/clp_addlibs.txt`
     90@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@am__append_12 = -I`$(CYGPATH_W) $(CPXINCDIR)` \
    8791@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiCpx`
    8892
    89 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@am__append_11 = $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
    90 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__append_12 = -I`$(CYGPATH_W) $(DYLPSRCDIR)/src/DylpStdLib` \
     93@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@am__append_13 = $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
     94@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__append_14 = -I`$(CYGPATH_W) $(DYLPSRCDIR)/src/DylpStdLib` \
    9195@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@        -I`$(CYGPATH_W) $(DYLPSRCDIR)/src/Dylp` \
    9296@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@        -I`$(CYGPATH_W) $(DYLPOBJDIR)/inc` \
    9397@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@        -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiDylp`
    9498
    95 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__append_13 = $(OSIOBJDIR)/src/OsiDylp/libOsiDylp.la \
     99@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__append_15 = $(OSIOBJDIR)/src/OsiDylp/libOsiDylp.la \
    96100@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@        $(DYLPOBJDIR)/src/Dylp/libDylp.la
    97101
    98 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__append_14 = `cat $(DYLPOBJDIR)/dylp_addlibs.txt`
    99 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_FMP_TRUE@am__append_15 = -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiFmp`
    100 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_FMP_TRUE@am__append_16 = $(OSIOBJDIR)/src/OsiFmp/libOsiFmp.la
    101 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@am__append_17 = -I`$(CYGPATH_W) $(GLPKINCDIR)` \
     102@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__append_16 = `cat $(DYLPOBJDIR)/dylp_addlibs.txt`
     103@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_FMP_TRUE@am__append_17 = -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiFmp`
     104@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_FMP_TRUE@am__append_18 = $(OSIOBJDIR)/src/OsiFmp/libOsiFmp.la
     105@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@am__append_19 = -I`$(CYGPATH_W) $(GLPKINCDIR)` \
    102106@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@        -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiGlpk`
    103107
    104 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@am__append_18 = $(OSIOBJDIR)/src/OsiGlpk/libOsiGlpk.la
    105 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@am__append_19 = -I`$(CYGPATH_W) $(MSKINCDIR)` \
     108@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@am__append_20 = $(OSIOBJDIR)/src/OsiGlpk/libOsiGlpk.la
     109@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@am__append_21 = -I`$(CYGPATH_W) $(MSKINCDIR)` \
    106110@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiMsk`
    107111
    108 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@am__append_20 = $(OSIOBJDIR)/src/OsiMsk/libOsiMsk.la
    109 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@am__append_21 = -I`$(CYGPATH_W) $(OSLINCDIR)` \
     112@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@am__append_22 = $(OSIOBJDIR)/src/OsiMsk/libOsiMsk.la
     113@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@am__append_23 = -I`$(CYGPATH_W) $(OSLINCDIR)` \
    110114@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiOsl`
    111115
    112 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@am__append_22 = $(OSIOBJDIR)/src/OsiOsl/libOsiOsl.la
    113 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@am__append_23 = -I`$(CYGPATH_W) $(SPXINCDIR)` \
     116@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@am__append_24 = $(OSIOBJDIR)/src/OsiOsl/libOsiOsl.la
     117@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@am__append_25 = -I`$(CYGPATH_W) $(SPXINCDIR)` \
    114118@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiSpx`
    115119
    116 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@am__append_24 = $(OSIOBJDIR)/src/OsiSpx/libOsiSpx.la
    117 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__append_25 = -I`$(CYGPATH_W) $(SYMPHONYSRCDIR)/src` \
     120@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@am__append_26 = $(OSIOBJDIR)/src/OsiSpx/libOsiSpx.la
     121@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__append_27 = -I`$(CYGPATH_W) $(SYMPHONYSRCDIR)/src` \
    118122@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@    -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiSym`
    119123
    120 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__append_26 = $(OSIOBJDIR)/src/OsiSym/libOsiSym.la \
     124@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__append_28 = $(OSIOBJDIR)/src/OsiSym/libOsiSym.la \
    121125@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@    $(SYMPHONYOBJDIR)/src/libSym.la
    122126
    123 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__append_27 = `cat $(SYMPHONYOBJDIR)/sym_addlibs.txt`
    124 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__append_28 = -I`$(CYGPATH_W) $(VOLSRCDIR)/src` \
     127@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__append_29 = `cat $(SYMPHONYOBJDIR)/sym_addlibs.txt`
     128@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__append_30 = -I`$(CYGPATH_W) $(VOLSRCDIR)/src` \
    125129@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiVol`
    126130
    127 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__append_29 = $(OSIOBJDIR)/src/OsiVol/libOsiVol.la \
     131@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__append_31 = $(OSIOBJDIR)/src/OsiVol/libOsiVol.la \
    128132@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@ $(VOLOBJDIR)/src/libVol.la
    129133
    130 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__append_30 = `cat $(VOLOBJDIR)/vol_addlibs.txt`
    131 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@am__append_31 = -I`$(CYGPATH_W) $(XPRINCDIR)` \
     134@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__append_32 = `cat $(VOLOBJDIR)/vol_addlibs.txt`
     135@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@am__append_33 = -I`$(CYGPATH_W) $(XPRINCDIR)` \
    132136@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@ -I`$(CYGPATH_W) $(OSISRCDIR)/src/OsiXpr`
    133137
    134 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@am__append_32 = $(OSIOBJDIR)/src/OsiXpr/libOsiXpr.la
    135 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_ASL_TRUE@am__append_33 = $(ASLLIB)
    136 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_ASL_TRUE@am__append_34 = $(ASL_CPPFLAGS) -DCOIN_HAS_ASL
     138@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@am__append_34 = $(OSIOBJDIR)/src/OsiXpr/libOsiXpr.la
     139@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_ASL_TRUE@am__append_35 = $(ASLLIB)
     140@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_ASL_TRUE@am__append_36 = $(ASL_CPPFLAGS) -DCOIN_HAS_ASL
    137141subdir = src
    138142DIST_COMMON = $(includecoin_HEADERS) $(srcdir)/Makefile.am \
     
    182186@COIN_HAS_CLP_TRUE@am_cbc_OBJECTS = CoinSolve.$(OBJEXT)
    183187cbc_OBJECTS = $(am_cbc_OBJECTS)
    184 am__DEPENDENCIES_1 =
    185 @COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@am__DEPENDENCIES_2 =  \
    186 @COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@  $(am__DEPENDENCIES_1)
     188@COIN_HAS_CLP_TRUE@@COIN_HAS_CPX_TRUE@am__DEPENDENCIES_1 = $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
     189am__DEPENDENCIES_2 =
     190@COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@am__DEPENDENCIES_3 =  \
     191@COIN_HAS_ASL_TRUE@@COIN_HAS_CLP_TRUE@  $(am__DEPENDENCIES_2)
    187192@COIN_HAS_CLP_TRUE@cbc_DEPENDENCIES = libCbcSolver.la libCbc.la \
    188193@COIN_HAS_CLP_TRUE@     $(CGLOBJDIR)/src/libCgl.la \
     
    191196@COIN_HAS_CLP_TRUE@     $(CLPOBJDIR)/src/libClp.la \
    192197@COIN_HAS_CLP_TRUE@     $(COINUTILSOBJDIR)/src/libCoinUtils.la \
    193 @COIN_HAS_CLP_TRUE@     $(am__DEPENDENCIES_2)
     198@COIN_HAS_CLP_TRUE@     $(am__DEPENDENCIES_1) $(am__DEPENDENCIES_3)
    194199am__cbc_generic_SOURCES_DIST = CbcGenBaB.cpp CbcGenCbcParam.cpp \
    195200        CbcGenCbcParam.hpp CbcGenCbcParamUtils.cpp CbcGenCtlBlk.cpp \
     
    212217@CBC_BUILD_CBC_GENERIC_TRUE@    CbcGenSolvers.$(OBJEXT)
    213218cbc_generic_OBJECTS = $(am_cbc_generic_OBJECTS)
    214 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__DEPENDENCIES_3 = $(OSIOBJDIR)/src/OsiClp/libOsiClp.la \
     219@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@am__DEPENDENCIES_4 = $(OSIOBJDIR)/src/OsiClp/libOsiClp.la \
    215220@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CLP_TRUE@ $(CLPOBJDIR)/src/libClp.la
    216 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@am__DEPENDENCIES_4 = $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
    217 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__DEPENDENCIES_5 = $(OSIOBJDIR)/src/OsiDylp/libOsiDylp.la \
     221@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_CPX_TRUE@am__DEPENDENCIES_5 = $(OSIOBJDIR)/src/OsiCpx/libOsiCpx.la
     222@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@am__DEPENDENCIES_6 = $(OSIOBJDIR)/src/OsiDylp/libOsiDylp.la \
    218223@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_DYLP_TRUE@        $(DYLPOBJDIR)/src/Dylp/libDylp.la
    219 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_FMP_TRUE@am__DEPENDENCIES_6 = $(OSIOBJDIR)/src/OsiFmp/libOsiFmp.la
    220 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@am__DEPENDENCIES_7 = $(OSIOBJDIR)/src/OsiGlpk/libOsiGlpk.la
    221 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@am__DEPENDENCIES_8 = $(OSIOBJDIR)/src/OsiMsk/libOsiMsk.la
    222 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@am__DEPENDENCIES_9 = $(OSIOBJDIR)/src/OsiOsl/libOsiOsl.la
    223 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@am__DEPENDENCIES_10 = $(OSIOBJDIR)/src/OsiSpx/libOsiSpx.la
    224 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__DEPENDENCIES_11 = $(OSIOBJDIR)/src/OsiSym/libOsiSym.la \
     224@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_FMP_TRUE@am__DEPENDENCIES_7 = $(OSIOBJDIR)/src/OsiFmp/libOsiFmp.la
     225@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_GLPK_TRUE@am__DEPENDENCIES_8 = $(OSIOBJDIR)/src/OsiGlpk/libOsiGlpk.la
     226@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_MSK_TRUE@am__DEPENDENCIES_9 = $(OSIOBJDIR)/src/OsiMsk/libOsiMsk.la
     227@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_OSL_TRUE@am__DEPENDENCIES_10 = $(OSIOBJDIR)/src/OsiOsl/libOsiOsl.la
     228@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SPX_TRUE@am__DEPENDENCIES_11 = $(OSIOBJDIR)/src/OsiSpx/libOsiSpx.la
     229@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@am__DEPENDENCIES_12 = $(OSIOBJDIR)/src/OsiSym/libOsiSym.la \
    225230@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_SYMPHONY_TRUE@    $(SYMPHONYOBJDIR)/src/libSym.la
    226 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__DEPENDENCIES_12 = $(OSIOBJDIR)/src/OsiVol/libOsiVol.la \
     231@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@am__DEPENDENCIES_13 = $(OSIOBJDIR)/src/OsiVol/libOsiVol.la \
    227232@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_VOL_TRUE@ $(VOLOBJDIR)/src/libVol.la
    228 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@am__DEPENDENCIES_13 = $(OSIOBJDIR)/src/OsiXpr/libOsiXpr.la
    229 @CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_ASL_TRUE@am__DEPENDENCIES_14 = $(am__DEPENDENCIES_1)
     233@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_XPR_TRUE@am__DEPENDENCIES_14 = $(OSIOBJDIR)/src/OsiXpr/libOsiXpr.la
     234@CBC_BUILD_CBC_GENERIC_TRUE@@COIN_HAS_ASL_TRUE@am__DEPENDENCIES_15 = $(am__DEPENDENCIES_2)
    230235@CBC_BUILD_CBC_GENERIC_TRUE@cbc_generic_DEPENDENCIES =  \
    231236@CBC_BUILD_CBC_GENERIC_TRUE@    libCbcSolver.la libCbc.la \
    232237@CBC_BUILD_CBC_GENERIC_TRUE@    $(CGLOBJDIR)/src/libCgl.la \
    233 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__DEPENDENCIES_3) \
    234238@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__DEPENDENCIES_4) \
    235239@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__DEPENDENCIES_5) \
     
    243247@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__DEPENDENCIES_13) \
    244248@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__DEPENDENCIES_14) \
     249@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__DEPENDENCIES_15) \
    245250@CBC_BUILD_CBC_GENERIC_TRUE@    $(OSIOBJDIR)/src/libOsi.la \
    246251@CBC_BUILD_CBC_GENERIC_TRUE@    $(COINUTILSOBJDIR)/src/libCoinUtils.la
     
    344349CPP = @CPP@
    345350CPPFLAGS = @CPPFLAGS@
     351CPXDOCDIR = @CPXDOCDIR@
    346352CPXINCDIR = @CPXINCDIR@
    347353CPXLIB = @CPXLIB@
     354CPXOBJDIR = @CPXOBJDIR@
     355CPXSRCDIR = @CPXSRCDIR@
    348356CXX = @CXX@
    349357CXXCPP = @CXXCPP@
     
    384392        $(OSIOBJDIR)/osi_addlibs.txt` `cat \
    385393        $(COINUTILSOBJDIR)/coinutils_addlibs.txt` $(ADDLIBS) \
    386         $(am__append_3) $(am__append_9) $(am__append_14) \
    387         $(am__append_27) $(am__append_30)
     394        $(am__append_3) $(am__append_11) $(am__append_16) \
     395        $(am__append_29) $(am__append_32)
    388396LIBTOOL = @LIBTOOL@
    389397LIBTOOLM4 = @LIBTOOLM4@
     
    557565
    558566# List additional defines
    559 AM_CPPFLAGS = $(am__append_2) $(am__append_5) $(am__append_7) \
    560         $(am__append_10) $(am__append_12) $(am__append_15) \
     567AM_CPPFLAGS = $(am__append_2) $(am__append_4) $(am__append_7) \
     568        $(am__append_9) $(am__append_12) $(am__append_14) \
    561569        $(am__append_17) $(am__append_19) $(am__append_21) \
    562         $(am__append_23) $(am__append_25) $(am__append_28) \
    563         $(am__append_31) $(am__append_34) -I`$(CYGPATH_W) \
    564         $(CGLSRCDIR)/src` -I`$(CYGPATH_W) $(CGLSRCDIR)/src/CglClique` \
    565         -I`$(CYGPATH_W) $(CGLSRCDIR)/src/CglDuplicateRow` \
    566         -I`$(CYGPATH_W) $(CGLSRCDIR)/src/CglFlowCover` -I`$(CYGPATH_W) \
     570        $(am__append_23) $(am__append_25) $(am__append_27) \
     571        $(am__append_30) $(am__append_33) $(am__append_36) \
     572        -I`$(CYGPATH_W) $(CGLSRCDIR)/src` -I`$(CYGPATH_W) \
     573        $(CGLSRCDIR)/src/CglClique` -I`$(CYGPATH_W) \
     574        $(CGLSRCDIR)/src/CglDuplicateRow` -I`$(CYGPATH_W) \
     575        $(CGLSRCDIR)/src/CglFlowCover` -I`$(CYGPATH_W) \
    567576        $(CGLSRCDIR)/src/CglGomory` -I`$(CYGPATH_W) \
    568577        $(CGLSRCDIR)/src/CglKnapsackCover` -I`$(CYGPATH_W) \
     
    594603@COIN_HAS_CLP_TRUE@     $(CLPOBJDIR)/src/libClp.la \
    595604@COIN_HAS_CLP_TRUE@     $(COINUTILSOBJDIR)/src/libCoinUtils.la \
    596 @COIN_HAS_CLP_TRUE@     $(am__append_4)
     605@COIN_HAS_CLP_TRUE@     $(am__append_5) $(am__append_6)
    597606
    598607# Finally, the -rpath flag is used by libtool to make sure that the shared
     
    618627@CBC_BUILD_CBC_GENERIC_TRUE@    libCbc.la \
    619628@CBC_BUILD_CBC_GENERIC_TRUE@    $(CGLOBJDIR)/src/libCgl.la \
    620 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_8) $(am__append_11) \
    621 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_13) $(am__append_16) \
    622 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_18) $(am__append_20) \
    623 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_22) $(am__append_24) \
    624 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_26) $(am__append_29) \
    625 @CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_32) $(am__append_33) \
     629@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_10) $(am__append_13) \
     630@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_15) $(am__append_18) \
     631@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_20) $(am__append_22) \
     632@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_24) $(am__append_26) \
     633@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_28) $(am__append_31) \
     634@CBC_BUILD_CBC_GENERIC_TRUE@    $(am__append_34) $(am__append_35) \
    626635@CBC_BUILD_CBC_GENERIC_TRUE@    $(OSIOBJDIR)/src/libOsi.la \
    627636@CBC_BUILD_CBC_GENERIC_TRUE@    $(COINUTILSOBJDIR)/src/libCoinUtils.la
  • trunk/Cbc/src/unitTest.cpp

    r641 r1132  
    368368    // Create vector of solver interfaces
    369369    std::vector<OsiCbcSolverInterface*> vecSi;
    370     CbcStrategyDefault strategy(false);
     370    CbcStrategyDefault strategy(0);
    371371#   if COIN_HAS_OSL
    372372    OsiSolverInterface * oslSi = new OsiOslSolverInterface;
  • trunk/Cbc/src/unitTestClp.cpp

    r1121 r1132  
    283283    OsiClpSolverInterface * si =
    284284      dynamic_cast<OsiClpSolverInterface *>(model->solver()) ;
    285     assert (si != NULL);
    286     // get clp itself
    287     ClpSimplex * modelC = si->getModelPtr();
    288     if (stuff&&stuff[9]) {
    289       // vector matrix!
    290       ClpMatrixBase * matrix = modelC->clpMatrix();
    291       if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
    292         ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
    293         clpMatrix->makeSpecialColumnCopy();
    294       }
    295     }
    296     modelC->tightenPrimalBounds(0.0,0,true);
    297     model->initialSolve();
    298     if (modelC->dualBound()==1.0e10) {
    299       // user did not set - so modify
    300       // get largest scaled away from bound
    301       ClpSimplex temp=*modelC;
    302       temp.dual(0,7);
    303       double largestScaled=1.0e-12;
    304       double largest=1.0e-12;
    305       int numberRows = temp.numberRows();
    306       const double * rowPrimal = temp.primalRowSolution();
    307       const double * rowLower = temp.rowLower();
    308       const double * rowUpper = temp.rowUpper();
    309       const double * rowScale = temp.rowScale();
    310       int iRow;
    311       for (iRow=0;iRow<numberRows;iRow++) {
    312         double value = rowPrimal[iRow];
    313         double above = value-rowLower[iRow];
    314         double below = rowUpper[iRow]-value;
    315         if (above<1.0e12) {
    316           largest = CoinMax(largest,above);
     285    ClpSimplex * modelC = NULL;
     286    if (si) {
     287      // get clp itself
     288      modelC = si->getModelPtr();
     289      if (stuff&&stuff[9]) {
     290        // vector matrix!
     291        ClpMatrixBase * matrix = modelC->clpMatrix();
     292        if (dynamic_cast< ClpPackedMatrix*>(matrix)) {
     293          ClpPackedMatrix * clpMatrix = dynamic_cast< ClpPackedMatrix*>(matrix);
     294          clpMatrix->makeSpecialColumnCopy();
    317295        }
    318         if (below<1.0e12) {
    319           largest = CoinMax(largest,below);
     296      }
     297      modelC->tightenPrimalBounds(0.0,0,true);
     298      model->initialSolve();
     299      if (modelC->dualBound()==1.0e10) {
     300        // user did not set - so modify
     301        // get largest scaled away from bound
     302        ClpSimplex temp=*modelC;
     303        temp.dual(0,7);
     304        double largestScaled=1.0e-12;
     305        double largest=1.0e-12;
     306        int numberRows = temp.numberRows();
     307        const double * rowPrimal = temp.primalRowSolution();
     308        const double * rowLower = temp.rowLower();
     309        const double * rowUpper = temp.rowUpper();
     310        const double * rowScale = temp.rowScale();
     311        int iRow;
     312        for (iRow=0;iRow<numberRows;iRow++) {
     313          double value = rowPrimal[iRow];
     314          double above = value-rowLower[iRow];
     315          double below = rowUpper[iRow]-value;
     316          if (above<1.0e12) {
     317            largest = CoinMax(largest,above);
     318          }
     319          if (below<1.0e12) {
     320            largest = CoinMax(largest,below);
     321          }
     322          if (rowScale) {
     323            double multiplier = rowScale[iRow];
     324            above *= multiplier;
     325            below *= multiplier;
     326          }
     327          if (above<1.0e12) {
     328            largestScaled = CoinMax(largestScaled,above);
     329          }
     330          if (below<1.0e12) {
     331            largestScaled = CoinMax(largestScaled,below);
     332          }
    320333        }
    321         if (rowScale) {
    322           double multiplier = rowScale[iRow];
    323           above *= multiplier;
    324           below *= multiplier;
     334       
     335        int numberColumns = temp.numberColumns();
     336        const double * columnPrimal = temp.primalColumnSolution();
     337        const double * columnLower = temp.columnLower();
     338        const double * columnUpper = temp.columnUpper();
     339        const double * columnScale = temp.columnScale();
     340        int iColumn;
     341        for (iColumn=0;iColumn<numberColumns;iColumn++) {
     342          double value = columnPrimal[iColumn];
     343          double above = value-columnLower[iColumn];
     344          double below = columnUpper[iColumn]-value;
     345          if (above<1.0e12) {
     346            largest = CoinMax(largest,above);
     347          }
     348          if (below<1.0e12) {
     349            largest = CoinMax(largest,below);
     350          }
     351          if (columnScale) {
     352            double multiplier = 1.0/columnScale[iColumn];
     353            above *= multiplier;
     354            below *= multiplier;
     355          }
     356          if (above<1.0e12) {
     357            largestScaled = CoinMax(largestScaled,above);
     358          }
     359          if (below<1.0e12) {
     360            largestScaled = CoinMax(largestScaled,below);
     361          }
    325362        }
    326         if (above<1.0e12) {
    327           largestScaled = CoinMax(largestScaled,above);
    328         }
    329         if (below<1.0e12) {
    330           largestScaled = CoinMax(largestScaled,below);
    331         }
    332       }
    333      
    334       int numberColumns = temp.numberColumns();
    335       const double * columnPrimal = temp.primalColumnSolution();
    336       const double * columnLower = temp.columnLower();
    337       const double * columnUpper = temp.columnUpper();
    338       const double * columnScale = temp.columnScale();
    339       int iColumn;
    340       for (iColumn=0;iColumn<numberColumns;iColumn++) {
    341         double value = columnPrimal[iColumn];
    342         double above = value-columnLower[iColumn];
    343         double below = columnUpper[iColumn]-value;
    344         if (above<1.0e12) {
    345           largest = CoinMax(largest,above);
    346         }
    347         if (below<1.0e12) {
    348           largest = CoinMax(largest,below);
    349         }
    350         if (columnScale) {
    351           double multiplier = 1.0/columnScale[iColumn];
    352           above *= multiplier;
    353           below *= multiplier;
    354         }
    355         if (above<1.0e12) {
    356           largestScaled = CoinMax(largestScaled,above);
    357         }
    358         if (below<1.0e12) {
    359           largestScaled = CoinMax(largestScaled,below);
    360         }
    361       }
    362       std::cout<<"Largest (scaled) away from bound "<<largestScaled
    363                <<" unscaled "<<largest<<std::endl;
     363        std::cout<<"Largest (scaled) away from bound "<<largestScaled
     364                 <<" unscaled "<<largest<<std::endl;
    364365#if 1
    365       modelC->setDualBound(CoinMax(1.0001e8,
    366                                    CoinMin(1000.0*largestScaled,1.00001e10)));
     366        modelC->setDualBound(CoinMax(1.0001e8,
     367                                     CoinMin(1000.0*largestScaled,1.00001e10)));
    367368#else
    368       modelC->setDualBound(CoinMax(1.0001e9,
    369                                    CoinMin(1000.0*largestScaled,1.e10)));
    370 #endif
     369        modelC->setDualBound(CoinMax(1.0001e9,
     370                                     CoinMin(1000.0*largestScaled,1.e10)));
     371#endif
     372      }
    371373    }
    372374    model->setMinimumDrop(CoinMin(5.0e-2,
     
    444446      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
    445447    }
     448    if (model->getNumCols()==-10724) {
     449      // mitre
     450      std::string problemName ;
     451      model->solver()->getStrParam(OsiProbName,problemName) ;
     452      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     453    }
    446454    if (model->getNumCols()==-1224) {
    447455      //PUSH_MPS("gesa2",1392,1224,25779856.372,25476489.678,7);
     
    451459      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
    452460    }
     461    if (model->getNumCols()==-282) {
     462      //PUSH_MPS("p0282",241,282,258411,176867.50,7);
     463      // p0282
     464      std::string problemName ;
     465      model->solver()->getStrParam(OsiProbName,problemName) ;
     466      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
     467    }
    453468    if (model->getNumCols()==-141) {
    454469      // egout
     
    482497    }
    483498    setCutAndHeuristicOptions(*model);
     499    if (si) {
    484500#ifdef CLP_MULTIPLE_FACTORIZATIONS   
    485     int denseCode = stuff ? static_cast<int> (stuff[4]) : -1;
    486     int smallCode = stuff ? static_cast<int> (stuff[10]) : -1;
    487     if (stuff&&stuff[8]>=1) {
    488       if (denseCode<0)
    489         denseCode=40;
    490       if (smallCode<0)
    491         smallCode=40;
    492     }
    493     if (denseCode>0)
    494       modelC->factorization()->setGoDenseThreshold(denseCode);
    495     if (smallCode>0)
    496       modelC->factorization()->setGoSmallThreshold(smallCode);
    497     if (denseCode>=modelC->numberRows()) {
    498       printf("problem going dense\n");
    499       //modelC->factorization()->goDenseOrSmall(modelC->numberRows());
    500     }
    501 #endif
    502     if (stuff&&stuff[8]>=1) {
    503       if (modelC->numberColumns()+modelC->numberRows()<=500&&
    504           model->fastNodeDepth()==-1)
    505         model->setFastNodeDepth(-9);
     501      int denseCode = stuff ? static_cast<int> (stuff[4]) : -1;
     502      int smallCode = stuff ? static_cast<int> (stuff[10]) : -1;
     503      if (stuff&&stuff[8]>=1) {
     504        if (denseCode<0)
     505          denseCode=40;
     506        if (smallCode<0)
     507          smallCode=40;
     508      }
     509      if (denseCode>0)
     510        modelC->factorization()->setGoDenseThreshold(denseCode);
     511      if (smallCode>0)
     512        modelC->factorization()->setGoSmallThreshold(smallCode);
     513      if (denseCode>=modelC->numberRows()) {
     514        //printf("problem going dense\n");
     515        //modelC->factorization()->goDenseOrSmall(modelC->numberRows());
     516      }
     517#endif
     518      if (stuff&&stuff[8]>=1) {
     519        if (modelC->numberColumns()+modelC->numberRows()<=500&&
     520            model->fastNodeDepth()==-1)
     521          model->setFastNodeDepth(-12);
     522      }
    506523    }
    507524    //OsiObject * obj = new CbcBranchToFixLots(model,0.3,0.0,3,3000003);
Note: See TracChangeset for help on using the changeset viewer.