Changeset 1883


Ignore:
Timestamp:
Apr 6, 2013 9:33:15 AM (6 years ago)
Author:
stefan
Message:

sync with trunk rev 1882

Location:
stable/2.8/Cbc
Files:
27 edited

Legend:

Unmodified
Added
Removed
  • stable/2.8/Cbc

  • stable/2.8/Cbc/src/CbcCompareDefault.cpp

    r1854 r1883  
    138138                return equalityTest(x, y); // so ties will be broken in consistent manner
    139139        }
     140    }
     141    if (!weight_) {
     142      double testX =  x->objectiveValue() + 1.0e-9 * x->numberUnsatisfied();
     143      double testY = y->objectiveValue() + 1.0e-9 * y->numberUnsatisfied();
     144      if (testX != testY)
     145        return testX > testY;
     146      else
     147        return equalityTest(x, y); // so ties will be broken in consistent manner
    140148    }
    141149    //weight_=0.0;
  • stable/2.8/Cbc/src/CbcCountRowCut.cpp

    r1839 r1883  
    288288      hash_[i] = rhs.hash_[i];
    289289    }
    290     for (int i=0;i<size_;i++) {
     290    for (int i=0;i<numberCuts_;i++) {
    291291      if (rhs.rowCut_[i])
    292292        rowCut_[i]=new OsiRowCut2(*rhs.rowCut_[i]);
     
    318318        hash_[i] = rhs.hash_[i];
    319319      }
    320       for (int i=0;i<size_;i++) {
     320      for (int i=0;i<numberCuts_;i++) {
    321321        if (rhs.rowCut_[i])
    322322          rowCut_[i]=new OsiRowCut2(*rhs.rowCut_[i]);
  • stable/2.8/Cbc/src/CbcCutGenerator.cpp

    r1839 r1883  
    5050        numberActiveCutsAtRoot_(0),
    5151        numberShortCutsAtRoot_(0),
    52         switches_(1)
     52        switches_(1),
     53        maximumTries_(-1)
    5354{
    5455}
     
    7374        numberActiveCutsAtRoot_(0),
    7475        numberShortCutsAtRoot_(0),
    75         switches_(1)
     76        switches_(1),
     77        maximumTries_(-1)
    7678{
    7779    if (howOften < -1900) {
     
    111113    generatorName_ = CoinStrdup(rhs.generatorName_);
    112114    switches_ = rhs.switches_;
     115    maximumTries_ = rhs.maximumTries_;
    113116    timeInCutGenerator_ = rhs.timeInCutGenerator_;
    114117    savedCuts_ = rhs.savedCuts_;
     
    141144        generatorName_ = CoinStrdup(rhs.generatorName_);
    142145        switches_ = rhs.switches_;
     146        maximumTries_ = rhs.maximumTries_;
    143147        timeInCutGenerator_ = rhs.timeInCutGenerator_;
    144148        savedCuts_ = rhs.savedCuts_;
     
    202206    if (howOften == -100)
    203207        return false;
     208    int pass = model_->getCurrentPassNumber() - 1;
     209    if (maximumTries_>0) {
     210      // howOften means what it says
     211      if ((pass%howOften)!=0||depth)
     212        return false;
     213      else
     214        howOften=1;
     215    }
    204216    if (howOften > 0)
    205217        howOften = howOften % 1000000;
     
    210222    bool returnCode = false;
    211223    //OsiSolverInterface * solver = model_->solver();
    212     int pass = model_->getCurrentPassNumber() - 1;
    213224    // Reset cuts on first pass
    214225    if (!pass)
     
    287298        CglProbing* generator =
    288299            dynamic_cast<CglProbing*>(generator_);
     300        //if (!depth&&!pass)
     301        //printf("Cut generator %s when %d\n",generatorName_,whenCutGenerator_);
    289302        if (!generator) {
    290303            // Pass across model information in case it could be useful
     
    11191132        }
    11201133#endif
    1121         {
    1122             int numberRowCutsAfter = cs.sizeRowCuts() ;
    1123             if (numberRowCutsBefore < numberRowCutsAfter) {
    1124                 for (int k = numberRowCutsBefore; k < numberRowCutsAfter; k++) {
    1125                     OsiRowCut thisCut = cs.rowCut(k) ;
    1126                     int n = thisCut.row().getNumElements();
    1127                     numberElements_ += n;
    1128                 }
     1134        int numberRowCutsAfter = cs.sizeRowCuts() ;
     1135        int numberColumnCutsAfter = cs.sizeColCuts() ;
     1136        if (numberRowCutsBefore < numberRowCutsAfter) {
     1137            for (int k = numberRowCutsBefore; k < numberRowCutsAfter; k++) {
     1138                OsiRowCut thisCut = cs.rowCut(k) ;
     1139                int n = thisCut.row().getNumElements();
     1140                numberElements_ += n;
     1141            }
    11291142#ifdef JJF_ZERO
    1130                 printf("generator %s generated %d row cuts\n",
    1131                        generatorName_, numberRowCutsAfter - numberRowCutsBefore);
    1132 #endif
    1133                 numberCuts_ += numberRowCutsAfter - numberRowCutsBefore;
    1134             }
    1135             int numberColumnCutsAfter = cs.sizeColCuts() ;
    1136             if (numberColumnCutsBefore < numberColumnCutsAfter) {
     1143            printf("generator %s generated %d row cuts\n",
     1144                   generatorName_, numberRowCutsAfter - numberRowCutsBefore);
     1145#endif
     1146            numberCuts_ += numberRowCutsAfter - numberRowCutsBefore;
     1147        }
     1148        if (numberColumnCutsBefore < numberColumnCutsAfter) {
    11371149#ifdef JJF_ZERO
    1138                 printf("generator %s generated %d column cuts\n",
    1139                        generatorName_, numberColumnCutsAfter - numberColumnCutsBefore);
    1140 #endif
    1141                 numberColumnCuts_ += numberColumnCutsAfter - numberColumnCutsBefore;
    1142             }
     1150            printf("generator %s generated %d column cuts\n",
     1151                   generatorName_, numberColumnCutsAfter - numberColumnCutsBefore);
     1152#endif
     1153            numberColumnCuts_ += numberColumnCutsAfter - numberColumnCutsBefore;
    11431154        }
    11441155        if (timing())
    11451156            timeInCutGenerator_ += CoinCpuTime() - time1;
    1146 #ifdef JJF_ZERO
    11471157        // switch off if first time and no good
    1148         if (node == NULL && !pass) {
    1149             if (cs.sizeCuts() - cutsBefore < CoinAbs(switchOffIfLessThan_)) {
    1150                 whenCutGenerator_ = -99;
    1151                 whenCutGeneratorInSub_ = -200;
     1158        if (node == NULL && !pass ) {
     1159            if (numberRowCutsAfter - numberRowCutsBefore
     1160                < switchOffIfLessThan_ /*&& numberCuts_ < switchOffIfLessThan_*/) {
     1161              // switch off
     1162              maximumTries_ = 0;
     1163              whenCutGenerator_=-100;
     1164              //whenCutGenerator_ = -100;
     1165              //whenCutGeneratorInSub_ = -200;
    11521166            }
    11531167        }
    1154 #endif
     1168        if (maximumTries_>0) {
     1169          maximumTries_--;
     1170          if (!maximumTries_)
     1171            whenCutGenerator_=-100;
     1172        }
    11551173    }
    11561174    return returnCode;
  • stable/2.8/Cbc/src/CbcCutGenerator.hpp

    r1839 r1883  
    166166        return depthCutGeneratorInSub_;
    167167    }
     168    /// Set maximum number of times to enter
     169    inline void setMaximumTries(int value)
     170    { maximumTries_ = value;}
     171    /// Get maximum number of times to enter
     172    inline int maximumTries() const
     173    { return maximumTries_;}
    168174
    169175    /// Get switches (for debug)
     
    451457    /// Switches - see gets and sets
    452458    int switches_;
     459    /// Maximum number of times to enter
     460    int maximumTries_;
    453461};
    454462
  • stable/2.8/Cbc/src/CbcFollowOn.cpp

    r1854 r1883  
    2323#include "CbcFollowOn.hpp"
    2424#include "CbcBranchActual.hpp"
     25#include "CbcBranchCut.hpp"
    2526#include "CoinSort.hpp"
    2627#include "CoinError.hpp"
     
    525526//##############################################################################
    526527
     528//##############################################################################
     529
     530// Default Constructor
     531CbcIdiotBranch::CbcIdiotBranch ()
     532        : CbcObject()
     533{
     534  id_ = 1000000000 +  CutBranchingObj;
     535}
     536
     537// Useful constructor
     538CbcIdiotBranch::CbcIdiotBranch (CbcModel * model)
     539        : CbcObject(model)
     540{
     541    assert (model);
     542    id_ = 1000000000 +  CutBranchingObj;
     543}
     544
     545// Copy constructor
     546CbcIdiotBranch::CbcIdiotBranch ( const CbcIdiotBranch & rhs)
     547  : CbcObject(rhs),
     548    randomNumberGenerator_(rhs.randomNumberGenerator_),
     549    savedRandomNumberGenerator_(rhs.savedRandomNumberGenerator_)
     550{
     551}
     552
     553// Clone
     554CbcObject *
     555CbcIdiotBranch::clone() const
     556{
     557    return new CbcIdiotBranch(*this);
     558}
     559
     560// Assignment operator
     561CbcIdiotBranch &
     562CbcIdiotBranch::operator=( const CbcIdiotBranch & rhs)
     563{
     564    if (this != &rhs) {
     565        CbcObject::operator=(rhs);
     566        randomNumberGenerator_ = rhs.randomNumberGenerator_;
     567        savedRandomNumberGenerator_ = rhs.savedRandomNumberGenerator_;
     568    }
     569    return *this;
     570}
     571
     572// Destructor
     573CbcIdiotBranch::~CbcIdiotBranch ()
     574{
     575}
     576double
     577CbcIdiotBranch::infeasibility(const OsiBranchingInformation * info,
     578                           int &preferredWay) const
     579{
     580  randomNumberGenerator_ = savedRandomNumberGenerator_;
     581  double rhs = buildCut(info,0,preferredWay).ub();
     582  double fraction = rhs-floor(rhs);
     583  if (fraction>0.5)
     584    fraction=1.0-fraction;
     585  return fraction;
     586}
     587
     588// This looks at solution and sets bounds to contain solution
     589void
     590CbcIdiotBranch::feasibleRegion()
     591{
     592}
     593
     594CbcBranchingObject *
     595CbcIdiotBranch::createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way)
     596{
     597  // down and up
     598  randomNumberGenerator_ = savedRandomNumberGenerator_;
     599  int preferredWay;
     600  OsiRowCut downCut = buildCut(info,0,preferredWay);
     601  double rhs = downCut.ub();
     602  assert(rhs == downCut.lb());
     603  OsiRowCut upCut =downCut;
     604  downCut.setUb(floor(rhs));
     605  downCut.setLb(-COIN_DBL_MAX);
     606  upCut.setLb(ceil(rhs));
     607  upCut.setUb(COIN_DBL_MAX);
     608  CbcBranchingObject * branch
     609    = new CbcCutBranchingObject(model_, downCut,upCut,true);
     610  return branch;
     611}
     612// Initialize for branching
     613void
     614CbcIdiotBranch::initializeForBranching(CbcModel * )
     615{
     616  savedRandomNumberGenerator_ = randomNumberGenerator_;
     617}
     618// Build "cut"
     619OsiRowCut
     620CbcIdiotBranch::buildCut(const OsiBranchingInformation * info,int /*type*/,int & preferredWay) const
     621{
     622  int numberIntegers = model_->numberIntegers();
     623  const int * integerVariable = model_->integerVariable();
     624  int * which = new int [numberIntegers];
     625  double * away = new double [numberIntegers];
     626  const double * solution = info->solution_;
     627  const double * lower = info->lower_;
     628  const double * upper = info->upper_;
     629  double integerTolerance = model_->getIntegerTolerance();
     630  //int nMax=CoinMin(4,numberIntegers/2);
     631  int n=0;
     632  for (int i=0;i<numberIntegers;i++) {
     633    int iColumn=integerVariable[i];
     634    double value = solution[iColumn];
     635    value = CoinMax(value, lower[iColumn]);
     636    value = CoinMin(value, upper[iColumn]);
     637    //#define JUST_SMALL
     638#ifndef JUST_SMALL
     639    double nearest = floor(value + 0.5);
     640    if (fabs(value-nearest)>integerTolerance) {
     641      double random = 0.0; //0.25*randomNumberGenerator_.randomDouble();
     642      away[n]=-fabs(value-nearest)*(1.0+random);
     643      which[n++]=iColumn;
     644    }
     645#else
     646    double distanceDown = value-floor(value);
     647    if (distanceDown>10.0*integerTolerance&&distanceDown<0.1) {
     648      double random = 0.0; //0.25*randomNumberGenerator_.randomDouble();
     649      away[n]=distanceDown*(1.0+random);
     650      which[n++]=iColumn;
     651    }
     652#endif
     653  }
     654  CoinSort_2(away,away+n,which);
     655  OsiRowCut possibleCut;
     656  possibleCut.setUb(0.0);
     657  if (n>1) {
     658    int nUse=0;
     659    double useRhs=0.0;
     660    double best=0.0;
     661    double rhs = 0.0;
     662    double scaleFactor=1.0;
     663    /* should be able to be clever to find best cut
     664       maybe don't do if away >0.45
     665       maybe don't be random
     666       maybe do complete enumeration on biggest k (where sum of k >= 1.0)
     667       maybe allow +-1
     668     */
     669    for (int i=0;i<n;i++) {
     670      int iColumn=which[i];
     671      double value = solution[iColumn];
     672      value = CoinMax(value, lower[iColumn]);
     673      value = CoinMin(value, upper[iColumn]);
     674#define PLUS_MINUS
     675#ifndef PLUS_MINUS
     676      away[i]=1.0;
     677      rhs += value;
     678#else
     679      if (value-floor(value)<=0.5) {
     680        away[i]=1.0;
     681        rhs += value;
     682      } else {
     683        away[i]=-1.0;
     684        rhs -= value;
     685      }
     686#endif
     687      double nearest = floor(rhs + 0.5);
     688      double distance=fabs(rhs-nearest);
     689      // scale back
     690      distance *= scaleFactor;
     691      scaleFactor *= 0.95;
     692      if (distance>best) {
     693        nUse=i+1;
     694        best=distance;
     695        useRhs=rhs;
     696      }
     697    }
     698    // create cut
     699    if (nUse>1) {
     700      possibleCut.setRow(nUse,which,away);
     701      possibleCut.setLb(useRhs);
     702      possibleCut.setUb(useRhs);
     703    }
     704  }
     705  delete [] which;
     706  delete [] away;
     707  return possibleCut;
     708}
     709#if 0
     710//##############################################################################
     711
     712// Default Constructor
     713CbcBoundingBranchingObject::CbcBoundingBranchingObject()
     714        : CbcBranchingObject()
     715{
     716  branchCut_.setUb(0.0);
     717}
     718
     719// Useful constructor
     720CbcBoundingBranchingObject::CbcBoundingBranchingObject (CbcModel * model,
     721                                                        int way , const OsiRowCut * cut)
     722        : CbcBranchingObject(model, 0, way, 0.5)
     723{
     724  branchCut_ = *cut;
     725}
     726
     727// Copy constructor
     728CbcBoundingBranchingObject::CbcBoundingBranchingObject ( const CbcBoundingBranchingObject & rhs) : CbcBranchingObject(rhs)
     729{
     730  branchCut_ = rhs.branchCut_;
     731}
     732
     733// Assignment operator
     734CbcBoundingBranchingObject &
     735CbcBoundingBranchingObject::operator=( const CbcBoundingBranchingObject & rhs)
     736{
     737    if (this != &rhs) {
     738        CbcBranchingObject::operator=(rhs);
     739        branchCut_ = rhs.branchCut_;
     740    }
     741    return *this;
     742}
     743CbcBranchingObject *
     744CbcBoundingBranchingObject::clone() const
     745{
     746    return (new CbcBoundingBranchingObject(*this));
     747}
     748
     749
     750// Destructor
     751CbcBoundingBranchingObject::~CbcBoundingBranchingObject ()
     752{
     753}
     754double
     755CbcBoundingBranchingObject::branch()
     756{
     757    decrementNumberBranchesLeft();
     758    OsiSolverInterface * solver = model_->solver();
     759    const double * columnLower = solver->getColLower();
     760    int i;
     761    // *** for way - up means bound all those in up section
     762    if (way_ < 0) {
     763#ifdef FULL_PRINT
     764        printf("Down Bound ");
     765#endif
     766        //printf("Down Bound %d\n",numberDown_);
     767        for (i = 0; i < numberDown_; i++) {
     768            int iColumn = downList_[i];
     769            model_->solver()->setColUpper(iColumn, columnLower[iColumn]);
     770#ifdef FULL_PRINT
     771            printf("Setting bound on %d to lower bound\n", iColumn);
     772#endif
     773        }
     774        way_ = 1;         // Swap direction
     775    } else {
     776#ifdef FULL_PRINT
     777        printf("Up Bound ");
     778#endif
     779        //printf("Up Bound %d\n",numberUp_);
     780        for (i = 0; i < numberUp_; i++) {
     781            int iColumn = upList_[i];
     782            model_->solver()->setColUpper(iColumn, columnLower[iColumn]);
     783#ifdef FULL_PRINT
     784            printf("Setting bound on %d to lower bound\n", iColumn);
     785#endif
     786        }
     787        way_ = -1;        // Swap direction
     788    }
     789#ifdef FULL_PRINT
     790    printf("\n");
     791#endif
     792    return 0.0;
     793}
     794void
     795CbcBoundingBranchingObject::print()
     796{
     797  OsiRowCut cut = branchCut_;
     798  if (way_ < 0) {
     799    printf("Down Fix ");
     800    cut.setUb(floor(branchCut_.ub()));
     801    cut.setLb(-COIN_DBL_MAX);
     802  } else {
     803    printf("Up Fix ");
     804    cut.setLb(ceil(branchCut_.lb()));
     805    cut.setUb(COIN_DBL_MAX);
     806  }
     807  printf("\n");
     808  cut.print();
     809}
     810
     811/** Compare the original object of \c this with the original object of \c
     812    brObj. Assumes that there is an ordering of the original objects.
     813    This method should be invoked only if \c this and brObj are of the same
     814    type.
     815    Return negative/0/positive depending on whether \c this is
     816    smaller/same/larger than the argument.
     817*/
     818int
     819CbcBoundingBranchingObject::compareOriginalObject
     820(const CbcBranchingObject* /*brObj*/) const
     821{
     822    throw("must implement");
     823}
     824
     825/** Compare the \c this with \c brObj. \c this and \c brObj must be os the
     826    same type and must have the same original object, but they may have
     827    different feasible regions.
     828    Return the appropriate CbcRangeCompare value (first argument being the
     829    sub/superset if that's the case). In case of overlap (and if \c
     830    replaceIfOverlap is true) replace the current branching object with one
     831    whose feasible region is the overlap.
     832   */
     833CbcRangeCompare
     834CbcBoundingBranchingObject::compareBranchingObject
     835(const CbcBranchingObject* /*brObj*/, const bool /*replaceIfOverlap*/)
     836{
     837#ifdef JJF_ZERO //ndef NDEBUG
     838    const CbcBoundingBranchingObject* br =
     839        dynamic_cast<const CbcBoundingBranchingObject*>(brObj);
     840    assert(br);
     841#endif
     842    // If two BoundingBranchingObject's have the same base object then it's pretty
     843    // much guaranteed
     844    throw("must implement");
     845}
     846
     847//##############################################################################
     848
     849#endif
  • stable/2.8/Cbc/src/CbcFollowOn.hpp

    r1854 r1883  
    1010
    1111#include "CbcBranchBase.hpp"
     12#include "OsiRowCut.hpp"
     13#include "CoinHelperFunctions.hpp"
    1214#include "CoinPackedMatrix.hpp"
    1315
     
    149151};
    150152
     153/** Define an idiotic idea class.
     154    The idea of this is that we take some integer variables away from integer and
     155    sum them with some randomness to get signed sum close to 0.5.  We then can
     156    branch to exclude that gap.
     157
     158    This branching rule should be in addition to normal rules and have a high priority.
     159*/
     160
     161class CbcIdiotBranch : public CbcObject {
     162
     163public:
     164
     165    // Default Constructor
     166    CbcIdiotBranch ();
     167
     168    /** Useful constructor
     169    */
     170    CbcIdiotBranch (CbcModel * model);
     171
     172    // Copy constructor
     173    CbcIdiotBranch ( const CbcIdiotBranch &);
     174
     175    /// Clone
     176    virtual CbcObject * clone() const;
     177
     178    // Assignment operator
     179    CbcIdiotBranch & operator=( const CbcIdiotBranch& rhs);
     180
     181    // Destructor
     182    ~CbcIdiotBranch ();
     183
     184    /// Infeasibility - large is 0.5
     185    virtual double infeasibility(const OsiBranchingInformation * info,
     186                                 int &preferredWay) const;
     187
     188    using CbcObject::feasibleRegion ;
     189    /// This looks at solution and sets bounds to contain solution
     190    virtual void feasibleRegion();
     191
     192    /// Creates a branching object
     193    virtual CbcBranchingObject * createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) ;
     194    /// Initialize for branching
     195    virtual void initializeForBranching(CbcModel * );
     196protected:
     197    /// Build "cut"
     198    OsiRowCut buildCut(const OsiBranchingInformation * info,int type,int & preferredWay) const;
     199    /// data
     200    /// Thread specific random number generator
     201    mutable CoinThreadRandom randomNumberGenerator_;
     202    /// Saved version of thread specific random number generator
     203    mutable CoinThreadRandom savedRandomNumberGenerator_;
     204};
     205
    151206#endif
    152207
  • stable/2.8/Cbc/src/CbcGeneralDepth.cpp

    r1854 r1883  
    2323#include "CbcGeneralDepth.hpp"
    2424#include "CbcBranchActual.hpp"
     25#include "CbcHeuristicDive.hpp"
    2526#include "CoinSort.hpp"
    2627#include "CoinError.hpp"
     
    160161        = dynamic_cast<OsiClpSolverInterface *> (solver);
    161162        if (clpSolver) {
     163          if ((model_->moreSpecialOptions()&33554432)==0) {
    162164            ClpNodeStuff * info = nodeInfo_;
    163165            info->integerTolerance_ = model_->getIntegerTolerance();
     
    246248            simplex->setLogLevel(saveLevel);
    247249            numberNodes_ = info->nNodes_;
    248             int numberDo = numberNodes_;
    249             if (whichSolution_ >= 0)
    250                 numberDo--;
    251             if (numberDo > 0) {
    252                 return 0.5;
    253             } else {
    254                 // no solution
    255                 return COIN_DBL_MAX; // say infeasible
    256             }
     250          } else {
     251            // Try diving
     252            // See if any diving heuristics set to do dive+save
     253            CbcHeuristicDive * dive=NULL;
     254            for (int i = 0; i < model_->numberHeuristics(); i++) {
     255              CbcHeuristicDive * possible = dynamic_cast<CbcHeuristicDive *>(model_->heuristic(i));
     256              if (possible&&possible->maxSimplexIterations()==COIN_INT_MAX) {
     257                // if more than one then rotate later?
     258                //if (possible->canHeuristicRun()) {
     259                dive=possible;
     260                break;
     261              }
     262            }
     263            assert (dive); // otherwise moreSpecial should have been turned off
     264            CbcSubProblem ** nodes=NULL;
     265            int branchState=dive->fathom(model_,numberNodes_,nodes);
     266            if (branchState) {
     267              printf("new solution\n");
     268              whichSolution_=numberNodes_-1;
     269            } else {
     270              whichSolution_=-1;
     271            }
     272#if 0
     273            if (0) {
     274              for (int iNode=0;iNode<numberNodes;iNode++) {
     275                //tree_->push(nodes[iNode]) ;
     276              }
     277              assert (node->nodeInfo());
     278              if (node->nodeInfo()->numberBranchesLeft()) {
     279                tree_->push(node) ;
     280              } else {
     281                node->setActive(false);
     282              }
     283            }
     284#endif
     285            //delete [] nodes;
     286            model_->setTemporaryPointer(reinterpret_cast<void *>(nodes));
     287            // end try diving
     288          }
     289          int numberDo = numberNodes_;
     290          if (numberDo > 0 || whichSolution_ >= 0) {
     291            return 0.5;
     292          } else {
     293            // no solution
     294            return COIN_DBL_MAX; // say infeasible
     295          }
    257296        } else {
    258297            return -1.0;
     
    284323#endif
    285324CbcBranchingObject *
    286 CbcGeneralDepth::createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * /*info*/, int /*way*/)
     325CbcGeneralDepth::createCbcBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int /*way*/)
    287326{
    288327    int numberDo = numberNodes_;
    289     if (whichSolution_ >= 0)
     328    if (whichSolution_ >= 0 && (model_->moreSpecialOptions()&33554432)==0)
    290329        numberDo--;
    291330    assert (numberDo > 0);
     
    308347    ClpSimplex * simplex = clpSolver->getModelPtr();
    309348    int numberColumns = simplex->numberColumns();
    310     double * lowerBefore = CoinCopyOfArray(simplex->getColLower(),
    311                                            numberColumns);
    312     double * upperBefore = CoinCopyOfArray(simplex->getColUpper(),
    313                                            numberColumns);
    314     ClpNodeStuff * info = nodeInfo_;
    315     double * weight = new double[numberNodes_];
    316     int * whichNode = new int [numberNodes_];
    317     // Sort
    318     for (iNode = 0; iNode < numberNodes_; iNode++) {
     349    if ((model_->moreSpecialOptions()&33554432)==0) {
     350      double * lowerBefore = CoinCopyOfArray(simplex->getColLower(),
     351                                             numberColumns);
     352      double * upperBefore = CoinCopyOfArray(simplex->getColUpper(),
     353                                             numberColumns);
     354      ClpNodeStuff * info = nodeInfo_;
     355      double * weight = new double[numberNodes_];
     356      int * whichNode = new int [numberNodes_];
     357      // Sort
     358      for (iNode = 0; iNode < numberNodes_; iNode++) {
    319359        if (iNode != whichSolution_) {
    320             double objectiveValue = info->nodeInfo_[iNode]->objectiveValue();
    321             double sumInfeasibilities = info->nodeInfo_[iNode]->sumInfeasibilities();
    322             int numberInfeasibilities = info->nodeInfo_[iNode]->numberInfeasibilities();
    323             double thisWeight = 0.0;
     360          double objectiveValue = info->nodeInfo_[iNode]->objectiveValue();
     361          double sumInfeasibilities = info->nodeInfo_[iNode]->sumInfeasibilities();
     362          int numberInfeasibilities = info->nodeInfo_[iNode]->numberInfeasibilities();
     363          double thisWeight = 0.0;
    324364#if 1
    325             // just closest
    326             thisWeight = 1.0e9 * numberInfeasibilities;
    327             thisWeight += sumInfeasibilities;
    328             thisWeight += 1.0e-7 * objectiveValue;
    329             // Try estimate
    330             thisWeight = info->nodeInfo_[iNode]->estimatedSolution();
     365          // just closest
     366          thisWeight = 1.0e9 * numberInfeasibilities;
     367          thisWeight += sumInfeasibilities;
     368          thisWeight += 1.0e-7 * objectiveValue;
     369          // Try estimate
     370          thisWeight = info->nodeInfo_[iNode]->estimatedSolution();
    331371#else
    332             thisWeight = 1.0e-3 * numberInfeasibilities;
    333             thisWeight += 1.0e-5 * sumInfeasibilities;
    334             thisWeight += objectiveValue;
     372          thisWeight = 1.0e-3 * numberInfeasibilities;
     373          thisWeight += 1.0e-5 * sumInfeasibilities;
     374          thisWeight += objectiveValue;
    335375#endif
    336             whichNode[iProb] = iNode;
    337             weight[iProb++] = thisWeight;
    338         }
    339     }
    340     assert (iProb == numberDo);
    341     CoinSort_2(weight, weight + numberDo, whichNode);
    342     for (iProb = 0; iProb < numberDo; iProb++) {
     376          whichNode[iProb] = iNode;
     377          weight[iProb++] = thisWeight;
     378        }
     379      }
     380      assert (iProb == numberDo);
     381      CoinSort_2(weight, weight + numberDo, whichNode);
     382      for (iProb = 0; iProb < numberDo; iProb++) {
    343383        iNode = whichNode[iProb];
    344384        ClpNode * node = info->nodeInfo_[iNode];
     
    353393#ifdef CHECK_PATH
    354394        if (simplex->numberColumns() == numberColumns_Z) {
    355             bool onOptimal = true;
    356             const double * columnLower = simplex->columnLower();
    357             const double * columnUpper = simplex->columnUpper();
    358             for (int i = 0; i < numberColumns_Z; i++) {
    359                 if (iNode == gotGoodNode_Z)
    360                     printf("good %d %d %g %g\n", iNode, i, columnLower[i], columnUpper[i]);
    361                 if (columnUpper[i] < debuggerSolution_Z[i] || columnLower[i] > debuggerSolution_Z[i] && simplex->isInteger(i)) {
    362                     onOptimal = false;
    363                     break;
    364                 }
    365             }
    366             if (onOptimal) {
    367                 printf("adding to node %x as %d - objs\n", this, iProb);
    368                 for (int j = 0; j <= iProb; j++)
    369                     printf("%d %g\n", j, sub[j].objectiveValue_);
    370             }
     395          bool onOptimal = true;
     396          const double * columnLower = simplex->columnLower();
     397          const double * columnUpper = simplex->columnUpper();
     398          for (int i = 0; i < numberColumns_Z; i++) {
     399            if (iNode == gotGoodNode_Z)
     400              printf("good %d %d %g %g\n", iNode, i, columnLower[i], columnUpper[i]);
     401            if (columnUpper[i] < debuggerSolution_Z[i] || columnLower[i] > debuggerSolution_Z[i] && simplex->isInteger(i)) {
     402              onOptimal = false;
     403              break;
     404            }
     405          }
     406          if (onOptimal) {
     407            printf("adding to node %x as %d - objs\n", this, iProb);
     408            for (int j = 0; j <= iProb; j++)
     409              printf("%d %g\n", j, sub[j].objectiveValue_);
     410          }
    371411        }
    372412#endif
    373     }
    374     delete [] weight;
    375     delete [] whichNode;
    376     const double * lower = solver->getColLower();
    377     const double * upper = solver->getColUpper();
    378     // restore bounds
    379     for ( int j = 0; j < numberColumns; j++) {
     413      }
     414      delete [] weight;
     415      delete [] whichNode;
     416      const double * lower = solver->getColLower();
     417      const double * upper = solver->getColUpper();
     418      // restore bounds
     419      for ( int j = 0; j < numberColumns; j++) {
    380420        if (lowerBefore[j] != lower[j])
    381             solver->setColLower(j, lowerBefore[j]);
     421          solver->setColLower(j, lowerBefore[j]);
    382422        if (upperBefore[j] != upper[j])
    383             solver->setColUpper(j, upperBefore[j]);
    384     }
    385     delete [] upperBefore;
    386     delete [] lowerBefore;
     423          solver->setColUpper(j, upperBefore[j]);
     424      }
     425      delete [] upperBefore;
     426      delete [] lowerBefore;
     427    } else {
     428      // from diving
     429      CbcSubProblem ** nodes = reinterpret_cast<CbcSubProblem **>
     430        (model_->temporaryPointer());
     431      assert (nodes);
     432      int adjustDepth=info->depth_;
     433      assert (numberDo);
     434      numberNodes_=0;
     435      for (iProb = 0; iProb < numberDo; iProb++) {
     436        if ((nodes[iProb]->problemStatus_&2)==0) {
     437          // create subproblem (and swap way and/or make inactive)
     438          sub[numberNodes_].takeOver(*nodes[iProb],true);
     439          // but adjust depth
     440          sub[numberNodes_].depth_+=adjustDepth;
     441          numberNodes_++;
     442        }
     443        delete nodes[iProb];
     444      }
     445      branch->numberSubProblems_ = numberNodes_;
     446      branch->numberSubLeft_ = numberNodes_;
     447      branch->setNumberBranches(numberNodes_);
     448      if (!numberNodes_) {
     449        // infeasible
     450        delete branch;
     451        branch=NULL;
     452      }
     453      delete [] nodes;
     454    }
    387455    return branch;
    388456}
  • stable/2.8/Cbc/src/CbcGeneralDepth.hpp

    r1854 r1883  
    7070    inline void setMaximumDepth(int value) {
    7171        maximumDepth_ = value;
     72    }
     73    /// Return number of nodes
     74    inline int numberNodes() const {
     75        return numberNodes_;
    7276    }
    7377    /// Get which solution
  • stable/2.8/Cbc/src/CbcHeuristic.cpp

    r1865 r1883  
    470470    }
    471471    randomNumberGenerator_.setSeed(value);
     472}
     473// Get seed
     474int
     475CbcHeuristic::getSeed() const
     476{
     477  return randomNumberGenerator_.getSeed();
    472478}
    473479
     
    648654    // valueNow,numberRowsNow,numberColumnsNow,
    649655    // valueStart,numberRowsStart,numberColumnsStart);
    650     if (10*numberRowsNow < 8*numberRowsStart)
     656    if (10*numberRowsNow < 8*numberRowsStart || 10*numberColumnsNow < 7*numberColumnsStart)
    651657        return valueNow / valueStart;
    652658    else if (10*numberRowsNow < 9*numberRowsStart)
     
    826832                    }
    827833                }
    828             } else if (ratio > fractionSmall && after > 300) {
     834            } else if (ratio > fractionSmall && after > 300 && numberNodes >=0) {
    829835                returnCode = -1;
    830836            }
  • stable/2.8/Cbc/src/CbcHeuristic.hpp

    r1822 r1883  
    237237    /// Set random number generator seed
    238238    void setSeed(int value);
     239    /// Get random number generator seed
     240    int getSeed() const;
    239241    /// Sets decay factor (for howOften) on failure
    240242    inline void setDecayFactor(double value) {
  • stable/2.8/Cbc/src/CbcHeuristicDive.cpp

    r1854 r1883  
    1111#include "CbcHeuristicDive.hpp"
    1212#include "CbcStrategy.hpp"
     13#include "CbcModel.hpp"
     14#include "CbcSubProblem.hpp"
    1315#include "OsiAuxInfo.hpp"
    1416#include  "CoinTime.hpp"
     
    190192}
    191193
    192 // See if diving will give better solution
    193 // Sets value of solution
    194 // Returns 1 if solution, 0 if not
    195 int
    196 CbcHeuristicDive::solution(double & solutionValue,
    197                            double * betterSolution)
    198 {
    199     int nodeCount = model_->getNodeCount();
    200     if (feasibilityPumpOptions_>0 && (nodeCount % feasibilityPumpOptions_) != 0)
    201         return 0;
    202 #ifdef DIVE_DEBUG
    203     std::cout << "solutionValue = " << solutionValue << std::endl;
    204 #endif
    205     ++numCouldRun_;
    206 
    207     // test if the heuristic can run
    208     if (!canHeuristicRun())
    209         return 0;
    210 
    211 #ifdef JJF_ZERO
    212     // See if to do
    213     if (!when() || (when() % 10 == 1 && model_->phase() != 1) ||
    214             (when() % 10 == 2 && (model_->phase() != 2 && model_->phase() != 3)))
    215         return 0; // switched off
    216 #endif
    217 
     194// inner part of dive
     195int
     196CbcHeuristicDive::solution(double & solutionValue, int & numberNodes,
     197                           int & numberCuts, OsiRowCut ** cuts,
     198                           CbcSubProblem ** & nodes,
     199                           double * newSolution)
     200{
    218201#ifdef DIVE_DEBUG
    219202    int nRoundInfeasible = 0;
    220203    int nRoundFeasible = 0;
     204#endif
    221205    int reasonToStop = 0;
    222 #endif
    223206    double time1 = CoinCpuTime();
    224207    int numberSimplexIterations = 0;
    225208    int maxSimplexIterations = (model_->getNodeCount()) ? maxSimplexIterations_
    226209                               : maxSimplexIterationsAtRoot_;
    227 
     210    // but can't be exactly coin_int_max
     211    maxSimplexIterations = CoinMin(maxSimplexIterations,COIN_INT_MAX>>3);
    228212    OsiSolverInterface * solver = cloneBut(6); // was model_->solver()->clone();
    229213# ifdef COIN_HAS_CLP
     
    231215    = dynamic_cast<OsiClpSolverInterface *> (solver);
    232216    if (clpSolver) {
     217      ClpSimplex * clpSimplex = clpSolver->getModelPtr();
     218      int oneSolveIts = clpSimplex->maximumIterations();
     219      oneSolveIts = CoinMin(1000+2*(clpSimplex->numberRows()+clpSimplex->numberColumns()),oneSolveIts);
     220      clpSimplex->setMaximumIterations(oneSolveIts);
     221      if (!nodes) {
    233222        // say give up easily
    234         ClpSimplex * clpSimplex = clpSolver->getModelPtr();
    235223        clpSimplex->setMoreSpecialOptions(clpSimplex->moreSpecialOptions() | 64);
     224      } else {
     225        // get ray
     226        int specialOptions = clpSimplex->specialOptions();
     227        specialOptions &= ~0x3100000;
     228        specialOptions |= 32;
     229        clpSimplex->setSpecialOptions(specialOptions);
     230        clpSolver->setSpecialOptions(clpSolver->specialOptions() | 1048576);
     231        if ((model_->moreSpecialOptions()&16777216)!=0) {
     232          // cutoff is constraint
     233          clpSolver->setDblParam(OsiDualObjectiveLimit, COIN_DBL_MAX);
     234        }
     235      }
    236236    }
    237237# endif
     
    268268    // Get solution array for heuristic solution
    269269    int numberColumns = solver->getNumCols();
    270     double * newSolution = new double [numberColumns];
    271270    memcpy(newSolution, solution, numberColumns*sizeof(double));
    272271
    273272    // vectors to store the latest variables fixed at their bounds
    274273    int* columnFixed = new int [numberIntegers];
    275     double* originalBound = new double [numberIntegers];
     274    double* originalBound = new double [numberIntegers+2*numberColumns];
     275    double * lowerBefore = originalBound+numberIntegers;
     276    double * upperBefore = lowerBefore+numberColumns;
     277    memcpy(lowerBefore,lower,numberColumns*sizeof(double));
     278    memcpy(upperBefore,upper,numberColumns*sizeof(double));
     279    double * lastDjs=newSolution+numberColumns;
    276280    bool * fixedAtLowerBound = new bool [numberIntegers];
    277281    PseudoReducedCost * candidate = new PseudoReducedCost [numberIntegers];
     
    279283
    280284    int maxNumberAtBoundToFix = static_cast<int> (floor(percentageToFix_ * numberIntegers));
     285    assert (!maxNumberAtBoundToFix||!nodes);
    281286
    282287    // count how many fractional variables
     
    308313        bool canRound = selectVariableToBranch(solver, newSolution,
    309314                                               bestColumn, bestRound);
    310 
    311315        // if the solution is not trivially roundable, we don't try to round;
    312316        // if the solution is trivially roundable, we try to round. However,
     
    340344                nRoundFeasible++;
    341345#endif
    342                 // Round all the fractional variables
    343                 for (int i = 0; i < numberIntegers; i++) {
     346                if (!nodes||bestColumn<0) {
     347                  // Round all the fractional variables
     348                  for (int i = 0; i < numberIntegers; i++) {
    344349                    int iColumn = integerVariable[i];
    345350                    double value = newSolution[iColumn];
    346351                    if (fabs(floor(value + 0.5) - value) > integerTolerance) {
    347                         assert(downLocks_[i] == 0 || upLocks_[i] == 0);
    348                         if (downLocks_[i] == 0 && upLocks_[i] == 0) {
    349                             if (direction * objective[iColumn] >= 0.0)
    350                                 newSolution[iColumn] = floor(value);
    351                             else
    352                                 newSolution[iColumn] = ceil(value);
    353                         } else if (downLocks_[i] == 0)
    354                             newSolution[iColumn] = floor(value);
    355                         else
    356                             newSolution[iColumn] = ceil(value);
     352                      assert(downLocks_[i] == 0 || upLocks_[i] == 0);
     353                      if (downLocks_[i] == 0 && upLocks_[i] == 0) {
     354                        if (direction * objective[iColumn] >= 0.0)
     355                          newSolution[iColumn] = floor(value);
     356                        else
     357                          newSolution[iColumn] = ceil(value);
     358                      } else if (downLocks_[i] == 0)
     359                        newSolution[iColumn] = floor(value);
     360                      else
     361                        newSolution[iColumn] = ceil(value);
    357362                    }
    358                 }
    359                 break;
    360             }
     363                  }
     364                  break;
     365                } else {
     366                  // can't round if going to use in branching
     367                  int i;
     368                  for (i = 0; i < numberIntegers; i++) {
     369                    int iColumn = integerVariable[i];
     370                    double value = newSolution[bestColumn];
     371                    if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     372                      if (iColumn==bestColumn) {
     373                        assert(downLocks_[i] == 0 || upLocks_[i] == 0);
     374                        double obj = objective[bestColumn];
     375                        if (downLocks_[i] == 0 && upLocks_[i] == 0) {
     376                          if (direction * obj >= 0.0)
     377                            bestRound=-1;
     378                          else
     379                            bestRound=1;
     380                        } else if (downLocks_[i] == 0)
     381                          bestRound=-1;
     382                        else
     383                          bestRound=1;
     384                        break;
     385                      }
     386                    }
     387                  }
     388                }
     389            }
    361390#ifdef DIVE_DEBUG
    362391            else
     
    549578
    550579        double originalBoundBestColumn;
     580        double bestColumnValue;
     581        int whichWay;
    551582        if (bestColumn >= 0) {
     583            bestColumnValue = newSolution[bestColumn];
    552584            if (bestRound < 0) {
    553585                originalBoundBestColumn = upper[bestColumn];
    554                 solver->setColUpper(bestColumn, floor(newSolution[bestColumn]));
     586                solver->setColUpper(bestColumn, floor(bestColumnValue));
     587                whichWay=0;
    555588            } else {
    556589                originalBoundBestColumn = lower[bestColumn];
    557                 solver->setColLower(bestColumn, ceil(newSolution[bestColumn]));
     590                solver->setColLower(bestColumn, ceil(bestColumnValue));
     591                whichWay=1;
    558592            }
    559593        } else {
     
    562596        int originalBestRound = bestRound;
    563597        int saveModelOptions = model_->specialOptions();
     598       
    564599        while (1) {
    565600
     
    567602            solver->resolve();
    568603            model_->setSpecialOptions(saveModelOptions);
    569             if (!solver->isAbandoned()) {
     604            if (!solver->isAbandoned()&&!solver->isIterationLimitReached()) {
    570605                numberSimplexIterations += solver->getIterationCount();
    571606            } else {
    572607                numberSimplexIterations = maxSimplexIterations + 1;
     608                reasonToStop += 100;
    573609                break;
    574610            }
    575611
    576612            if (!solver->isProvenOptimal()) {
     613                if (nodes) {
     614                  if (solver->isProvenPrimalInfeasible()) {
     615                    if (maxSimplexIterationsAtRoot_!=COIN_INT_MAX) {
     616                      // stop now
     617                      printf("stopping on first infeasibility\n");
     618                      break;
     619                    } else if (cuts) {
     620                      // can do conflict cut
     621                      printf("could do intermediate conflict cut\n");
     622                      bool localCut;
     623                      OsiRowCut * cut = model_->conflictCut(solver,localCut);
     624                      if (cut) {
     625                        if (!localCut) {
     626                          model_->makePartialCut(cut,solver);
     627                          cuts[numberCuts++]=cut;
     628                        } else {
     629                          delete cut;
     630                        }
     631                      }
     632                    }
     633                  } else {
     634                    reasonToStop += 10;
     635                    break;
     636                  }
     637                }
    577638                if (numberAtBoundFixed > 0) {
    578639                    // Remove the bound fix for variables that were at bounds
     
    587648                } else if (bestRound == originalBestRound) {
    588649                    bestRound *= (-1);
     650                    whichWay |=2;
    589651                    if (bestRound < 0) {
    590652                        solver->setColLower(bestColumn, originalBoundBestColumn);
    591                         solver->setColUpper(bestColumn, floor(newSolution[bestColumn]));
     653                        solver->setColUpper(bestColumn, floor(bestColumnValue));
    592654                    } else {
    593                         solver->setColLower(bestColumn, ceil(newSolution[bestColumn]));
     655                        solver->setColLower(bestColumn, ceil(bestColumnValue));
    594656                        solver->setColUpper(bestColumn, originalBoundBestColumn);
    595657                    }
     
    602664        if (!solver->isProvenOptimal() ||
    603665                direction*solver->getObjValue() >= solutionValue) {
    604 #ifdef DIVE_DEBUG
    605             reasonToStop = 1;
    606 #endif
    607             break;
    608         }
    609 
    610         if (iteration > maxIterations_) {
    611 #ifdef DIVE_DEBUG
    612             reasonToStop = 2;
    613 #endif
    614             break;
    615         }
    616 
    617         if (CoinCpuTime() - time1 > maxTime_) {
    618 #ifdef DIVE_DEBUG
    619             reasonToStop = 3;
    620 #endif
    621             break;
    622         }
    623 
    624         if (numberSimplexIterations > maxSimplexIterations) {
    625 #ifdef DIVE_DEBUG
    626             reasonToStop = 4;
    627 #endif
     666            reasonToStop += 1;
     667        } else if (iteration > maxIterations_) {
     668            reasonToStop += 2;
     669        } else if (CoinCpuTime() - time1 > maxTime_) {
     670            reasonToStop += 3;
     671        } else if (numberSimplexIterations > maxSimplexIterations) {
     672            reasonToStop += 4;
    628673            // also switch off
    629674#ifdef CLP_INVESTIGATE
     
    632677#endif
    633678            when_ = 0;
    634             break;
    635         }
    636 
    637         if (solver->getIterationCount() > 1000 && iteration > 3) {
    638 #ifdef DIVE_DEBUG
    639             reasonToStop = 5;
    640 #endif
     679        } else if (solver->getIterationCount() > 1000 && iteration > 3 && !nodes) {
     680            reasonToStop += 5;
    641681            // also switch off
    642682#ifdef CLP_INVESTIGATE
     
    645685#endif
    646686            when_ = 0;
    647             break;
    648687        }
    649688
    650689        memcpy(newSolution, solution, numberColumns*sizeof(double));
    651690        numberFractionalVariables = 0;
     691        double sumFractionalVariables=0.0;
    652692        for (int i = 0; i < numberIntegers; i++) {
    653693            int iColumn = integerVariable[i];
    654694            double value = newSolution[iColumn];
    655             if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     695            double away = fabs(floor(value + 0.5) - value);
     696            if (away > integerTolerance) {
    656697                numberFractionalVariables++;
    657             }
    658         }
    659 
    660     }
    661 
    662 
    663     double * rowActivity = new double[numberRows];
    664     memset(rowActivity, 0, numberRows*sizeof(double));
    665 
     698                sumFractionalVariables += away;
     699            }
     700        }
     701        if (nodes) {
     702          // save information
     703          //branchValues[numberNodes]=bestColumnValue;
     704          //statuses[numberNodes]=whichWay+(bestColumn<<2);
     705          //bases[numberNodes]=solver->getWarmStart();
     706          ClpSimplex * simplex = clpSolver->getModelPtr();
     707          CbcSubProblem * sub =
     708            new CbcSubProblem(clpSolver,lowerBefore,upperBefore,
     709                          simplex->statusArray(),numberNodes);
     710          nodes[numberNodes]=sub;
     711          // other stuff
     712          sub->branchValue_=bestColumnValue;
     713          sub->problemStatus_=whichWay;
     714          sub->branchVariable_=bestColumn;
     715          sub->objectiveValue_ = simplex->objectiveValue();
     716          sub->sumInfeasibilities_ = sumFractionalVariables;
     717          sub->numberInfeasibilities_ = numberFractionalVariables;
     718          printf("DiveNode %d column %d way %d bvalue %g obj %g\n",
     719                 numberNodes,sub->branchVariable_,sub->problemStatus_,
     720                 sub->branchValue_,sub->objectiveValue_);
     721          numberNodes++;
     722          if (solver->isProvenOptimal()) {
     723            memcpy(lastDjs,solver->getReducedCost(),numberColumns*sizeof(double));
     724            memcpy(lowerBefore,lower,numberColumns*sizeof(double));
     725            memcpy(upperBefore,upper,numberColumns*sizeof(double));
     726          }
     727        }
     728        if (!numberFractionalVariables||reasonToStop)
     729          break;
     730    }
     731    if (nodes) {
     732      printf("Exiting dive for reason %d\n",reasonToStop);
     733      if (reasonToStop>1) {
     734        printf("problems in diving\n");
     735        int whichWay=nodes[numberNodes-1]->problemStatus_;
     736        CbcSubProblem * sub;
     737        if ((whichWay&2)==0) {
     738          // leave both ways
     739          sub = new CbcSubProblem(*nodes[numberNodes-1]);
     740          nodes[numberNodes++]=sub;
     741        } else {
     742          sub = nodes[numberNodes-1];
     743        }
     744        if ((whichWay&1)==0)
     745          sub->problemStatus_=whichWay|1;
     746        else
     747          sub->problemStatus_=whichWay&~1;
     748      }
     749      if (!numberNodes) {
     750        // was good at start! - create fake
     751        clpSolver->resolve();
     752        ClpSimplex * simplex = clpSolver->getModelPtr();
     753        CbcSubProblem * sub =
     754          new CbcSubProblem(clpSolver,lowerBefore,upperBefore,
     755                            simplex->statusArray(),numberNodes);
     756        nodes[numberNodes]=sub;
     757        // other stuff
     758        sub->branchValue_=0.0;
     759        sub->problemStatus_=0;
     760        sub->branchVariable_=-1;
     761        sub->objectiveValue_ = simplex->objectiveValue();
     762        sub->sumInfeasibilities_ = 0.0;
     763        sub->numberInfeasibilities_ = 0;
     764        printf("DiveNode %d column %d way %d bvalue %g obj %g\n",
     765               numberNodes,sub->branchVariable_,sub->problemStatus_,
     766               sub->branchValue_,sub->objectiveValue_);
     767        numberNodes++;
     768        assert (solver->isProvenOptimal());
     769      }
     770      nodes[numberNodes-1]->problemStatus_ |= 256*reasonToStop;
     771      // use djs as well
     772      if (solver->isProvenPrimalInfeasible()&&cuts) {
     773        // can do conflict cut and re-order
     774        printf("could do final conflict cut\n");
     775        bool localCut;
     776        OsiRowCut * cut = model_->conflictCut(solver,localCut);
     777        if (cut) {
     778          printf("cut - need to use conflict and previous djs\n");
     779          if (!localCut) {
     780            model_->makePartialCut(cut,solver);
     781            cuts[numberCuts++]=cut;
     782          } else {
     783            delete cut;
     784          }
     785        } else {
     786          printf("bad conflict - just use previous djs\n");
     787        }
     788      }
     789    }
     790   
    666791    // re-compute new solution value
    667792    double objOffset = 0.0;
     
    669794    newSolutionValue = -objOffset;
    670795    for (int i = 0 ; i < numberColumns ; i++ )
    671         newSolutionValue += objective[i] * newSolution[i];
     796      newSolutionValue += objective[i] * newSolution[i];
    672797    newSolutionValue *= direction;
    673798    //printf("new solution value %g %g\n",newSolutionValue,solutionValue);
    674     if (newSolutionValue < solutionValue) {
    675         // paranoid check
    676         memset(rowActivity, 0, numberRows*sizeof(double));
    677         for (int i = 0; i < numberColumns; i++) {
    678             int j;
    679             double value = newSolution[i];
    680             if (value) {
    681                 for (j = columnStart[i];
    682                         j < columnStart[i] + columnLength[i]; j++) {
    683                     int iRow = row[j];
    684                     rowActivity[iRow] += value * element[j];
    685                 }
    686             }
    687         }
    688         // check was approximately feasible
    689         bool feasible = true;
    690         for (int i = 0; i < numberRows; i++) {
    691             if (rowActivity[i] < rowLower[i]) {
    692                 if (rowActivity[i] < rowLower[i] - 1000.0*primalTolerance)
    693                     feasible = false;
    694             } else if (rowActivity[i] > rowUpper[i]) {
    695                 if (rowActivity[i] > rowUpper[i] + 1000.0*primalTolerance)
    696                     feasible = false;
    697             }
    698         }
    699         for (int i = 0; i < numberIntegers; i++) {
    700             int iColumn = integerVariable[i];
    701             double value = newSolution[iColumn];
    702             if (fabs(floor(value + 0.5) - value) > integerTolerance) {
    703                 feasible = false;
    704                 break;
    705             }
    706         }
    707         if (feasible) {
    708             // new solution
    709             memcpy(betterSolution, newSolution, numberColumns*sizeof(double));
    710             solutionValue = newSolutionValue;
    711             //printf("** Solution of %g found by CbcHeuristicDive\n",newSolutionValue);
    712             returnCode = 1;
    713         } else {
    714             // Can easily happen
    715             //printf("Debug CbcHeuristicDive giving bad solution\n");
    716         }
     799    if (newSolutionValue < solutionValue && !reasonToStop) {
     800      double * rowActivity = new double[numberRows];
     801      memset(rowActivity, 0, numberRows*sizeof(double));
     802      // paranoid check
     803      memset(rowActivity, 0, numberRows*sizeof(double));
     804      for (int i = 0; i < numberColumns; i++) {
     805        int j;
     806        double value = newSolution[i];
     807        if (value) {
     808          for (j = columnStart[i];
     809               j < columnStart[i] + columnLength[i]; j++) {
     810            int iRow = row[j];
     811            rowActivity[iRow] += value * element[j];
     812          }
     813        }
     814      }
     815      // check was approximately feasible
     816      bool feasible = true;
     817      for (int i = 0; i < numberRows; i++) {
     818        if (rowActivity[i] < rowLower[i]) {
     819          if (rowActivity[i] < rowLower[i] - 1000.0*primalTolerance)
     820            feasible = false;
     821        } else if (rowActivity[i] > rowUpper[i]) {
     822          if (rowActivity[i] > rowUpper[i] + 1000.0*primalTolerance)
     823            feasible = false;
     824        }
     825      }
     826      for (int i = 0; i < numberIntegers; i++) {
     827        int iColumn = integerVariable[i];
     828        double value = newSolution[iColumn];
     829        if (fabs(floor(value + 0.5) - value) > integerTolerance) {
     830          feasible = false;
     831          break;
     832        }
     833      }
     834      if (feasible) {
     835        // new solution
     836        solutionValue = newSolutionValue;
     837        //printf("** Solution of %g found by CbcHeuristicDive\n",newSolutionValue);
     838        //if (cuts)
     839        //clpSolver->getModelPtr()->writeMps("good8.mps", 2);
     840        returnCode = 1;
     841      } else {
     842        // Can easily happen
     843        printf("Debug CbcHeuristicDive giving bad solution\n");
     844      }
     845      delete [] rowActivity;
    717846    }
    718847
     
    726855#endif
    727856
    728     delete [] newSolution;
    729857    delete [] columnFixed;
    730858    delete [] originalBound;
    731859    delete [] fixedAtLowerBound;
    732860    delete [] candidate;
    733     delete [] rowActivity;
    734861    delete [] random;
    735862    delete [] downArray_;
     
    739866    delete solver;
    740867    return returnCode;
     868}
     869// See if diving will give better solution
     870// Sets value of solution
     871// Returns 1 if solution, 0 if not
     872int
     873CbcHeuristicDive::solution(double & solutionValue,
     874                           double * betterSolution)
     875{
     876    int nodeCount = model_->getNodeCount();
     877    if (feasibilityPumpOptions_>0 && (nodeCount % feasibilityPumpOptions_) != 0)
     878        return 0;
     879#ifdef DIVE_DEBUG
     880    std::cout << "solutionValue = " << solutionValue << std::endl;
     881#endif
     882    ++numCouldRun_;
     883
     884    // test if the heuristic can run
     885    if (!canHeuristicRun())
     886        return 0;
     887
     888#ifdef JJF_ZERO
     889    // See if to do
     890    if (!when() || (when() % 10 == 1 && model_->phase() != 1) ||
     891            (when() % 10 == 2 && (model_->phase() != 2 && model_->phase() != 3)))
     892        return 0; // switched off
     893#endif
     894    // Get solution array for heuristic solution
     895    int numberColumns = model_->solver()->getNumCols();
     896    double * newSolution = new double [numberColumns];
     897    int numberCuts=0;
     898    int numberNodes=-1;
     899    CbcSubProblem ** nodes=NULL;
     900    int returnCode=solution(solutionValue,numberNodes,numberCuts,
     901                            NULL,nodes,
     902                            newSolution);
     903  if (returnCode==1)
     904    memcpy(betterSolution, newSolution, numberColumns*sizeof(double));
     905
     906    delete [] newSolution;
     907    return returnCode;
     908}
     909/* returns 0 if no solution, 1 if valid solution
     910   with better objective value than one passed in
     911   also returns list of nodes
     912   This does Fractional Diving
     913*/
     914int
     915CbcHeuristicDive::fathom(CbcModel * model, int & numberNodes,
     916                         CbcSubProblem ** & nodes)
     917{
     918  double solutionValue = model->getCutoff();
     919  numberNodes=0;
     920  // Get solution array for heuristic solution
     921  int numberColumns = model_->solver()->getNumCols();
     922  double * newSolution = new double [4*numberColumns];
     923  double * lastDjs = newSolution+numberColumns;
     924  double * originalLower = lastDjs+numberColumns;
     925  double * originalUpper = originalLower+numberColumns;
     926  memcpy(originalLower,model_->solver()->getColLower(),
     927         numberColumns*sizeof(double));
     928  memcpy(originalUpper,model_->solver()->getColUpper(),
     929         numberColumns*sizeof(double));
     930  int numberCuts=0;
     931  OsiRowCut ** cuts = NULL; //new OsiRowCut * [maxIterations_];
     932  nodes=new CbcSubProblem * [maxIterations_+2];
     933  int returnCode=solution(solutionValue,numberNodes,numberCuts,
     934                          cuts,nodes,
     935                          newSolution);
     936
     937  if (returnCode==1) {
     938    // copy to best solution ? or put in solver
     939    printf("Solution from heuristic fathom\n");
     940  }
     941  int numberFeasibleNodes=numberNodes;
     942  if (returnCode!=1)
     943    numberFeasibleNodes--;
     944  if (numberFeasibleNodes>0) {
     945    CoinWarmStartBasis * basis = nodes[numberFeasibleNodes-1]->status_;
     946    //double * sort = new double [numberFeasibleNodes];
     947    //int * whichNode = new int [numberFeasibleNodes];
     948    //int numberNodesNew=0;
     949    // use djs on previous unless feasible
     950    for (int iNode=0;iNode<numberFeasibleNodes;iNode++) {
     951      CbcSubProblem * sub = nodes[iNode];
     952      double branchValue = sub->branchValue_;
     953      int iStatus=sub->problemStatus_;
     954      int iColumn = sub->branchVariable_;
     955      bool secondBranch = (iStatus&2)!=0;
     956      bool branchUp;
     957      if (!secondBranch)
     958        branchUp = (iStatus&1)!=0;
     959      else
     960        branchUp = (iStatus&1)==0;
     961      double djValue=lastDjs[iColumn];
     962      sub->djValue_=fabs(djValue);
     963      if (!branchUp&&floor(branchValue)==originalLower[iColumn]
     964          &&basis->getStructStatus(iColumn) == CoinWarmStartBasis::atLowerBound) {
     965        if (djValue>0.0) {
     966          // naturally goes to LB
     967          printf("ignoring branch down on %d (node %d) from value of %g - branch was %s - dj %g\n",
     968                 iColumn,iNode,branchValue,secondBranch ? "second" : "first",
     969                 djValue);
     970          sub->problemStatus_ |= 4;
     971          //} else {
     972          // put on list
     973          //sort[numberNodesNew]=djValue;
     974          //whichNode[numberNodesNew++]=iNode;
     975        }
     976      } else if (branchUp&&ceil(branchValue)==originalUpper[iColumn]
     977          &&basis->getStructStatus(iColumn) == CoinWarmStartBasis::atUpperBound) {
     978        if (djValue<0.0) {
     979          // naturally goes to UB
     980          printf("ignoring branch up on %d (node %d) from value of %g - branch was %s - dj %g\n",
     981                 iColumn,iNode,branchValue,secondBranch ? "second" : "first",
     982                 djValue);
     983          sub->problemStatus_ |= 4;
     984          //} else {
     985          // put on list
     986          //sort[numberNodesNew]=-djValue;
     987          //whichNode[numberNodesNew++]=iNode;
     988        }
     989      }
     990    }
     991    // use conflict to order nodes
     992    for (int iCut=0;iCut<numberCuts;iCut++) {
     993    }
     994    //CoinSort_2(sort,sort+numberNodesNew,whichNode);
     995    // create nodes
     996    // last node will have one way already done
     997  }
     998  for (int iCut=0;iCut<numberCuts;iCut++) {
     999    delete cuts[iCut];
     1000  }
     1001  delete [] cuts;
     1002  delete [] newSolution;
     1003  return returnCode;
    7411004}
    7421005
  • stable/2.8/Cbc/src/CbcHeuristicDive.hpp

    r1854 r1883  
    88
    99#include "CbcHeuristic.hpp"
     10class CbcSubProblem;
     11class OsiRowCut;
    1012struct PseudoReducedCost {
    1113    int var;
     
    5961    virtual int solution(double & objectiveValue,
    6062                         double * newSolution);
     63    /// inner part of dive
     64  int solution(double & objectiveValue, int & numberNodes,
     65                 int & numberCuts, OsiRowCut ** cuts,
     66                 CbcSubProblem ** & nodes,
     67                 double * newSolution);
     68    /** returns 0 if no solution, 1 if valid solution
     69        with better objective value than one passed in
     70        also returns list of nodes
     71        This does Fractional Diving
     72    */
     73    int fathom(CbcModel * model, int & numberNodes,CbcSubProblem ** & nodes);
    6174
    6275    /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
     
    7992    void setMaxSimplexIterations(int value) {
    8093        maxSimplexIterations_ = value;
     94    }
     95    /// Get maximum number of simplex iterations
     96    inline int maxSimplexIterations() const {
     97        return maxSimplexIterations_;
    8198    }
    8299
  • stable/2.8/Cbc/src/CbcHeuristicFPump.cpp

    r1870 r1883  
    496496            maximumPasses = 100; // feasibility problem?
    497497        }
     498        randomNumberGenerator_.randomize();
    498499        if (model_->getRandomSeed()!=-1)
    499500          clpSolver->getModelPtr()->setRandomSeed(randomNumberGenerator_.getSeed());
     501        clpSolver->getModelPtr()->randomNumberGenerator()->randomize();
    500502      }
    501503    }
     
    10231025                    offset += costValue * newSolution[iColumn];
    10241026                }
     1027                if (numberPasses==1 && !totalNumberPasses && (model_->specialOptions()&8388608)!=0) {
     1028                  // doing multiple solvers - make a real difference - flip 5%
     1029                  for (i = 0; i < numberIntegers; i++) {
     1030                    int iColumn = integerVariable[i];
     1031                    double value = floor(newSolution[iColumn]+0.5);
     1032                    if (fabs(value-solution[iColumn])>primalTolerance) {
     1033                      value = randomNumberGenerator_.randomDouble();
     1034                      if(value<0.05) {
     1035                        //printf("Flipping %d - random %g\n",iColumn,value);
     1036                        solver->setObjCoeff(iColumn,-solver->getObjCoefficients()[iColumn]);
     1037                      }
     1038                    }
     1039                  }
     1040                }
    10251041                solver->setDblParam(OsiObjOffset, -offset);
    10261042                if (!general && false) {
  • stable/2.8/Cbc/src/CbcHeuristicGreedy.cpp

    r1796 r1883  
    398398
    399399        int numberRows = solver->getNumRows();
     400        int numberColumns = solver->getNumCols();
    400401        // Column copy
     402        matrix_.setDimensions(numberRows,numberColumns);
    401403        const double * element = matrix_.getElements();
    402404        const CoinBigIndex * columnStart = matrix_.getVectorStarts();
     
    407409                good = false;
    408410        }
    409         int numberColumns = solver->getNumCols();
    410411        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    411412            if (objective[iColumn]*direction < 0.0)
     
    830831
    831832        int numberRows = solver->getNumRows();
     833        int numberColumns = solver->getNumCols();
     834        matrix_.setDimensions(numberRows,numberColumns);
    832835        // Column copy
    833836        const double * element = matrix_.getElements();
     
    843846                good = false;
    844847        }
    845         int numberColumns = solver->getNumCols();
    846848        for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
    847849            if (objective[iColumn]*direction < 0.0)
  • stable/2.8/Cbc/src/CbcLinked.cpp

    r1854 r1883  
    330330            }
    331331            modelPtr_->replaceMatrix(temp, true);
     332            modelPtr_->setNewRowCopy(NULL);
     333            modelPtr_->setClpScaledMatrix(NULL);
    332334        } else {
    333335            delete temp;
  • stable/2.8/Cbc/src/CbcModel.cpp

    r1879 r1883  
    2424#include <cmath>
    2525#include <cfloat>
    26 
    2726#ifdef COIN_HAS_CLP
    2827// include Presolve from Clp
     
    447446        if (!numberContinuousObj && numberIntegerObj <= 5 && numberIntegerWeight <= 100 &&
    448447                numberIntegerObj*3 < numberObjects_ && !parentModel_ && solver_->getNumRows() > 100)
    449             iType = 3 + 4;
     448          iType = 1 + 4 + ((moreSpecialOptions_&536870912)==0) ? 2 : 0;
    450449        else if (!numberContinuousObj && numberIntegerObj <= 100 &&
    451450                 numberIntegerObj*5 < numberObjects_ && numberIntegerWeight <= 100 &&
    452451                 !parentModel_ &&
    453452                 solver_->getNumRows() > 100 && cost != -COIN_DBL_MAX)
    454             iType = 2 + 4;
     453          iType = 4 + ((moreSpecialOptions_&536870912)==0) ? 2 : 0;
    455454        else if (!numberContinuousObj && numberIntegerObj <= 100 &&
    456455                 numberIntegerObj*5 < numberObjects_ &&
     
    511510                << general << CoinMessageEol ;
    512511                // switch off clp type branching
    513                 fastNodeDepth_ = -1;
     512                // no ? fastNodeDepth_ = -1;
    514513                int highPriority = (branchOnSatisfied) ? -999 : 100;
    515514                for (int i = 0; i < numberObjects_; i++) {
     
    10721071                                          messages())
    10731072                << value << CoinMessageEol ;
    1074                 setDblParam(CbcModel::CbcCutoffIncrement, value*0.999) ;
     1073                setDblParam(CbcModel::CbcCutoffIncrement, CoinMax(value*0.999,value-1.0e-4)) ;
    10751074            }
    10761075        }
     
    15961595
    15971596{
     1597  if (!parentModel_)
    15981598    /*
    15991599      Capture a time stamp before we start (unless set).
     
    16741674            // pre-processing done
    16751675            if (strategy_->preProcessState() < 0) {
    1676                 // infeasible
    1677                 handler_->message(CBC_INFEAS, messages_) << CoinMessageEol ;
     1676                // infeasible (or unbounded)
    16781677                status_ = 0 ;
    1679                 secondaryStatus_ = 1;
     1678                if (!solver_->isProvenDualInfeasible()) {
     1679                  handler_->message(CBC_INFEAS, messages_) << CoinMessageEol ;
     1680                  secondaryStatus_ = 1;
     1681                } else {
     1682                  handler_->message(CBC_UNBOUNDED,
     1683                                    messages_) << CoinMessageEol ;
     1684                  secondaryStatus_ = 7;
     1685                }
    16801686                originalContinuousObjective_ = COIN_DBL_MAX;
    16811687                if (flipObjective)
     
    21532159                handler_->message(CBC_HEURISTICS_OFF, messages_) << numberOdd << CoinMessageEol ;
    21542160            }
     2161            // If odd switch off AddIntegers
     2162            specialOptions_ &= ~65536;
    21552163        } else if (numberSOS) {
    21562164            specialOptions_ |= 128; // say can do SOS in dynamic mode
    21572165            // switch off fast nodes for now
    21582166            fastNodeDepth_ = -1;
     2167            moreSpecialOptions_ &= ~33554432; // no diving
    21592168        }
    21602169        if (numberThreads_ > 0) {
     
    22252234
    22262235    // add cutoff as constraint if wanted
    2227     if ((moreSpecialOptions_&16777216)!=0) {
     2236    if (cutoffRowNumber_==-2) {
    22282237      if (!parentModel_) {
    22292238        int numberColumns=solver_->getNumCols();
     
    22392248        if (n) {
    22402249          double cutoff=getCutoff();
     2250          // relax a little bit
     2251          cutoff += 1.0e-4;
    22412252          double offset;
    22422253          solver_->getDblParam(OsiObjOffset, offset);
     2254          cutoffRowNumber_ = solver_->getNumRows();
    22432255          solver_->addRow(n,indices,obj,-COIN_DBL_MAX,CoinMin(cutoff,1.0e25)+offset);
    22442256        } else {
    22452257          // no objective!
    2246           moreSpecialOptions_ &= ~16777216;
     2258          cutoffRowNumber_ = -1;
    22472259        }
    22482260        delete [] indices;
     
    22502262      } else {
    22512263        // switch off
    2252         moreSpecialOptions_ &= ~16777216;
     2264        cutoffRowNumber_ = -1;
    22532265      }
    22542266    }
     
    24872499      }
    24882500      CoinWarmStartBasis * basis = dynamic_cast<CoinWarmStartBasis *> (solver_->getEmptyWarmStart());
     2501      int numberIterations=0;
    24892502      for (int i=0;i<numberModels;i++) {
    24902503        rootModels[i]=new CbcModel(*this);
     
    24962509        // use seed
    24972510        rootModels[i]->setSpecialOptions(specialOptions_ |(4194304|8388608));
     2511        rootModels[i]->setMoreSpecialOptions(moreSpecialOptions_ &
     2512                                             (~134217728));
    24982513        rootModels[i]->solver_->setWarmStart(basis);
    24992514#ifdef COIN_HAS_CLP
     
    25012516          = dynamic_cast<OsiClpSolverInterface *> (rootModels[i]->solver_);
    25022517        if (clpSolver) {
    2503           clpSolver->getModelPtr()->setRandomSeed(newSeed+20000000*i);
    2504           clpSolver->getModelPtr()->allSlackBasis();
     2518          ClpSimplex * simplex = clpSolver->getModelPtr();
     2519          if (defaultHandler_)
     2520            simplex->setDefaultMessageHandler();
     2521          simplex->setRandomSeed(newSeed+20000000*i);
     2522          simplex->allSlackBasis();
     2523          int logLevel=simplex->logLevel();
     2524          if (logLevel==1)
     2525            simplex->setLogLevel(0);
     2526          if (i!=0) {
     2527            double random = simplex->randomNumberGenerator()->randomDouble();
     2528            int bias = static_cast<int>(random*(numberIterations/4));
     2529            simplex->setMaximumIterations(numberIterations/2+bias);
     2530            simplex->primal();
     2531            simplex->setMaximumIterations(COIN_INT_MAX);
     2532            simplex->dual();
     2533          } else {
     2534            simplex->primal();
     2535            numberIterations=simplex->numberIterations();
     2536          }
     2537          simplex->setLogLevel(logLevel);
     2538          clpSolver->setWarmStart(NULL);
    25052539        }
    25062540#endif
     2541        for (int j=0;j<numberHeuristics_;j++)
     2542          rootModels[i]->heuristic_[j]->setSeed(rootModels[i]->heuristic_[j]->getSeed()+100000000*i);
     2543        for (int j=0;j<numberCutGenerators_;j++)
     2544          rootModels[i]->generator_[j]->generator()->refreshSolver(rootModels[i]->solver_);
    25072545      }
    25082546      delete basis;
     
    26612699    }
    26622700    // replace solverType
     2701    double * tightBounds = NULL;
    26632702    if (solverCharacteristics_->tryCuts())  {
    26642703
     
    26672706            if (!eventHappened_ && feasible) {
    26682707                if (rootModels) {
     2708                  // for fixings
     2709                  int numberColumns=solver_->getNumCols();
     2710                  tightBounds = new double [2*numberColumns];
     2711                  {
     2712                    const double * lower = solver_->getColLower();
     2713                    const double * upper = solver_->getColUpper();
     2714                    for (int i=0;i<numberColumns;i++) {
     2715                      tightBounds[2*i+0]=lower[i];
     2716                      tightBounds[2*i+1]=upper[i];
     2717                    }
     2718                  }
    26692719                  int numberModels = multipleRootTries_%100;
    26702720                  const OsiSolverInterface ** solvers = new
     
    26742724                  for (int i=0;i<numberModels;i++) {
    26752725                    solvers[i]=rootModels[i]->solver();
     2726                    const double * lower = solvers[i]->getColLower();
     2727                    const double * upper = solvers[i]->getColUpper();
     2728                    for (int j=0;j<numberColumns;j++) {
     2729                      tightBounds[2*j+0]=CoinMax(lower[j],tightBounds[2*j+0]);
     2730                      tightBounds[2*j+1]=CoinMin(upper[j],tightBounds[2*j+1]);
     2731                    }
    26762732                    int numberRows2=solvers[i]->getNumRows();
    26772733                    assert (numberRows2>=numberRows);
     
    26852741                    generator_[j]->scaleBackStatistics(numberModels);
    26862742                  }
    2687                   CbcRowCuts rowCut(maxCuts);
     2743                  //CbcRowCuts rowCut(maxCuts);
     2744                  const OsiRowCutDebugger *debugger = NULL;
     2745                  if ((specialOptions_&1) != 0)
     2746                    debugger = solver_->getRowCutDebugger() ;
    26882747                  for (int iModel=0;iModel<numberModels;iModel++) {
    26892748                    int numberRows2=solvers[iModel]->getNumRows();
     
    27012760                      CoinBigIndex start = rowStart[iRow];
    27022761                      rc.setRow(rowLength[iRow],column+start,elements+start,false);
    2703                       rowCut.addCutIfNotDuplicate(rc);
     2762                      if (debugger)
     2763                        CoinAssert (!debugger->invalidCut(rc));
     2764                      globalCuts_.addCutIfNotDuplicate(rc);
    27042765                    }
    2705                     //int cutsAdded=rowCut.numberCuts()-numberCuts;
     2766                    //int cutsAdded=globalCuts_.numberCuts()-numberCuts;
    27062767                    //numberCuts += cutsAdded;
    27072768                    //printf("Model %d gave %d cuts (out of %d possible)\n",
    27082769                    //     iModel,cutsAdded,numberRows2-numberRows);
    27092770                  }
    2710                   rowCut.addCuts(cuts);
     2771                  // normally replace global cuts
     2772                  //if (!globalCuts_.())
     2773                  //globalCuts_=rowCutrowCut.addCuts(globalCuts_);
     2774                  //rowCut.addCuts(globalCuts_);
     2775                  int nTightened=0;
     2776                  bool feasible=true;
     2777                  {
     2778                    double tolerance=1.0e-5;
     2779                    const double * lower = solver_->getColLower();
     2780                    const double * upper = solver_->getColUpper();
     2781                    for (int i=0;i<numberColumns;i++) {
     2782                      if (tightBounds[2*i+0]>tightBounds[2*i+1]) {
     2783                        feasible=false;
     2784                        printf("Bad bounds on %d %g,%g was %g,%g\n",
     2785                               i,tightBounds[2*i+0],tightBounds[2*i+1],
     2786                               lower[i],upper[i]);
     2787                      }
     2788                      //int k=0;
     2789                      double oldLower=lower[i];
     2790                      double oldUpper=upper[i];
     2791                      if (tightBounds[2*i+0]>oldLower+tolerance) {
     2792                        nTightened++;
     2793                        //k++;
     2794                        solver_->setColLower(i,tightBounds[2*i+0]);
     2795                      }
     2796                      if (tightBounds[2*i+1]<oldUpper-tolerance) {
     2797                        nTightened++;
     2798                        //k++;
     2799                        solver_->setColUpper(i,tightBounds[2*i+1]);
     2800                      }
     2801                      //if (k)
     2802                      //printf("new bounds on %d %g,%g was %g,%g\n",
     2803                      //       i,tightBounds[2*i+0],tightBounds[2*i+1],
     2804                      //       oldLower,oldUpper);
     2805                    }
     2806                    if (!feasible)
     2807                      abort(); // deal with later
     2808                  }
     2809                  delete [] tightBounds;
     2810                  tightBounds=NULL;
    27112811                  char printBuffer[200];
    27122812                  sprintf(printBuffer,"%d solvers added %d different cuts out of pool of %d",
    2713                           numberModels,cuts.sizeRowCuts(),maxCuts);
     2813                          numberModels,globalCuts_.sizeRowCuts(),maxCuts);
    27142814                  messageHandler()->message(CBC_GENERAL, messages())
    27152815                    << printBuffer << CoinMessageEol ;
     2816                  if (nTightened) {
     2817                    sprintf(printBuffer,"%d bounds were tightened",
     2818                          nTightened);
     2819                    messageHandler()->message(CBC_GENERAL, messages())
     2820                      << printBuffer << CoinMessageEol ;
     2821                  }
    27162822                  delete [] solvers;
     2823                }
     2824                if (!parentModel_&&(moreSpecialOptions_&67108864) != 0) {
     2825                  // load cuts from file
     2826                  FILE * fp = fopen("global.cuts","rb");
     2827                  if (fp) {
     2828                    size_t nRead;
     2829                    int numberColumns=solver_->getNumCols();
     2830                    int numCols;
     2831                    nRead = fread(&numCols, sizeof(int), 1, fp);
     2832                    if (nRead != 1)
     2833                      throw("Error in fread");
     2834                    if (numberColumns!=numCols) {
     2835                      printf("Mismatch on columns %d %d\n",numberColumns,numCols);
     2836                      fclose(fp);
     2837                    } else {
     2838                      // If rootModel just do some
     2839                      double threshold=-1.0;
     2840                      if (!multipleRootTries_)
     2841                        threshold=0.5;
     2842                      int initialCuts=0;
     2843                      int initialGlobal = globalCuts_.sizeRowCuts();
     2844                      double * elements = new double [numberColumns+2];
     2845                      int * indices = new int [numberColumns];
     2846                      int numberEntries=1;
     2847                      while (numberEntries>0) {
     2848                        nRead = fread(&numberEntries, sizeof(int), 1, fp);
     2849                        if (nRead != 1)
     2850                          throw("Error in fread");
     2851                        double randomNumber=randomNumberGenerator_.randomDouble();
     2852                        if (numberEntries>0) {
     2853                          initialCuts++;
     2854                          nRead = fread(elements, sizeof(double), numberEntries+2, fp);
     2855                          if (nRead != static_cast<size_t>(numberEntries+2))
     2856                            throw("Error in fread");
     2857                          nRead = fread(indices, sizeof(int), numberEntries, fp);
     2858                          if (nRead != static_cast<size_t>(numberEntries))
     2859                            throw("Error in fread");
     2860                          if (randomNumber>threshold) {
     2861                            OsiRowCut rc;
     2862                            rc.setLb(elements[numberEntries]);
     2863                            rc.setUb(elements[numberEntries+1]);
     2864                            rc.setRow(numberEntries,indices,elements,
     2865                                      false);
     2866                            rc.setGloballyValidAsInteger(2);
     2867                            globalCuts_.addCutIfNotDuplicate(rc) ;
     2868                          }
     2869                        }
     2870                      }
     2871                      fclose(fp);
     2872                      // fixes
     2873                      int nTightened=0;
     2874                      fp = fopen("global.fix","rb");
     2875                      if (fp) {
     2876                        nRead = fread(indices, sizeof(int), 2, fp);
     2877                        if (nRead != 2)
     2878                          throw("Error in fread");
     2879                        if (numberColumns!=indices[0]) {
     2880                          printf("Mismatch on columns %d %d\n",numberColumns,
     2881                                 indices[0]);
     2882                        } else {
     2883                          indices[0]=1;
     2884                          while (indices[0]>=0) {
     2885                            nRead = fread(indices, sizeof(int), 2, fp);
     2886                            if (nRead != 2)
     2887                              throw("Error in fread");
     2888                            int iColumn=indices[0];
     2889                            if (iColumn>=0) {
     2890                              nTightened++;
     2891                              nRead = fread(elements, sizeof(double), 4, fp);
     2892                              if (nRead != 4)
     2893                                throw("Error in fread");
     2894                              solver_->setColLower(iColumn,elements[0]);
     2895                              solver_->setColUpper(iColumn,elements[1]);
     2896                            }
     2897                          }
     2898                        }
     2899                      }
     2900                      if (fp)
     2901                        fclose(fp);
     2902                      char printBuffer[200];
     2903                      sprintf(printBuffer,"%d cuts read in of which %d were unique, %d bounds tightened",
     2904                             initialCuts,
     2905                             globalCuts_.sizeRowCuts()-initialGlobal,nTightened);
     2906                      messageHandler()->message(CBC_GENERAL, messages())
     2907                        << printBuffer << CoinMessageEol ;
     2908                      delete [] elements;
     2909                      delete [] indices;
     2910                    }
     2911                  }
    27172912                }
    27182913                feasible = solveWithCuts(cuts, maximumCutPassesAtRoot_,
    27192914                                         NULL);
     2915                if (multipleRootTries_&&
     2916                    (moreSpecialOptions_&134217728)!=0) {
     2917                  FILE * fp=NULL;
     2918                  size_t nRead;
     2919                  int numberColumns=solver_->getNumCols();
     2920                  int initialCuts=0;
     2921                  if ((moreSpecialOptions_&134217728)!=0) {
     2922                    // append so go down to end
     2923                    fp = fopen("global.cuts","r+b");
     2924                    if (fp) {
     2925                      int numCols;
     2926                      nRead = fread(&numCols, sizeof(int), 1, fp);
     2927                      if (nRead != 1)
     2928                        throw("Error in fread");
     2929                      if (numberColumns!=numCols) {
     2930                        printf("Mismatch on columns %d %d\n",numberColumns,numCols);
     2931                        fclose(fp);
     2932                        fp=NULL;
     2933                      }
     2934                    }
     2935                  }
     2936                  double * elements = new double [numberColumns+2];
     2937                  int * indices = new int [numberColumns];
     2938                  if (fp) {
     2939                    int numberEntries=1;
     2940                    while (numberEntries>0) {
     2941                      fpos_t position;
     2942                      fgetpos(fp, &position);
     2943                      nRead = fread(&numberEntries, sizeof(int), 1, fp);
     2944                      if (nRead != 1)
     2945                        throw("Error in fread");
     2946                      if (numberEntries>0) {
     2947                        initialCuts++;
     2948                        nRead = fread(elements, sizeof(double), numberEntries+2, fp);
     2949                        if (nRead != static_cast<size_t>(numberEntries+2))
     2950                          throw("Error in fread");
     2951                        nRead = fread(indices, sizeof(int), numberEntries, fp);
     2952                        if (nRead != static_cast<size_t>(numberEntries))
     2953                          throw("Error in fread");
     2954                      } else {
     2955                        // end
     2956                        fsetpos(fp, &position);
     2957                      }
     2958                    }
     2959                  } else {
     2960                    fp = fopen("global.cuts","wb");
     2961                    size_t nWrite;
     2962                    nWrite=fwrite(&numberColumns,sizeof(int),1,fp);
     2963                    if (nWrite != 1)
     2964                      throw("Error in fwrite");
     2965                  }
     2966                  size_t nWrite;
     2967                  // now append binding cuts
     2968                  int numberC=continuousSolver_->getNumRows();
     2969                  int numberRows=solver_->getNumRows();
     2970                  printf("Saving %d cuts (up from %d)\n",
     2971                         initialCuts+numberRows-numberC,initialCuts);
     2972                  const double * rowLower = solver_->getRowLower();
     2973                  const double * rowUpper = solver_->getRowUpper();
     2974                  // Row copy
     2975                  CoinPackedMatrix matrixByRow(*solver_->getMatrixByRow());
     2976                  const double * elementByRow = matrixByRow.getElements();
     2977                  const int * column = matrixByRow.getIndices();
     2978                  const CoinBigIndex * rowStart = matrixByRow.getVectorStarts();
     2979                  const int * rowLength = matrixByRow.getVectorLengths();
     2980                  for (int iRow=numberC;iRow<numberRows;iRow++) {
     2981                    int n=rowLength[iRow];
     2982                    assert (n);
     2983                    CoinBigIndex start=rowStart[iRow];
     2984                    memcpy(elements,elementByRow+start,n*sizeof(double));
     2985                    memcpy(indices,column+start,n*sizeof(int));
     2986                    elements[n]=rowLower[iRow];
     2987                    elements[n+1]=rowUpper[iRow];
     2988                    nWrite=fwrite(&n,sizeof(int),1,fp);
     2989                    if (nWrite != 1)
     2990                      throw("Error in fwrite");
     2991                    nWrite=fwrite(elements,sizeof(double),n+2,fp);
     2992                    if (nWrite != static_cast<size_t>(n+2))
     2993                      throw("Error in fwrite");
     2994                    nWrite=fwrite(indices,sizeof(int),n,fp);
     2995                    if (nWrite != static_cast<size_t>(n))
     2996                      throw("Error in fwrite");
     2997                  }
     2998                  // eof marker
     2999                  int eofMarker=-1;
     3000                  nWrite=fwrite(&eofMarker,sizeof(int),1,fp);
     3001                  if (nWrite != 1)
     3002                    throw("Error in fwrite");
     3003                  fclose(fp);
     3004                  // do tighter bounds (? later extra to original columns)
     3005                  int nTightened=0;
     3006                  const double * lower = solver_->getColLower();
     3007                  const double * upper = solver_->getColUpper();
     3008                  const double * originalLower = continuousSolver_->getColLower();
     3009                  const double * originalUpper = continuousSolver_->getColUpper();
     3010                  double tolerance=1.0e-5;
     3011                  for (int i=0;i<numberColumns;i++) {
     3012                    if (lower[i]>originalLower[i]+tolerance) {
     3013                      nTightened++;
     3014                    }
     3015                    if (upper[i]<originalUpper[i]-tolerance) {
     3016                      nTightened++;
     3017                    }
     3018                  }
     3019                  if (nTightened) {
     3020                    fp = fopen("global.fix","wb");
     3021                    size_t nWrite;
     3022                    indices[0]=numberColumns;
     3023                    if (originalColumns_)
     3024                      indices[1]=COIN_INT_MAX;
     3025                    else
     3026                      indices[1]=-1;
     3027                    nWrite=fwrite(indices,sizeof(int),2,fp);
     3028                    if (nWrite != 2)
     3029                      throw("Error in fwrite");
     3030                    for (int i=0;i<numberColumns;i++) {
     3031                      int nTightened=0;
     3032                      if (lower[i]>originalLower[i]+tolerance) {
     3033                        nTightened++;
     3034                      }
     3035                      if (upper[i]<originalUpper[i]-tolerance) {
     3036                        nTightened++;
     3037                      }
     3038                      if (nTightened) {
     3039                        indices[0]=i;
     3040                        if (originalColumns_)
     3041                          indices[1]=originalColumns_[i];
     3042                        elements[0]=lower[i];
     3043                        elements[1]=upper[i];
     3044                        elements[2]=originalLower[i];
     3045                        elements[3]=originalUpper[i];
     3046                        nWrite=fwrite(indices,sizeof(int),2,fp);
     3047                        if (nWrite != 2)
     3048                          throw("Error in fwrite");
     3049                        nWrite=fwrite(elements,sizeof(double),4,fp);
     3050                        if (nWrite != 4)
     3051                          throw("Error in fwrite");
     3052                      }
     3053                    }
     3054                    // eof marker
     3055                    indices[0]=-1;
     3056                    nWrite=fwrite(indices,sizeof(int),2,fp);
     3057                    if (nWrite != 2)
     3058                      throw("Error in fwrite");
     3059                    fclose(fp);
     3060                  }
     3061                  delete [] elements;
     3062                  delete [] indices;
     3063                }
    27203064                if ((specialOptions_&524288) != 0 && !parentModel_
    27213065                        && storedRowCuts_) {
     
    29743318    }
    29753319#endif
     3320    if (!parentModel_&&(moreSpecialOptions_&268435456) != 0) {
     3321      // try idiotic idea
     3322      CbcObject * obj = new CbcIdiotBranch(this);
     3323      obj->setPriority(1); // temp
     3324      addObjects(1, &obj);
     3325      delete obj;
     3326    }
     3327   
    29763328    /*
    29773329      A hook to use clp to quickly explore some part of the tree.
     
    29833335        obj->setPriority(1);
    29843336        addObjects(1, &obj);
     3337        delete obj;
    29853338    }
    29863339    int saveNumberSolves = numberSolves_;
    29873340    int saveNumberIterations = numberIterations_;
    2988     if (fastNodeDepth_ >= 0 &&/*!parentModel_*/(specialOptions_&2048) == 0) {
     3341    if ((fastNodeDepth_ >= 0||(moreSpecialOptions_&33554432)!=0)
     3342        &&/*!parentModel_*/(specialOptions_&2048) == 0) {
    29893343        // add in a general depth object doClp
    29903344        int type = (fastNodeDepth_ <= 100) ? fastNodeDepth_ : -(fastNodeDepth_ - 100);
     3345        if ((moreSpecialOptions_&33554432)!=0)
     3346          type=12;
     3347        else
     3348          fastNodeDepth_ += 1000000;     // mark as done
    29913349        CbcObject * obj =
    29923350            new CbcGeneralDepth(this, type);
    29933351        addObjects(1, &obj);
    2994         // mark as done
    2995         fastNodeDepth_ += 1000000;
    29963352        delete obj;
    29973353        // fake number of objects
     
    36954051              Decide if we want to do a restart.
    36964052            */
    3697             if (saveSolver) {
     4053            if (saveSolver && (specialOptions_&(512 + 32768)) != 0) {
    36984054                bool tryNewSearch = solverCharacteristics_->reducedCostsAccurate() &&
    36994055                                    (getCutoff() < 1.0e20 && getCutoff() < checkCutoffForRestart);
     
    40504406            if (!node || node->objectiveValue() > cutoff)
    40514407                continue;
    4052             // Do main work of solving node here
    4053             doOneNode(this, node, createdNode);
     4408            // Do main work of solving node here
     4409            doOneNode(this, node, createdNode);
    40544410#ifdef JJF_ZERO
    4055             if (node) {
    4056                 if (createdNode) {
    4057                     printf("Node %d depth %d, created %d depth %d\n",
    4058                            node->nodeNumber(), node->depth(),
    4059                            createdNode->nodeNumber(), createdNode->depth());
    4060                 } else {
    4061                     printf("Node %d depth %d,  no created node\n",
    4062                            node->nodeNumber(), node->depth());
    4063                 }
    4064             } else if (createdNode) {
    4065                 printf("Node exhausted, created %d depth %d\n",
    4066                        createdNode->nodeNumber(), createdNode->depth());
    4067             } else {
    4068                 printf("Node exhausted,  no created node\n");
    4069                 numberConsecutiveInfeasible = 2;
    4070             }
     4411            if (node) {
     4412              if (createdNode) {
     4413                printf("Node %d depth %d, created %d depth %d\n",
     4414                       node->nodeNumber(), node->depth(),
     4415                       createdNode->nodeNumber(), createdNode->depth());
     4416              } else {
     4417                printf("Node %d depth %d,  no created node\n",
     4418                       node->nodeNumber(), node->depth());
     4419              }
     4420            } else if (createdNode) {
     4421              printf("Node exhausted, created %d depth %d\n",
     4422                     createdNode->nodeNumber(), createdNode->depth());
     4423            } else {
     4424              printf("Node exhausted,  no created node\n");
     4425              numberConsecutiveInfeasible = 2;
     4426            }
    40714427#endif
    40724428            //if (createdNode)
     
    44514807        setCutoff(1.0e50) ; // As best solution should be worse than cutoff
    44524808        // change cutoff as constraint if wanted
    4453         if ((moreSpecialOptions_&16777216)!=0) {
    4454           if (solver_->getNumRows()>=numberRowsAtContinuous_)
    4455             solver_->setRowUpper(numberRowsAtContinuous_-1,1.0e50);
     4809        if (cutoffRowNumber_>=0) {
     4810          if (solver_->getNumRows()>cutoffRowNumber_)
     4811            solver_->setRowUpper(cutoffRowNumber_,1.0e50);
    44564812        }
    44574813        // also in continuousSolver_
     
    45164872    delete globalConflictCuts_;
    45174873    globalConflictCuts_=NULL;
    4518     if (!bestSolution_) {
     4874    if (!bestSolution_ && (specialOptions_&8388608)==0) {
    45194875        // make sure lp solver is infeasible
    45204876        int numberColumns = solver_->getNumCols();
     
    45434899    }
    45444900#endif
    4545     if (fastNodeDepth_ >= 1000000 && !parentModel_) {
    4546         // delete object off end
    4547         delete object_[numberObjects_];
     4901    if ((fastNodeDepth_ >= 1000000 || (moreSpecialOptions_&33554432)!=0)
     4902         && !parentModel_) {
     4903      // delete object off end
     4904      delete object_[numberObjects_];
     4905      if ((moreSpecialOptions_&33554432)==0)
    45484906        fastNodeDepth_ -= 1000000;
    45494907    }
     
    47265084        numberIntegers_(0),
    47275085        numberRowsAtContinuous_(0),
     5086        cutoffRowNumber_(-1),
    47285087        maximumNumberCuts_(0),
    47295088        phase_(0),
     
    47735132        ownObjects_(true),
    47745133        originalColumns_(NULL),
    4775         howOftenGlobalScan_(1),
     5134        howOftenGlobalScan_(3),
    47765135        numberGlobalViolations_(0),
    47775136        numberExtraIterations_(0),
     
    48925251        secondaryStatus_(-1),
    48935252        numberRowsAtContinuous_(0),
     5253        cutoffRowNumber_(-1),
    48945254        maximumNumberCuts_(0),
    48955255        phase_(0),
     
    49365296        ownObjects_(true),
    49375297        originalColumns_(NULL),
    4938         howOftenGlobalScan_(1),
     5298        howOftenGlobalScan_(3),
    49395299        numberGlobalViolations_(0),
    49405300        numberExtraIterations_(0),
     
    50635423}
    50645424
     5425static int * resizeInt(int * array,int oldLength, int newLength)
     5426{
     5427  if (!array)
     5428    return NULL;
     5429  assert (newLength>oldLength);
     5430  int * newArray = new int [newLength];
     5431  memcpy(newArray,array,oldLength*sizeof(int));
     5432  delete [] array;
     5433  memset(newArray+oldLength,0,(newLength-oldLength)*sizeof(int));
     5434  return newArray;
     5435}
     5436static double * resizeDouble(double * array,int oldLength, int newLength)
     5437{
     5438  if (!array)
     5439    return NULL;
     5440  assert (newLength>oldLength);
     5441  double * newArray = new double [newLength];
     5442  memcpy(newArray,array,oldLength*sizeof(double));
     5443  delete [] array;
     5444  memset(newArray+oldLength,0,(newLength-oldLength)*sizeof(double));
     5445  return newArray;
     5446}
    50655447/*
    50665448  Assign a solver to the model (model assumes ownership)
     
    50865468
    50875469{
    5088     // resize best solution if exists
    5089     if (bestSolution_ && solver && solver_) {
     5470    // resize stuff if exists
     5471    if (solver && solver_) {
    50905472        int nOld = solver_->getNumCols();
    50915473        int nNew = solver->getNumCols();
    50925474        if (nNew > nOld) {
    5093             double * temp = new double[nNew];
    5094             memcpy(temp, bestSolution_, nOld*sizeof(double));
    5095             memset(temp + nOld, 0, (nNew - nOld)*sizeof(double));
    5096             delete [] bestSolution_;
    5097             bestSolution_ = temp;
     5475          originalColumns_ = resizeInt(originalColumns_,nOld,nNew);
     5476          usedInSolution_ = resizeInt(usedInSolution_,nOld,nNew);
     5477          continuousSolution_ = resizeDouble(continuousSolution_,nOld,nNew);
     5478          hotstartSolution_ = resizeDouble(hotstartSolution_,nOld,nNew);
     5479          bestSolution_ = resizeDouble(bestSolution_,nOld,nNew);
     5480          currentSolution_ = resizeDouble(currentSolution_,nOld,nNew);
     5481          if (savedSolutions_) {
     5482            for (int i = 0; i < maximumSavedSolutions_; i++)
     5483              savedSolutions_[i] = resizeDouble(savedSolutions_[i],nOld,nNew);
     5484          }
    50985485        }
    50995486    }
     
    53865773    testSolution_ = currentSolution_;
    53875774    numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
     5775    cutoffRowNumber_ = rhs.cutoffRowNumber_;
    53885776    maximumNumberCuts_ = rhs.maximumNumberCuts_;
    53895777    phase_ = rhs.phase_;
     
    57136101        }
    57146102        numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
     6103        cutoffRowNumber_ = rhs.cutoffRowNumber_;
    57156104        maximumNumberCuts_ = rhs.maximumNumberCuts_;
    57166105        phase_ = rhs.phase_;
     
    60056394        int i;
    60066395        for (i = 0; i < numberCutGenerators_; i++) {
    6007             if (mode < 2)
     6396            if (mode < 2) {
    60086397                generator_[i] = new CbcCutGenerator(*rhs.generator_[i]);
    6009             else
     6398            } else {
    60106399                generator_[i] = new CbcCutGenerator(*rhs.virginGenerator_[i]);
     6400                // But copy across maximumTries
     6401                generator_[i]->setMaximumTries(rhs.generator_[i]->maximumTries());
     6402            }
    60116403            virginGenerator_[i] = new CbcCutGenerator(*rhs.virginGenerator_[i]);
    60126404        }
     
    60706462    strongInfo_[6] = rhs.strongInfo_[6];
    60716463    numberRowsAtContinuous_ = rhs.numberRowsAtContinuous_;
     6464    cutoffRowNumber_ = rhs.cutoffRowNumber_;
    60726465    maximumDepth_ = rhs.maximumDepth_;
    60736466}
     
    62596652        heuristic_[where]->setHeuristicName(name) ;
    62606653    heuristic_[where]->setSeed(987654321 + where);
    6261     if (randomSeed_!=-1)
    6262       heuristic_[where]->setSeed(randomSeed_);
    62636654    numberHeuristics_++ ;
    62646655}
     
    62866677{
    62876678    int nNode = 0;
     6679    CbcNodeInfo * nodeInfo = node->nodeInfo();
    62886680    int numberColumns = getNumCols();
    6289     CbcNodeInfo * nodeInfo = node->nodeInfo();
    62906681
    62916682    /*
     
    65436934#         endif
    65446935                    addCuts[numberToAdd++] = addedCuts_[i];
     6936#if 1
     6937                    if ((specialOptions_&1) != 0) {
     6938                      const OsiRowCutDebugger * debugger = solver_->getRowCutDebugger() ;
     6939                      if (debugger)
     6940                        CoinAssert (!debugger->invalidCut(*addedCuts_[i]));
     6941                    }
     6942#endif
    65456943                } else {
    65466944#         ifdef CHECK_CUT_COUNTS
     
    66507048                    delete [] which;
    66517049                }
     7050                //#define CHECK_DEBUGGER
     7051#ifdef CHECK_DEBUGGER
     7052                if ((specialOptions_&1) != 0 ) {
     7053                  const OsiRowCutDebugger * debugger =
     7054                    solver_->getRowCutDebugger();
     7055                  if (debugger) {
     7056                    for (int j=0;j<numberToAdd;j++)
     7057                      CoinAssert (!debugger->invalidCut(*addCuts[j]));
     7058                    //addCuts[j]->print();
     7059                  }
     7060                }
     7061#endif
    66527062                //int n2=solver_->getNumRows();
    66537063                //for (int j=0;j<numberToAdd;j++)
     
    67077117CbcModel::synchronizeHandlers(int /*makeDefault*/)
    67087118{
     7119    bool defaultHandler = defaultHandler_;
    67097120    if (!defaultHandler_) {
    67107121        // Must have clone
     
    67137124    }
    67147125#ifdef COIN_HAS_CLP
    6715     OsiClpSolverInterface * solver;
    6716     solver = dynamic_cast<OsiClpSolverInterface *>(solver_) ;
    6717     if (solver) {
     7126    if (!defaultHandler) {
     7127      OsiClpSolverInterface * solver;
     7128      solver = dynamic_cast<OsiClpSolverInterface *>(solver_) ;
     7129      if (solver) {
    67187130        solver->passInMessageHandler(handler_);
    67197131        solver->getModelPtr()->passInMessageHandler(handler_);
    6720     }
    6721     solver = dynamic_cast<OsiClpSolverInterface *>(continuousSolver_) ;
    6722     if (solver) {
     7132      }
     7133      solver = dynamic_cast<OsiClpSolverInterface *>(continuousSolver_) ;
     7134      if (solver) {
    67237135        solver->passInMessageHandler(handler_);
    67247136        solver->getModelPtr()->passInMessageHandler(handler_);
     7137      }
    67257138    }
    67267139#endif
     
    69857398          if ((specialOptions_&1) != 0) {
    69867399            debugger = continuousSolver_->getRowCutDebugger() ;
    6987             if (debugger)
     7400            if (debugger) {
    69887401              if (debugger->invalidCut(*cut)) {
    69897402                continuousSolver_->applyRowCuts(1,cut);
     
    69917404              }
    69927405              CoinAssert (!debugger->invalidCut(*cut));
     7406            }
    69937407          }
    69947408        } else {
     
    72727686        allowZeroIterations = true;
    72737687    }
     7688    int saveNumberTries=numberTries;
    72747689    /*
    72757690      Is it time to scan the cuts in order to remove redundant cuts? If so, set
     
    72907705    // Really primalIntegerTolerance; relates to an illposed problem with various
    72917706    // integer solutions depending on integer tolerance.
    7292     double primalTolerance = 1.0e-7 ;
     7707    //double primalTolerance = 1.0e-7 ;
    72937708    // We may need to keep going on
    72947709    bool keepGoing = false;
     
    73407755        */
    73417756        int numberViolated = 0;
    7342         if (currentPassNumber_ == 1 && howOftenGlobalScan_ > 0 &&
     7757        if ((currentPassNumber_ == 1 ||!numberNodes_) && howOftenGlobalScan_ > 0 &&
    73437758                (numberNodes_ % howOftenGlobalScan_) == 0 &&
    73447759                (doCutsNow(1) || true)) {
    73457760            // global column cuts now done in node at top of tree
    7346             int numberCuts = globalCuts_.sizeRowCuts() ;
    7347             // possibly extend whichGenerator
    7348             resizeWhichGenerator(numberViolated, numberViolated + numberCuts);
    7349             for (int i = 0; i < numberCuts; i++) {
     7761            int numberCuts = numberCutGenerators_ ? globalCuts_.sizeRowCuts() : 0;
     7762            if (numberCuts) {
     7763              // possibly extend whichGenerator
     7764              resizeWhichGenerator(numberViolated, numberViolated + numberCuts);
     7765              // only add new cuts up to 10% of current elements
     7766              int numberElements = solver_->getNumElements();
     7767              int numberColumns = solver_->getNumCols();
     7768              int maximumAdd = CoinMax(numberElements/10,2*numberColumns)+100;
     7769              double * violations = new double[numberCuts];
     7770              int * which = new int[numberCuts];
     7771              int numberPossible=0;
     7772              for (int i = 0; i < numberCuts; i++) {
    73507773                OsiRowCut * thisCut = globalCuts_.rowCutPtr(i) ;
    7351                 if (thisCut->violated(cbcColSolution_) > primalTolerance ||
    7352                         thisCut->effectiveness() == COIN_DBL_MAX) {
     7774                double violation = thisCut->violated(cbcColSolution_);
     7775                if(thisCut->effectiveness() == COIN_DBL_MAX) {
     7776                  // see if already there
     7777                  int j;
     7778                  for (j = 0; j < currentNumberCuts_; j++) {
     7779                    if (addedCuts_[j]==thisCut)
     7780                      break;
     7781                  }
     7782                  if (j==currentNumberCuts_)
     7783                    violation = COIN_DBL_MAX;
     7784                  //else
     7785                  //printf("already done??\n");
     7786                }
     7787                if (violation > 0.005) {
     7788                  violations[numberPossible]=-violation;
     7789                  which[numberPossible++]=i;
     7790                }
     7791              }
     7792              CoinSort_2(violations,violations+numberPossible,which);
     7793              for (int i = 0; i < numberPossible; i++) {
     7794                int k=which[i];
     7795                OsiRowCut * thisCut = globalCuts_.rowCutPtr(k) ;
     7796                assert (thisCut->violated(cbcColSolution_) > 0.005/*primalTolerance*/ ||
     7797                        thisCut->effectiveness() == COIN_DBL_MAX);
     7798#define CHECK_DEBUGGER
     7799#ifdef CHECK_DEBUGGER
     7800                if ((specialOptions_&1) != 0 ) {
     7801                  const OsiRowCutDebugger * debugger =
     7802                    solver_->getRowCutDebuggerAlways();
     7803                  CoinAssert (!debugger->invalidCut(*thisCut));
     7804                }
     7805#endif
    73537806#if 0 //ndef NDEBUG
    7354                   printf("Global cut added - violation %g\n",
    7355                            thisCut->violated(cbcColSolution_)) ;
    7356 #endif
    7357                     whichGenerator_[numberViolated++] = -1;
     7807                printf("Global cut added - violation %g\n",
     7808                       thisCut->violated(cbcColSolution_)) ;
     7809#endif
     7810                whichGenerator_[numberViolated++] = -1;
    73587811#ifndef GLOBAL_CUTS_JUST_POINTERS
    7359                     theseCuts.insert(*thisCut) ;
     7812                theseCuts.insert(*thisCut) ;
    73607813#else
    7361                     theseCuts.insert(thisCut) ;
    7362 #endif
    7363                 }
    7364             }
    7365             numberGlobalViolations_ += numberViolated;
     7814                theseCuts.insert(thisCut) ;
     7815#endif
     7816                if (violations[i]!=-COIN_DBL_MAX)
     7817                  maximumAdd -= thisCut->row().getNumElements();
     7818                if (maximumAdd<0)
     7819                  break;
     7820              }
     7821              delete [] which;
     7822              delete [] violations;
     7823              numberGlobalViolations_ += numberViolated;
     7824            }
    73667825        }
    73677826        /*
     
    77198178            //solver_->setHintParam(OsiDoDualInResolve,true,OsiHintTry);
    77208179            if ( maximumSecondsReached() ) {
    7721                 numberTries = 0; // exit
     8180                numberTries = -1000; // exit
    77228181                feasible = false;
    77238182                break;
     
    78778336                    // maybe give it one more try
    78788337                    if (numberLastAttempts > 2 || currentDepth_ || experimentBreak < 2)
    7879                         break ;
     8338                        numberTries=0 ;
    78808339                    else
    78818340                        numberLastAttempts++;
     
    79118370            keepGoing=false;
    79128371        }
    7913         if (numberTries <=0 && feasible && !keepGoing && !parentModel_ && !numberNodes_) {
     8372        if (numberTries ==0 && feasible && !keepGoing && !parentModel_ && !numberNodes_) {
    79148373          for (int i = 0; i < numberCutGenerators_; i++) {
    79158374            if (generator_[i]->whetherCallAtEnd()
    79168375                &&!generator_[i]->whetherInMustCallAgainMode()) {
    7917               keepGoing= true;
    7918               break;
     8376              // give it some goes and switch off
     8377              numberTries=(saveNumberTries+4)/5;
     8378              generator_[i]->setWhetherCallAtEnd(false);
    79198379            }
    79208380          }
     
    79868446                }
    79878447                if (!feasible) { //node will be fathomed
     8448                    lockThread();
    79888449                    for (int i = 0; i < currentNumberCuts_; i++) {
    79898450                        // take off node
     
    79948455                        }
    79958456                    }
     8457                    unlockThread();
    79968458                }
    79978459            }
     
    81378599        */
    81388600        if (!numberNodes_) {
     8601          if (!parentModel_) {
     8602            //printf("%d global cuts\n",globalCuts_.sizeRowCuts()) ;
     8603            if ((specialOptions_&1) != 0) {
     8604              //specialOptions_ &= ~1;
     8605              int numberCuts = globalCuts_.sizeRowCuts();
     8606              const OsiRowCutDebugger *debugger =
     8607                continuousSolver_->getRowCutDebugger() ;
     8608              if (debugger) {
     8609                for (int i = 0; i < numberCuts; i++) {
     8610                  OsiRowCut * cut = globalCuts_.rowCutPtr(i) ;
     8611                  if (debugger->invalidCut(*cut)) {
     8612                    continuousSolver_->applyRowCuts(1,cut);
     8613                    continuousSolver_->writeMps("bad");
     8614                    printf("BAD cut\n");
     8615                  }
     8616                  //CoinAssert (!debugger->invalidCut(*cut));
     8617                }
     8618              }
     8619            }
     8620          }
    81398621          //solver_->writeMps("second");
    81408622            if (numberRowsAdded)
     
    82858767                willBeCutsInTree = 0;
    82868768        }
    8287         if (!numberNodes_)
     8769        if (!numberNodes_) {
    82888770            handler_->message(CBC_ROOT, messages_)
    82898771            << numberNewCuts_
     
    82918773            << currentPassNumber_
    82928774            << CoinMessageEol ;
     8775        }
    82938776        /*
    82948777          Count the number of cuts produced by each cut generator on this call. Not
     
    84018884                    howOften = -99; // switch off
    84028885            }
     8886            if (generator_[i]->maximumTries()!=-1)
     8887                howOften = -99; // switch off
    84038888            /*
    84048889              Below -99, this generator is switched off. There's no need to consider
    84058890              further. Then again, there was no point in persisting this far!
    84068891            */
    8407             if (howOften < -99)
    8408                 continue ;
     8892            if (howOften < -99) {
     8893              // may have been switched off - report
     8894              if (!numberNodes_) {
     8895                int n = generator_[i]->numberCutsInTotal();
     8896                if (n) {
     8897                  double average = 0.0;
     8898                  average = generator_[i]->numberElementsInTotal();
     8899                  average /= n;
     8900                  handler_->message(CBC_GENERATOR, messages_)
     8901                    << i
     8902                    << generator_[i]->cutGeneratorName()
     8903                    << n
     8904                    << average
     8905                    << generator_[i]->numberColumnCuts()
     8906                    << generator_[i]->numberCutsActive()
     8907                    + generator_[i]->numberColumnCuts();
     8908                  handler_->printing(generator_[i]->timing())
     8909                    << generator_[i]->timeInCutGenerator();
     8910                  handler_->message()
     8911                    << -100
     8912                    << CoinMessageEol ;
     8913                }
     8914              }
     8915              continue ;
     8916            }
    84098917            /*
    84108918              Adjust, if howOften is adjustable.
     
    87289236        specialOptions_ &= ~256; // mark as full scan done
    87299237    }
    8730 # ifdef COIN_HAS_CLP
    8731     if (!node && !parentModel_ && intParam_[CbcMaxNumNode] == -123456) {
    8732         OsiClpSolverInterface * clpSolver
    8733         = dynamic_cast<OsiClpSolverInterface *> (solver_);
    8734         if (clpSolver) {
    8735             clpSolver->lexSolve();
    8736         }
     9238# if 0 //def COIN_HAS_CLP
     9239    // check basis
     9240    OsiClpSolverInterface * clpSolver
     9241      = dynamic_cast<OsiClpSolverInterface *> (solver_);
     9242    if (clpSolver) {
     9243      ClpSimplex * simplex = clpSolver->getModelPtr();
     9244      int numberTotal=simplex->numberRows()+simplex->numberColumns();
     9245      int superbasic=0;
     9246      for (int i=0;i<numberTotal;i++) {
     9247        if (simplex->getStatus(i)==ClpSimplex::superBasic)
     9248          superbasic++;
     9249      }
     9250      if (superbasic) {
     9251        printf("%d superbasic!\n",superbasic);
     9252        clpSolver->resolve();
     9253        superbasic=0;
     9254        for (int i=0;i<numberTotal;i++) {
     9255          if (simplex->getStatus(i)==ClpSimplex::superBasic)
     9256            superbasic++;
     9257        }
     9258        assert (!superbasic);
     9259      }
    87379260    }
    87389261# endif
     
    87629285            }
    87639286        }
     9287        if (generator_[i]->whetherCallAtEnd())
     9288          generate=false;
    87649289        const OsiRowCutDebugger * debugger = NULL;
    87659290        bool onOptimalPath = false;
     
    88969421            if (thisCut->lb() > thisCut->ub())
    88979422                status = -1; // sub-problem is infeasible
    8898             if (thisCut->globallyValid()) {
     9423            if (thisCut->globallyValid()||!numberNodes_) {
    88999424                // add to global list
    89009425                OsiRowCut newCut(*thisCut);
     
    92219746        }
    92229747    }
    9223 #ifdef COIN_HAS_CLP
     9748  #ifdef COIN_HAS_CLP
    92249749    OsiClpSolverInterface * clpSolver
    92259750    = dynamic_cast<OsiClpSolverInterface *> (solver_);
     
    1051311038                int n = CoinMax(obj2->numberTimesDown(),
    1051411039                                obj2->numberTimesUp());
    10515                 if (n >= value)
    10516                     obj2->setNumberBeforeTrust(n + 1);
     11040                if (n >= value) {
     11041                  value = CoinMin(CoinMin(n+1,3*(value+1)/2),5*numberBeforeTrust_);
     11042                  obj2->setNumberBeforeTrust(value);
     11043                }
    1051711044            }
    1051811045        }
     
    1145111978            setCutoff(cutoff);
    1145211979            // change cutoff as constraint if wanted
    11453             if ((moreSpecialOptions_&16777216)!=0) {
    11454               if (solver_->getNumRows()>=numberRowsAtContinuous_) {
     11980            if (cutoffRowNumber_>=0) {
     11981              if (solver_->getNumRows()>cutoffRowNumber_) {
    1145511982                double offset;
    1145611983                solver_->getDblParam(OsiObjOffset, offset);
    11457                 solver_->setRowUpper(numberRowsAtContinuous_-1,cutoff+offset);
     11984                solver_->setRowUpper(cutoffRowNumber_,cutoff+offset);
    1145811985              }
    1145911986            }
     
    1163112158                setCutoff(cutoff);
    1163212159                // change cutoff as constraint if wanted
    11633                 if ((moreSpecialOptions_&16777216)!=0) {
    11634                   if (solver_->getNumRows()>=numberRowsAtContinuous_) {
     12160                if (cutoffRowNumber_>=0) {
     12161                  if (solver_->getNumRows()>cutoffRowNumber_) {
    1163512162                    double offset;
    1163612163                    solver_->getDblParam(OsiObjOffset, offset);
    11637                     solver_->setRowUpper(numberRowsAtContinuous_-1,cutoff+offset);
     12164                    solver_->setRowUpper(cutoffRowNumber_,cutoff+offset);
    1163812165                  }
    1163912166                }
     
    1235612883// Make partial cut into a global cut and save
    1235712884void
    12358 CbcModel::makePartialCut(const OsiRowCut * partialCut)
     12885CbcModel::makePartialCut(const OsiRowCut * partialCut,
     12886                         const OsiSolverInterface * solver)
    1235912887{
    1236012888  // get greedy cut
    1236112889  double bSum = partialCut->lb();
    1236212890  assert (bSum<0.0);
     12891  if (!solver)
     12892    solver=solver_;
    1236312893  int nConflict = partialCut->row().getNumElements();
    1236412894  const int * column = partialCut->row().getIndices();
    1236512895  const double * element = partialCut->row().getElements();
    1236612896  double * originalLower = topOfTree_->mutableLower();
    12367   const double * columnLower = solver_->getColLower();
     12897  const double * columnLower = solver->getColLower();
    1236812898  double * originalUpper = topOfTree_->mutableUpper();
    12369   const double * columnUpper = solver_->getColUpper();
     12899  const double * columnUpper = solver->getColUpper();
    1237012900  int nC=nConflict;
    1237112901  while (nConflict) {
     
    1240312933  printf("CUTa has %d (started at %d) - final bSum %g\n",nConflict,nC,bSum);
    1240412934  if (nConflict>1) {
     12935    if ((specialOptions_&1) != 0) {
     12936      const OsiRowCutDebugger *debugger = continuousSolver_->getRowCutDebugger() ;
     12937      if (debugger) {
     12938        if (debugger->invalidCut(newCut)) {
     12939          continuousSolver_->applyRowCuts(1,&newCut);
     12940          continuousSolver_->writeMps("bad");
     12941        }
     12942        CoinAssert (!debugger->invalidCut(newCut));
     12943      }
     12944    }
    1240512945    newCut.setGloballyValidAsInteger(2);
    1240612946    newCut.mutableRow().setTestForDuplicateIndex(false);
     
    1314513685            int totalNodes = numberNodes_ + numberExtraNodes_;
    1314613686            int totalIterations = numberIterations_ + numberExtraIterations_;
     13687            bool diving=false;
     13688            if ((moreSpecialOptions_&33554432)!=0) {
     13689              testDepth=COIN_INT_MAX;
     13690              if (oldNode&&(oldNode->depth()==-2||oldNode->depth()==4))
     13691                diving=true;
     13692            }
    1314713693            if (totalNodes*40 < totalIterations || numberNodes_ < 1000) {
    1314813694                doClp = false;
     
    1315213698                //     totalNodes,totalIterations,doClp ? 'Y' : 'N');
    1315313699            }
    13154             if (oldNode && fastNodeDepth_ >= 0 && oldNode->depth() >= testDepth &&/*!parentModel_*/(specialOptions_&2048) == 0
    13155                     && doClp && !cuts.sizeRowCuts()) {
     13700            if (oldNode &&
     13701                ((fastNodeDepth_ >= 0 && oldNode->depth() >= testDepth && doClp)||diving) &&/*!parentModel_*/(specialOptions_&2048) == 0
     13702                && !cuts.sizeRowCuts()) {
    1315613703                OsiClpSolverInterface * clpSolver
    1315713704                = dynamic_cast<OsiClpSolverInterface *> (solver_);
     
    1316413711#endif
    1316513712#ifdef COIN_HAS_CLP
    13166             int save;
     13713            int save=0;
    1316713714            OsiClpSolverInterface * clpSolver
    1316813715              = dynamic_cast<OsiClpSolverInterface *> (solver_);
     
    1334413891                assert (numberProblems);
    1334513892                int nProbMinus1 = numberProblems - 1;
     13893                lockThread();
    1334613894                for (int i = 0; i < currentNumberCuts_; i++) {
    1334713895                    if (addedCuts_[i])
    1334813896                        addedCuts_[i]->increment(nProbMinus1) ;
    1334913897                }
     13898                unlockThread();
    1335013899                for (int i = 0; i < numberProblems; i++) {
    1335113900                    double objectiveValue;
     
    1356614115        setCutoff(cutoff) ;
    1356714116        // change cutoff as constraint if wanted
    13568         if ((moreSpecialOptions_&16777216)!=0) {
    13569           if (solver_->getNumRows()>=numberRowsAtContinuous_) {
     14117        if (cutoffRowNumber_>=0) {
     14118          if (solver_->getNumRows()>cutoffRowNumber_) {
    1357014119            double offset;
    1357114120            solver_->getDblParam(OsiObjOffset, offset);
    13572             solver_->setRowUpper(numberRowsAtContinuous_-1,cutoff+offset);
     14121            solver_->setRowUpper(cutoffRowNumber_,cutoff+offset);
    1357314122          }
    1357414123        }
     
    1406714616// Set original columns as created by preprocessing
    1406814617void
    14069 CbcModel::setOriginalColumns(const int * originalColumns)
     14618CbcModel::setOriginalColumns(const int * originalColumns,int numberGood)
    1407014619{
    1407114620    int numberColumns = getNumCols();
    1407214621    delete [] originalColumns_;
    14073     originalColumns_ = CoinCopyOfArray(originalColumns, numberColumns);
     14622    originalColumns_ = new int [numberColumns];
     14623    int numberCopy=CoinMin(numberColumns,numberGood);
     14624    memcpy(originalColumns_,originalColumns,numberCopy*sizeof(int));
     14625    for (int i=numberCopy;i<numberColumns;i++)
     14626      originalColumns_[i]=-1;
    1407414627}
    1407514628// Set the cut modifier method
     
    1409814651{
    1409914652    int foundSolution = 0;
     14653    int saveNumberCutGenerators=numberCutGenerators_;
     14654    if ((moreSpecialOptions_&33554432)!=0 && (specialOptions_&2048)==0) {
     14655      if (node&&(node->depth()==-2||node->depth()==4))
     14656        numberCutGenerators_=0; // so can dive and branch
     14657    }
    1410014658    int currentNumberCuts = 0 ;
    1410114659    currentNode_ = node; // so can be accessed elsewhere
     
    1419514753            CbcBranchingObject * branch = static_cast <CbcBranchingObject *>(branch2) ;
    1419614754#endif
     14755#if 1
    1419714756            branch->setModel(this);
    1419814757            branchesLeft = node->branch(NULL); // old way
     14758#else
     14759            branchesLeft = node->branch(solver_);
     14760#endif
    1419914761            if (parallelMode() >= 0)
    1420014762                branch->setModel(baseModel);
     
    1460115163                  solver_->writeMpsNative("infeas2.mps", NULL, NULL, 2);
    1460215164                  solver_->getRowCutDebuggerAlways()->printOptimalSolution(*solver_);
    14603                   assert (solver_->getRowCutDebugger()) ;
     15165                  const OsiRowCutDebugger * debugger = solver_->getRowCutDebugger() ;
     15166                  assert (debugger) ;
     15167                  int numberRows0=continuousSolver_->getNumRows();
     15168                  int numberRows=solver_->getNumRows();
     15169                  const CoinPackedMatrix * rowCopy = solver_->getMatrixByRow();
     15170                  const int * rowLength = rowCopy->getVectorLengths();
     15171                  const double * elements = rowCopy->getElements();
     15172                  const int * column = rowCopy->getIndices();
     15173                  const CoinBigIndex * rowStart = rowCopy->getVectorStarts();
     15174                  const double * rowLower = solver_->getRowLower();
     15175                  const double * rowUpper = solver_->getRowUpper();
     15176                  for (int iRow=numberRows0;iRow<numberRows;iRow++) {
     15177                    OsiRowCut rc;
     15178                    rc.setLb(rowLower[iRow]);
     15179                    rc.setUb(rowUpper[iRow]);
     15180                    CoinBigIndex start = rowStart[iRow];
     15181                    rc.setRow(rowLength[iRow],column+start,elements+start,false);
     15182                    CoinAssert (!debugger->invalidCut(rc));
     15183                  }
    1460415184                  assert (feasible);
    1460515185                }
     
    1487215452            if (parallelMode() >= 0)
    1487315453                newNode = new CbcNode() ;
     15454#if 0
     15455            // Try diving
     15456            if (parallelMode() >= 0 && (specialOptions_&2048) == 0) {
     15457              // See if any diving heuristics set to do dive+save
     15458              CbcHeuristicDive * dive=NULL;
     15459              for (int i = 0; i < numberHeuristics_; i++) {
     15460                CbcHeuristicDive * possible = dynamic_cast<CbcHeuristicDive *>(heuristic_[i]);
     15461                if (possible&&possible->maxSimplexIterations()==COIN_INT_MAX) {
     15462                  // if more than one then rotate later?
     15463                  //if (possible->canHeuristicRun()) {
     15464                  if (node->depth()==0||node->depth()==5) {
     15465                    dive=possible;
     15466                    break;
     15467                  }
     15468                }
     15469              }
     15470              if (dive) {
     15471                int numberNodes;
     15472                CbcSubProblem ** nodes=NULL;
     15473                int branchState=dive->fathom(this,numberNodes,nodes);
     15474                if (branchState) {
     15475                  printf("new solution\n");
     15476                }
     15477                if (0) {
     15478                  for (int iNode=0;iNode<numberNodes;iNode++) {
     15479                    //tree_->push(nodes[iNode]) ;
     15480                  }
     15481                  assert (node->nodeInfo());
     15482                  if (node->nodeInfo()->numberBranchesLeft()) {
     15483                    tree_->push(node) ;
     15484                  } else {
     15485                    node->setActive(false);
     15486                  }
     15487                }
     15488                delete [] nodes;
     15489              }
     15490            }
     15491            // end try diving
     15492#endif
    1487415493            // Set objective value (not so obvious if NLP etc)
    1487515494            setObjectiveValue(newNode, node);
     
    1526315882        unlockThread();
    1526415883    }
     15884    numberCutGenerators_=saveNumberCutGenerators;
    1526515885    return foundSolution;
    1526615886}
     
    1552016140    for (int i = 0; i < numberHeuristics_; i++) {
    1552116141        CbcHeuristicDive * heuristic = dynamic_cast<CbcHeuristicDive *> (heuristic_[i]);
    15522         if (heuristic) {
     16142        if (heuristic && heuristic->maxSimplexIterations()!=COIN_INT_MAX) {
    1552316143            heuristic->setMaxSimplexIterations(nTree);
    1552416144            heuristic->setMaxSimplexIterationsAtRoot(nRoot);
     
    1688917509    char general[200];
    1689017510    if (clpSolver) {
    16891       clpSolver->getModelPtr()->dual(); // to get more randomness
     17511      clpSolver->getModelPtr()->dual(); // probably not needed
    1689217512      clpSolver->setWarmStart(NULL);
    16893       sprintf(general,"Starting multiple root solver - %d iterations in initialSolve",
    16894               clpSolver->getIterationCount());
     17513      sprintf(general,"Starting multiple root solver");
    1689517514    } else {
    1689617515#endif
     
    1691117530    return NULL;
    1691217531}
    16913 
    16914 
     17532OsiRowCut *
     17533CbcModel::conflictCut(const OsiSolverInterface * solver, bool & localCuts)
     17534{
     17535  OsiRowCut * cut=NULL;
     17536  localCuts=false;
     17537# ifdef COIN_HAS_CLP
     17538  const OsiClpSolverInterface * clpSolver
     17539    = dynamic_cast<const OsiClpSolverInterface *> (solver);
     17540  if (clpSolver&&topOfTree_) {
     17541    int debugMode=0;
     17542    const double * originalLower = topOfTree_->lower();
     17543    const double * originalUpper = topOfTree_->upper();
     17544    int typeCut = 1;
     17545    ClpSimplex * simplex = clpSolver->getModelPtr();
     17546    assert(simplex->status()==1);
     17547    if(simplex->ray()) {
     17548      {
     17549        int numberRows=simplex->numberRows();
     17550        double * saveRay=CoinCopyOfArray(simplex->ray(),numberRows);
     17551#define SAFE_RAY
     17552#ifdef SAFE_RAY
     17553        ClpSimplex & tempSimplex=*simplex;
     17554#else
     17555        ClpSimplex tempSimplex=*simplex;
     17556#endif
     17557        int logLevel=simplex->logLevel();
     17558        tempSimplex.setLogLevel(63);
     17559        tempSimplex.scaling(0);
     17560        tempSimplex.dual();
     17561        tempSimplex.setLogLevel(logLevel);
     17562        if (!tempSimplex.numberIterations()) {
     17563          double * ray = tempSimplex.ray();
     17564          int nBad=0;
     17565          for (int i=0;i<numberRows;i++) {
     17566            if (fabs(ray[i]-saveRay[i])>1.0e-3) {
     17567              if (debugMode)
     17568                printf("row %d true %g bad %g - diff %g\n",
     17569                       i,ray[i],saveRay[i],ray[i]-saveRay[i]);
     17570              nBad++;
     17571            }
     17572          }
     17573          if (nBad)
     17574            printf("%d mismatch crunch ray values\n",nBad);
     17575        }
     17576        delete [] saveRay;
     17577      }
     17578     // make sure we use non-scaled versions
     17579      ClpPackedMatrix * saveMatrix = simplex->swapScaledMatrix(NULL);
     17580      double * saveScale = simplex->swapRowScale(NULL);
     17581      //printf("Could do normal cut\n");
     17582      // could use existing arrays
     17583      int numberRows=simplex->numberRows();
     17584      int numberColumns=simplex->numberColumns();
     17585      double * farkas = new double [2*numberColumns+numberRows];
     17586      double * bound = farkas + numberColumns;
     17587      double * effectiveRhs = bound + numberColumns;
     17588      // sign as internally for dual - so swap if primal
     17589      /*const*/ double * ray = simplex->ray();
     17590      // have to get rid of local cut rows
     17591      if (whichGenerator_) {
     17592        const int * whichGenerator = whichGenerator_ - numberRowsAtContinuous_;
     17593        int badRows=0;
     17594        for (int iRow=numberRowsAtContinuous_;iRow<numberRows;iRow++) {
     17595          int iType=whichGenerator[iRow];
     17596          if ((iType>=0&&iType<10000)||iType<-1) {
     17597            if (fabs(ray[iRow])>1.0e-10) {
     17598              badRows++;
     17599            } else {
     17600              ray[iRow]=0.0;
     17601            }
     17602          }
     17603        }
     17604        if (badRows) {
     17605          if ((debugMode&1)!=0)
     17606            printf("%d rows from local cuts\n",badRows);
     17607          localCuts=true;
     17608        }
     17609      }
     17610      // get farkas row
     17611      memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
     17612      simplex->transposeTimes(-1.0,ray,farkas);
     17613      //const char * integerInformation = simplex->integerType_;
     17614      //assert (integerInformation);
     17615
     17616      int sequenceOut = simplex->sequenceOut();
     17617      // Put nonzero bounds in bound
     17618      const double * columnLower = simplex->columnLower();
     17619      const double * columnUpper = simplex->columnUpper();
     17620      int numberBad=0;
     17621      for (int i=0;i<numberColumns;i++) {
     17622        double value = farkas[i];
     17623        double boundValue=0.0;
     17624        if (simplex->getStatus(i)==ClpSimplex::basic) {
     17625          // treat as zero if small
     17626          if (fabs(value)<1.0e-8) {
     17627            value=0.0;
     17628            farkas[i]=0.0;
     17629          }
     17630          if (value) {
     17631            //printf("basic %d direction %d farkas %g\n",
     17632            //     i,simplex->directionOut(),value);
     17633            if (value<0.0)
     17634              boundValue=columnLower[i];
     17635            else
     17636              boundValue=columnUpper[i];
     17637          }
     17638        } else if (fabs(value)>1.0e-10) {
     17639          if (value<0.0)
     17640            boundValue=columnLower[i];
     17641          else
     17642            boundValue=columnUpper[i];
     17643        }
     17644        bound[i]=boundValue;
     17645        if (fabs(boundValue)>1.0e10)
     17646          numberBad++;
     17647      }
     17648      const double * rowLower = simplex->rowLower();
     17649      const double * rowUpper = simplex->rowUpper();
     17650      //int pivotRow = simplex->spareIntArray_[3];
     17651      //bool badPivot=pivotRow<0;
     17652      for (int i=0;i<numberRows;i++) {
     17653        double value = ray[i];
     17654        double rhsValue=0.0;
     17655        if (simplex->getRowStatus(i)==ClpSimplex::basic) {
     17656          // treat as zero if small
     17657          if (fabs(value)<1.0e-8) {
     17658            value=0.0;
     17659            ray[i]=0.0;
     17660          }
     17661          if (value) {
     17662            //printf("row basic %d direction %d ray %g\n",
     17663            //     i,simplex->directionOut(),value);
     17664            if (value<0.0)
     17665              rhsValue=rowLower[i];
     17666            else
     17667              rhsValue=rowUpper[i];
     17668          }
     17669        } else if (fabs(value)>1.0e-10) {
     17670          if (value<0.0)
     17671            rhsValue=rowLower[i];
     17672          else
     17673              rhsValue=rowUpper[i];
     17674        }
     17675        effectiveRhs[i]=rhsValue;
     17676      }
     17677      simplex->times(-1.0,bound,effectiveRhs);
     17678      simplex->swapRowScale(saveScale);
     17679      simplex->swapScaledMatrix(saveMatrix);
     17680      double bSum=0.0;
     17681      for (int i=0;i<numberRows;i++) {
     17682        bSum += effectiveRhs[i]*ray[i];
     17683      }
     17684      if (numberBad||bSum>-1.0e-4) {
     17685#ifndef NDEBUG
     17686        printf("bad BOUND bSum %g  - %d bad\n",
     17687               bSum,numberBad);
     17688#endif
     17689      } else {
     17690        const char * integerInformation = simplex->integerInformation();
     17691        assert (integerInformation);
     17692        int * conflict = new int[numberColumns];
     17693        double * sort = new double [numberColumns];
     17694        double relax=0.0;
     17695        int nConflict=0;
     17696        int nOriginal=0;
     17697        int nFixed=0;
     17698        for (int iColumn=0;iColumn<numberColumns;iColumn++) {
     17699          if (integerInformation[iColumn]) {
     17700            if ((debugMode&1)!=0)
     17701            printf("%d status %d %g <= %g <=%g (orig %g, %g) farkas %g\n",
     17702                   iColumn,simplex->getStatus(iColumn),columnLower[iColumn],
     17703                   simplex->primalColumnSolution()[iColumn],columnUpper[iColumn],
     17704                   originalLower[iColumn],originalUpper[iColumn],
     17705                   farkas[iColumn]);
     17706            double gap = originalUpper[iColumn]-originalLower[iColumn];
     17707            if (!gap)
     17708              continue;
     17709            if (gap==columnUpper[iColumn]-columnLower[iColumn])
     17710              nOriginal++;
     17711            if (columnUpper[iColumn]==columnLower[iColumn])
     17712              nFixed++;
     17713            if (fabs(farkas[iColumn])<1.0e-15) {
     17714              farkas[iColumn]=0.0;
     17715              continue;
     17716            }
     17717            // temp
     17718            if (gap>=20000.0&&false) {
     17719              // can't use
     17720              if (farkas[iColumn]<0.0) {
     17721                assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
     17722                // farkas is negative - relax lower bound all way
     17723                relax +=
     17724                  farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
     17725              } else {
     17726                assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
     17727                // farkas is positive - relax upper bound all way
     17728                relax +=
     17729                  farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
     17730              }
     17731              continue;
     17732            }
     17733            if (originalLower[iColumn]==columnLower[iColumn]) {
     17734              if (farkas[iColumn]>0.0&&(simplex->getStatus(iColumn)==ClpSimplex::atUpperBound
     17735                                        ||simplex->getStatus(iColumn)==ClpSimplex::isFixed
     17736                                        ||iColumn==sequenceOut)) {
     17737                // farkas is positive - add to list
     17738                gap=originalUpper[iColumn]-columnUpper[iColumn];
     17739                if (gap) {
     17740                  sort[nConflict]=-farkas[iColumn]*gap;
     17741                  conflict[nConflict++]=iColumn;
     17742                }
     17743                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
     17744              }
     17745            } else if (originalUpper[iColumn]==columnUpper[iColumn]) {
     17746              if (farkas[iColumn]<0.0&&(simplex->getStatus(iColumn)==ClpSimplex::atLowerBound
     17747                                        ||simplex->getStatus(iColumn)==ClpSimplex::isFixed
     17748                                        ||iColumn==sequenceOut)) {
     17749                // farkas is negative - add to list
     17750                gap=columnLower[iColumn]-originalLower[iColumn];
     17751                if (gap) {
     17752                  sort[nConflict]=farkas[iColumn]*gap;
     17753                  conflict[nConflict++]=iColumn;
     17754                }
     17755                //assert (gap>columnUpper[iColumn]-columnLower[iColumn]);
     17756              }
     17757            } else {
     17758              // can't use
     17759              if (farkas[iColumn]<0.0) {
     17760                assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
     17761                // farkas is negative - relax lower bound all way
     17762                relax +=
     17763                  farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
     17764              } else {
     17765                assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
     17766                // farkas is positive - relax upper bound all way
     17767                relax +=
     17768                  farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
     17769              }
     17770            }
     17771            assert(relax>=0.0);
     17772          } else {
     17773            // not integer - but may have been got at
     17774            double gap = originalUpper[iColumn]-originalLower[iColumn];
     17775            if (gap>columnUpper[iColumn]-columnLower[iColumn]) {
     17776              // can't use
     17777              if (farkas[iColumn]<0.0) {
     17778                assert(originalLower[iColumn]-columnLower[iColumn]<=0.0);
     17779                // farkas is negative - relax lower bound all way
     17780                relax +=
     17781                  farkas[iColumn]*(originalLower[iColumn]-columnLower[iColumn]);
     17782              } else {
     17783                assert(originalUpper[iColumn]-columnUpper[iColumn]>=0.0);
     17784                // farkas is positive - relax upper bound all way
     17785                relax +=
     17786                  farkas[iColumn]*(originalUpper[iColumn]-columnUpper[iColumn]);
     17787              }
     17788            }
     17789          }
     17790        }
     17791        if (relax+bSum>-1.0e-4||!nConflict) {
     17792          if (relax+bSum>-1.0e-4) {
     17793#ifndef NDEBUG
     17794            printf("General integers relax bSum to %g\n",relax+bSum);
     17795#endif
     17796          } else {
     17797            printf("All variables relaxed and still infeasible - what does this mean?\n");
     17798            int nR=0;
     17799            for (int i=0;i<numberRows;i++) {
     17800              if (fabs(ray[i])>1.0e-10)
     17801                nR++;
     17802              else
     17803                ray[i]=0.0;
     17804            }
     17805            int nC=0;
     17806            for (int i=0;i<numberColumns;i++) {
     17807              if (fabs(farkas[i])>1.0e-10)
     17808                nC++;
     17809              else
     17810                farkas[i]=0.0;
     17811            }
     17812            if (nR<3&&nC<5) {
     17813              printf("BAD %d nonzero rows, %d nonzero columns\n",nR,nC);
     17814            }
     17815          }
     17816        } else {
     17817          printf("BOUNDS violation bSum %g (relaxed %g) - %d at original bounds, %d fixed - %d in conflict\n",bSum,
     17818                 relax+bSum,nOriginal,nFixed,nConflict);
     17819          CoinSort_2(sort,sort+nConflict,conflict);
     17820          int nC=nConflict;
     17821          bSum+=relax;
     17822          double saveBsum = bSum;
     17823          while (nConflict) {
     17824            //int iColumn=conflict[nConflict-1];
     17825            double change=-sort[nConflict-1];
     17826            if (bSum+change>-1.0e-4)
     17827              break;
     17828            nConflict--;
     17829            bSum += change;
     17830          }
     17831          if (!nConflict) {
     17832            int nR=0;
     17833            for (int i=0;i<numberRows;i++) {
     17834              if (fabs(ray[i])>1.0e-10)
     17835                nR++;
     17836              else
     17837                ray[i]=0.0;
     17838            }
     17839            int nC=0;
     17840            for (int i=0;i<numberColumns;i++) {
     17841              if (fabs(farkas[i])>1.0e-10)
     17842                nC++;
     17843              else
     17844                farkas[i]=0.0;
     17845            }
     17846            if (nR<3&&nC<5) {
     17847              printf("BAD2 %d nonzero rows, %d nonzero columns\n",nR,nC);
     17848            }
     17849          }
     17850          // no point doing if no reduction (or big?) ?
     17851          if (nConflict<nC+1&&nConflict<500) {
     17852            cut=new OsiRowCut();
     17853            cut->setUb(COIN_DBL_MAX);
     17854            if (!typeCut) {
     17855              double lo=1.0;
     17856              for (int i=0;i<nConflict;i++) {
     17857                int iColumn = conflict[i];
     17858                if (originalLower[iColumn]==columnLower[iColumn]) {
     17859                  // must be at least one higher
     17860                  sort[i]=1.0;
     17861                  lo += originalLower[iColumn];
     17862                } else {
     17863                  // must be at least one lower
     17864                  sort[i]=-1.0;
     17865                  lo -= originalUpper[iColumn];
     17866                }
     17867              }
     17868              cut->setLb(lo);
     17869              cut->setRow(nConflict,conflict,sort);
     17870              printf("CUT has %d (started at %d) - final bSum %g\n",nConflict,nC,bSum);
     17871            } else {
     17872              // just save for use later
     17873              // first take off small
     17874              int nC2=nC;
     17875              while (nC2) {
     17876                //int iColumn=conflict[nConflict-1];
     17877                double change=-sort[nC2-1];
     17878                if (saveBsum+change>-1.0e-4||change>1.0e-4)
     17879                  break;
     17880                nC2--;
     17881                saveBsum += change;
     17882              }
     17883              cut->setLb(saveBsum);
     17884              for (int i=0;i<nC2;i++) {
     17885                int iColumn = conflict[i];
     17886                sort[i]=farkas[iColumn];
     17887              }
     17888              cut->setRow(nC2,conflict,sort);
     17889              printf("Stem CUT has %d (greedy %d - with small %d) - saved bSum %g final greedy bSum %g\n",
     17890                     nC2,nConflict,nC,saveBsum,bSum);
     17891            }
     17892          }
     17893        }
     17894        delete [] conflict;
     17895        delete [] sort;
     17896      }
     17897      delete [] farkas;
     17898    } else {
     17899      printf("No dual ray\n");
     17900    }
     17901  }
     17902#endif
     17903  return cut;
     17904}
     17905
  • stable/2.8/Cbc/src/CbcModel.hpp

    r1839 r1883  
    359359    void makeGlobalCut(const OsiColCut & cut);
    360360    /// Make partial cut into a global cut and save
    361     void makePartialCut(const OsiRowCut * cut);
     361  void makePartialCut(const OsiRowCut * cut, const OsiSolverInterface * solver=NULL);
    362362    /// Make partial cuts into global cuts
    363363    void makeGlobalCuts();
     
    443443    */
    444444    void AddIntegers();
    445 
    446445    /**
    447446      Save copy of the model.
     
    866865    }
    867866    /// Set original columns as created by preprocessing
    868     void setOriginalColumns(const int * originalColumns) ;
     867    void setOriginalColumns(const int * originalColumns,
     868                            int numberGood=COIN_INT_MAX) ;
     869    /// Create conflict cut (well - most of)
     870    OsiRowCut * conflictCut(const OsiSolverInterface * solver, bool & localCuts);
    869871
    870872    /** Set the print frequency.
     
    17341736    inline void setDefaultHandler(bool yesNo) {
    17351737        defaultHandler_ = yesNo;
     1738    }
     1739    /// Check default handler
     1740    inline bool defaultHandler() const {
     1741        return defaultHandler_;
    17361742    }
    17371743    //@}
     
    18181824        22 bit (4194304) - Conflict analysis
    18191825        23 bit (8388608) - Conflict analysis - temporary bit
    1820         24 bit (16777216) - Add cutoff as LP constraint
     1826        24 bit (16777216) - Add cutoff as LP constraint (out)
     1827        25 bit (33554432) - diving/reordering
     1828        26 bit (67108864) - load global cuts from file
     1829        27 bit (134217728) - append binding global cuts to file
     1830        28 bit (268435456) - idiot branching
     1831        29 bit (536870912) - don't make fake objective
    18211832    */
    18221833    inline void setMoreSpecialOptions(int value) {
     
    18271838        return moreSpecialOptions_;
    18281839    }
    1829   /// Set time method
     1840    /// Set cutoff as constraint
     1841    inline void setCutoffAsConstraint(bool yesNo) {
     1842      cutoffRowNumber_ = (yesNo) ? -2 : -1;
     1843    }
     1844    /// Set time method
    18301845    inline void setUseElapsedTime(bool yesNo) {
    18311846        if (yesNo)
     
    18381853        return (moreSpecialOptions_&131072)!=0;
    18391854    }
     1855    /// Get useful temporary pointer
     1856    inline void * temporaryPointer() const
     1857    { return temporaryPointer_;}
     1858    /// Set useful temporary pointer
     1859    inline void setTemporaryPointer(void * pointer)
     1860    { temporaryPointer_=pointer;}
    18401861    /// Go to dantzig pivot selection if easy problem (clp only)
    18411862#ifdef COIN_HAS_CLP
     
    24542475    /// Number of rows at continuous
    24552476    int numberRowsAtContinuous_;
     2477    /**
     2478       -1 - cutoff as constraint not activated
     2479       -2 - waiting to activate
     2480       >=0 - activated
     2481     */
     2482    int cutoffRowNumber_;
    24562483    /// Maximum number of cuts
    24572484    int maximumNumberCuts_;
     
    26212648    /// Arrays with analysis results
    26222649    double * analyzeResults_;
     2650    /// Useful temporary pointer
     2651    void * temporaryPointer_;
    26232652    /// Number of nodes infeasible by normal branching (before cuts)
    26242653    int numberInfeasibleNodes_;
  • stable/2.8/Cbc/src/CbcNode.cpp

    r1839 r1883  
    16331633                    break;
    16341634                }
    1635             }
     1635            } else {
     1636              obj->initializeForBranching(model);
     1637            }
    16361638        }
    16371639    }
     
    21322134                    if (dynamicObject) {
    21332135                        // Use this object's numberBeforeTrust
    2134                         int numberBeforeTrust = dynamicObject->numberBeforeTrust();
     2136                        int numberBeforeTrustThis = dynamicObject->numberBeforeTrust();
    21352137                        iColumn = dynamicObject->columnNumber();
    21362138                        gotDown = false;
    21372139                        numberThisDown = dynamicObject->numberTimesDown();
    2138                         if (numberThisDown >= numberBeforeTrust)
     2140                        if (numberThisDown >= numberBeforeTrustThis)
    21392141                            gotDown = true;
    21402142                        gotUp = false;
    21412143                        numberThisUp = dynamicObject->numberTimesUp();
    2142                         if (numberThisUp >= numberBeforeTrust)
     2144                        if (numberThisUp >= numberBeforeTrustThis)
    21432145                            gotUp = true;
    21442146                        if (!depth_ && false) {
     
    25592561                            dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object) ;
    25602562                        // Use this object's numberBeforeTrust
    2561                         int numberBeforeTrust = dynamicObject->numberBeforeTrust();
     2563                        int numberBeforeTrustThis = dynamicObject->numberBeforeTrust();
    25622564                        int iSequence = dynamicObject->columnNumber();
    25632565                        double value = saveSolution[iSequence];
     
    25672569                        int numberThisDown = dynamicObject->numberTimesDown();
    25682570                        int numberThisUp = dynamicObject->numberTimesUp();
    2569                         if (!numberBeforeTrust) {
     2571                        if (!numberBeforeTrustThis) {
    25702572                            // override
    25712573                            downEstimate[iObject] = downPenalty;
     
    25772579                            min1 = 0.8 * min1 + 0.2 * max1;
    25782580                            sort[j] = - min1;
    2579                         } else if (numberThisDown < numberBeforeTrust ||
    2580                                    numberThisUp < numberBeforeTrust) {
    2581                             double invTrust = 1.0 / static_cast<double> (numberBeforeTrust);
    2582                             if (numberThisDown < numberBeforeTrust) {
     2581                        } else if (numberThisDown < numberBeforeTrustThis ||
     2582                                   numberThisUp < numberBeforeTrustThis) {
     2583                            double invTrust = 1.0 / static_cast<double> (numberBeforeTrustThis);
     2584                            if (numberThisDown < numberBeforeTrustThis) {
    25832585                                double fraction = numberThisDown * invTrust;
    25842586                                downEstimate[iObject] = fraction * downEstimate[iObject] + (1.0 - fraction) * downPenalty;
    25852587                            }
    2586                             if (numberThisUp < numberBeforeTrust) {
     2588                            if (numberThisUp < numberBeforeTrustThis) {
    25872589                                double fraction = numberThisUp * invTrust;
    25882590                                upEstimate[iObject] = fraction * upEstimate[iObject] + (1.0 - fraction) * upPenalty;
     
    26172619                                delete branch;
    26182620                            }
    2619                             if (number >= numberBeforeTrust)
    2620                                 dynamicObject->setNumberBeforeTrust(number + 1);
     2621                            if (number >= numberBeforeTrustThis)
     2622                              dynamicObject->setNumberBeforeTrust(CoinMin(number + 1,5*numberBeforeTrust));
    26212623                            numberFixed++;
    26222624                        }
     
    28142816                numberTest = numberToDo;
    28152817                numberStrong=numberToDo;
    2816                 skipAll=false;
     2818                skipAll=0;
    28172819                searchStrategy=0;
    28182820                solver->setIntParam(OsiMaxNumIterationHotStart, 100000);
     2821                //printf("Strong branching type %d\n",strongType);
    28192822              }
    28202823            }
     
    28812884                if (model->messageHandler()->logLevel() > 3 && numberBeforeTrust && dynamicObject)
    28822885                    dynamicObject->print(1, choice.possibleBranch->value());
     2886                if (strongType)
     2887                  canSkip=0;
    28832888                if (skipAll < 0)
    2884                     canSkip = true;
    2885                 if (strongType)
    2886                   canSkip=false;
     2889                    canSkip = 1;
    28872890                if (!canSkip) {
    28882891                    if (!doneHotStart) {
     
    28962899                        if (!solver->isProvenOptimal()) {
    28972900                          skipAll=-2;
    2898                           canSkip = true;
     2901                          canSkip = 1;
    28992902                        }
    29002903                        xMark++;
     
    30893092                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    30903093#endif
     3094                        if (!solver->isProvenOptimal()) {
     3095                          skipAll=-2;
     3096                          canSkip = 1;
     3097                        }
     3098                        xMark++;
    30913099                    }
    30923100#if 0 //def DO_ALL_AT_ROOT
     
    32773285                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    32783286#endif
     3287                        if (!solver->isProvenOptimal()) {
     3288                          skipAll=-2;
     3289                          canSkip = 1;
     3290                        }
     3291                        xMark++;
    32793292                    }
    32803293
     
    34263439                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    34273440#endif
     3441                        if (!solver->isProvenOptimal()) {
     3442                          skipAll=-2;
     3443                          canSkip = 1;
     3444                        }
     3445                        xMark++;
    34283446                        // may be infeasible (if other way stopped on iterations)
    34293447                        if (goneInfeasible) {
     
    34733491                        memcpy(saveUpper,solver->getColUpper(),solver->getNumCols()*sizeof(double));
    34743492#endif
     3493                        if (!solver->isProvenOptimal()) {
     3494                          skipAll=-2;
     3495                          canSkip = 1;
     3496                        }
     3497                        xMark++;
    34753498                        // may be infeasible (if other way stopped on iterations)
    34763499                        if (goneInfeasible) {
     
    36503673    }
    36513674    if (numberUnfinished*10 < numberStrongDone &&
    3652             numberStrongIterations*20 < model->getIterationCount()&&
     3675        model->numberStrongIterations()*20 < model->getIterationCount()&&
    36533676                                !auxiliaryInfo->solutionAddsCuts()) {
    36543677        //printf("increasing trust\n");
     
    45134536    double infeasibility = object->infeasibility(&usefulInfo, preferredWay);
    45144537    if (thisOne->whichSolution() >= 0) {
    4515         ClpNode * nodeInfo = thisOne->nodeInfo(thisOne->whichSolution());
    4516         nodeInfo->applyNode(simplex, 2);
     4538        ClpNode * nodeInfo=NULL;
     4539        if ((model->moreSpecialOptions()&33554432)==0) {
     4540          nodeInfo = thisOne->nodeInfo(thisOne->whichSolution());
     4541          nodeInfo->applyNode(simplex, 2);
     4542        } else {
     4543          // from diving
     4544          CbcSubProblem ** nodes = reinterpret_cast<CbcSubProblem **>
     4545            (model->temporaryPointer());
     4546          assert (nodes);
     4547          int numberDo=thisOne->numberNodes()-1;
     4548          for (int iNode=0;iNode<numberDo;iNode++)
     4549            nodes[iNode]->apply(solver,1);
     4550          nodes[numberDo]->apply(solver,9+16);
     4551        }
    45174552        int saveLogLevel = simplex->logLevel();
    45184553        simplex->setLogLevel(0);
     
    45234558        if (simplex->status()) {
    45244559            //simplex->writeMps("bad7.mps",2);
    4525             if (nodeInfo->objectiveValue() > cutoff - 1.0e-2)
     4560            if (nodeInfo) {
     4561              if (nodeInfo->objectiveValue() > cutoff - 1.0e-2)
    45264562                goodSolution = false;
    4527             else
     4563              else
    45284564                assert (!simplex->status());
     4565            } else {
     4566              // debug diving
     4567              assert (!simplex->status());
     4568            }
    45294569        }
    45304570        if (goodSolution) {
     
    45844624        } else {
    45854625            branch_ = thisOne->createCbcBranch(solver, &usefulInfo, preferredWay);
    4586             // Set to firat one (and change when re-pushing)
    4587             CbcGeneralBranchingObject * branch =
     4626            if (branch_) {
     4627              // Set to first one (and change when re-pushing)
     4628              CbcGeneralBranchingObject * branch =
    45884629                dynamic_cast <CbcGeneralBranchingObject *> (branch_);
    4589             branch->state(objectiveValue_, sumInfeasibilities_,
    4590                           numberUnsatisfied_, 0);
    4591             branch->setNode(this);
    4592             anyAction = 0;
     4630              branch->state(objectiveValue_, sumInfeasibilities_,
     4631                            numberUnsatisfied_, 0);
     4632              branch->setNode(this);
     4633              anyAction = 0;
     4634            } else {
     4635              anyAction = -2; // mark as infeasible
     4636            }
    45934637        }
    45944638    } else {
  • stable/2.8/Cbc/src/CbcObject.hpp

    r1854 r1883  
    252252    /// Redoes data when sequence numbers change
    253253    virtual void redoSequenceEtc(CbcModel * , int , const int * ) {}
     254    /// Initialize for branching
     255    virtual void initializeForBranching(CbcModel * ) {}
    254256
    255257protected:
  • stable/2.8/Cbc/src/CbcSolver.cpp

    r1875 r1883  
    178178#include "CglKnapsackCover.hpp"
    179179#include "CglRedSplit.hpp"
     180#include "CglRedSplit2.hpp"
     181#include "CglGMI.hpp"
    180182#include "CglClique.hpp"
    181183#include "CglFlowCover.hpp"
     
    644646    parameters_[whichParam(CBC_PARAM_STR_ZEROHALFCUTS, numberParameters_, parameters_)].setCurrentOption("off");
    645647    parameters_[whichParam(CBC_PARAM_STR_REDSPLITCUTS, numberParameters_, parameters_)].setCurrentOption("off");
     648    parameters_[whichParam(CBC_PARAM_STR_REDSPLIT2CUTS, numberParameters_, parameters_)].setCurrentOption("off");
     649    parameters_[whichParam(CBC_PARAM_STR_GMICUTS, numberParameters_, parameters_)].setCurrentOption("off");
    646650    parameters_[whichParam(CBC_PARAM_STR_CLIQUECUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    647651    parameters_[whichParam(CBC_PARAM_STR_MIXEDCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    648652    parameters_[whichParam(CBC_PARAM_STR_FLOWCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    649     parameters_[whichParam(CBC_PARAM_STR_TWOMIRCUTS, numberParameters_, parameters_)].setCurrentOption("root");
     653    parameters_[whichParam(CBC_PARAM_STR_TWOMIRCUTS, numberParameters_, parameters_)].setCurrentOption("ifmove");
    650654    parameters_[whichParam(CBC_PARAM_STR_LANDPCUTS, numberParameters_, parameters_)].setCurrentOption("off");
    651655    parameters_[whichParam(CBC_PARAM_STR_RESIDCUTS, numberParameters_, parameters_)].setCurrentOption("off");
     
    12701274        int * prioritiesIn = NULL;
    12711275        std::vector< std::pair< std::string, double > > mipStart;
     1276        std::vector< std::pair< std::string, double > > mipStartBefore;
    12721277        int numberSOS = 0;
    12731278        int * sosStart = NULL;
     
    15811586        int redsplitAction = 0;
    15821587
     1588        CglRedSplit2 redsplit2Gen;
     1589        //redsplit2Gen.setLimit(100);
     1590        // set default action (0=off,1=on,2=root)
     1591        // Off
     1592        int redsplit2Action = 0;
     1593
     1594        CglGMI GMIGen;
     1595        //GMIGen.setLimit(100);
     1596        // set default action (0=off,1=on,2=root)
     1597        // Off
     1598        int GMIAction = 0;
     1599
    15831600        CglFakeClique cliqueGen(NULL, false);
    15841601        //CglClique cliqueGen(false,true);
     
    16021619        twomirGen.setMaxElements(250);
    16031620        // set default action (0=off,1=on,2=root)
    1604         int twomirAction = 2;
     1621        int twomirAction = 3;
    16051622#ifndef DEBUG_MALLOC
    16061623        CglLandP landpGen;
     1624        landpGen.validator().setMinViolation(1.0e-4);
    16071625#endif
    16081626        // set default action (0=off,1=on,2=root)
     
    16361654        int doKKT = 0;
    16371655        int crossover = 2; // do crossover unless quadratic
     1656        bool biLinearProblem=false;
    16381657        // For names
    16391658        int lengthName = 0;
     
    16731692            iParam = whichParam(CBC_PARAM_STR_PROBINGCUTS, numberParameters_, parameters_);
    16741693            parameters_[iParam].setCurrentOption("on");
    1675             probingAction = 1;
    1676             parameters_[iParam].setCurrentOption("forceOnStrong");
    1677             probingAction = 8;
     1694            probingAction = 3;
     1695            //parameters_[iParam].setCurrentOption("forceOnStrong");
     1696            //probingAction = 8;
    16781697        }
    16791698        std::string field;
     
    17941813                    model_.setDblParam(CbcModel::CbcStartSeconds, CoinCpuTime());
    17951814#endif
     1815                  biLinearProblem=false;
    17961816                    // check if any integers
    17971817#ifndef CBC_OTHER_SOLVER
     
    23392359                            redsplitAction = action;
    23402360                            break;
     2361                        case CBC_PARAM_STR_REDSPLIT2CUTS:
     2362                            defaultSettings = false; // user knows what she is doing
     2363                            redsplit2Action = action;
     2364                            break;
     2365                        case CBC_PARAM_STR_GMICUTS:
     2366                            defaultSettings = false; // user knows what she is doing
     2367                            GMIAction = action;
     2368                            break;
    23412369                        case CBC_PARAM_STR_CLIQUECUTS:
    23422370                            defaultSettings = false; // user knows what she is doing
     
    24002428                                redsplitAction = action;
    24012429                                parameters_[whichParam(CBC_PARAM_STR_REDSPLITCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     2430                                redsplit2Action = action;
     2431                                parameters_[whichParam(CBC_PARAM_STR_REDSPLIT2CUTS, numberParameters_, parameters_)].setCurrentOption(action);
     2432                                GMIAction = action;
     2433                                parameters_[whichParam(CBC_PARAM_STR_GMICUTS, numberParameters_, parameters_)].setCurrentOption(action);
    24022434                                landpAction = action;
    24032435                                parameters_[whichParam(CBC_PARAM_STR_LANDPCUTS, numberParameters_, parameters_)].setCurrentOption(action);
     
    30823114                            bool miplib = type == CBC_PARAM_ACTION_MIPLIB;
    30833115                            int logLevel = parameters_[slog].intValue();
     3116                            int truncateColumns=COIN_INT_MAX;
     3117                            int * newPriorities=NULL;
    30843118                            // Reduce printout
    30853119                            if (logLevel <= 1) {
     
    31403174                                        si->setIntegerPriority(1000);
    31413175                                        si->setBiLinearPriority(10000);
     3176                                        biLinearProblem=true;
    31423177                                        si->setSpecialOptions2(2 + 4 + 8);
    31433178                                        CoinModel * model2 = coinModel;
     
    32813316                                            assert (solver3);
    32823317                                            solution = solver3->bestSolution();
    3283                                             double bestObjectiveValue = solver3->bestObjectiveValue();
    3284                                             linkSolver->setBestObjectiveValue(bestObjectiveValue);
    3285                                             linkSolver->setBestSolution(solution, solver3->getNumCols());
     3318                                            double bestObjectiveValue = solver3->bestObjectiveValue();
     3319                                            linkSolver->setBestObjectiveValue(bestObjectiveValue);
     3320                                            if (solution) {
     3321                                              linkSolver->setBestSolution(solution, solver3->getNumCols());
     3322                                            }
    32863323                                            CbcHeuristicDynamic3 dynamic(model_);
    32873324                                            dynamic.setHeuristicName("dynamic pass thru");
    32883325                                            model_.addHeuristic(&dynamic);
    32893326                                            // if convex
    3290                                             if ((linkSolver->specialOptions2()&4) != 0) {
     3327                                            if ((linkSolver->specialOptions2()&4) != 0 && solution) {
    32913328                                                int numberColumns = coinModel->numberColumns();
    32923329                                                assert (linkSolver->objectiveVariable() == numberColumns);
     
    36353672                                    preProcess = 0;
    36363673                            }
     3674                            if (mipStartBefore.size())
     3675                              {
     3676                                CbcModel tempModel=*babModel_;
     3677                                std::vector< std::string > colNames;
     3678                                for ( int i=0 ; (i<babModel_->solver()->getNumCols()) ; ++i )
     3679                                  colNames.push_back( model_.solver()->getColName(i) );
     3680                                std::vector< double > x( babModel_->getNumCols(), 0.0 );
     3681                                double obj;
     3682                                int status = computeCompleteSolution( &tempModel, colNames, mipStartBefore, &x[0], obj );
     3683                                // set cutoff
     3684                                if (!status)
     3685                                  babModel_->setCutoff(CoinMin(babModel_->getCutoff(),obj+1.0e-4));
     3686                              }
    36373687                            if (preProcess && type == CBC_PARAM_ACTION_BAB) {
    36383688#ifndef CBC_OTHER_SOLVER
     
    37223772                                        process.passInProhibited(prohibited, numberColumns);
    37233773                                        delete [] prohibited;
     3774                                    }
     3775                                    if (0) {
     3776                                     
     3777                                      // Special integers
     3778                                      int numberColumns = saveSolver->getNumCols();
     3779                                      char * prohibited = new char[numberColumns];
     3780                                      memset(prohibited, 0, numberColumns);
     3781                                      const CoinPackedMatrix * matrix = saveSolver->getMatrixByCol();
     3782                                      const int * columnLength = matrix->getVectorLengths();
     3783                                      int numberProhibited=0;
     3784                                      for (int iColumn = numberColumns-1; iColumn >=0; iColumn--) {
     3785                                        if (!saveSolver->isInteger(iColumn)||
     3786                                            columnLength[iColumn]>1)
     3787                                          break;
     3788                                        numberProhibited++;
     3789                                        prohibited[iColumn] = 1;
     3790                                      }
     3791                                      if (numberProhibited) {
     3792                                        process.passInProhibited(prohibited, numberColumns);
     3793                                        printf("**** Treating last %d integers as special - give high priority?\n",numberProhibited);
     3794                                      }
     3795                                      delete [] prohibited;
    37243796                                    }
    37253797                                    if (!model_.numberObjects() && true) {
     
    39023974                                // we have to keep solver2 so pass clone
    39033975                                solver2 = solver2->clone();
     3976                                // see if extra variables wanted
     3977                                int threshold =
     3978                                  parameters_[whichParam(CBC_PARAM_INT_EXTRA_VARIABLES, numberParameters_, parameters_)].intValue();
     3979                                if (threshold) {
     3980                                  int numberColumns = solver2->getNumCols();
     3981                                  int highPriority=0;
     3982                                  /*
     3983                                    normal - no priorities
     3984                                    >10000 equal high priority
     3985                                    >20000 higher priority for higher cost
     3986                                  */
     3987                                  if (threshold>10000) {
     3988                                    highPriority=threshold/10000;
     3989                                    threshold -= 10000*highPriority;
     3990                                  }
     3991                                  const double * columnLower = solver2->getColLower();
     3992                                  const double * columnUpper = solver2->getColUpper();
     3993                                  const double * objective = solver2->getObjCoefficients();
     3994                                  int numberIntegers = 0;
     3995                                  int numberBinary = 0;
     3996                                  int numberTotalIntegers=0;
     3997                                  double * obj = new double [numberColumns];
     3998                                  int * which = new int [numberColumns];
     3999                                  for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     4000                                    if (solver2->isInteger(iColumn)) {
     4001                                      numberTotalIntegers++;
     4002                                      if (columnUpper[iColumn] > columnLower[iColumn]) {
     4003                                        numberIntegers++;
     4004                                        if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
     4005                                          numberBinary++;
     4006                                      }
     4007                                    }
     4008                                  }
     4009                                  int numberSort=0;
     4010                                  int numberZero=0;
     4011                                  int numberZeroContinuous=0;
     4012                                  int numberDifferentObj=0;
     4013                                  int numberContinuous=0;
     4014                                  for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     4015                                    if (columnUpper[iColumn] > columnLower[iColumn]) {
     4016                                      if (solver2->isInteger(iColumn)) {
     4017                                        if (!objective[iColumn]) {
     4018                                          numberZero++;
     4019                                        } else {
     4020                                          obj[numberSort]= fabs(objective[iColumn]);
     4021                                          which[numberSort++]=iColumn;
     4022                                        }
     4023                                      } else if (objective[iColumn]) {
     4024                                        numberContinuous++;
     4025                                      } else {
     4026                                        numberZeroContinuous++;
     4027                                      }
     4028                                    }
     4029                                  }
     4030                                  CoinSort_2(obj,obj+numberSort,which);
     4031                                  double last=obj[0];
     4032                                  for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     4033                                    if (fabs(obj[jColumn]-last)>1.0e-12) {
     4034                                      numberDifferentObj++;
     4035                                      last=obj[jColumn];
     4036                                    }
     4037                                  }
     4038                                  numberDifferentObj++;
     4039                                  sprintf(generalPrint,"Problem has %d integers (%d of which binary) and %d continuous",
     4040                                         numberIntegers,numberBinary,numberColumns-numberIntegers);
     4041                                  generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4042                                    << generalPrint
     4043                                    << CoinMessageEol;
     4044                                  if (numberColumns>numberIntegers) {
     4045                                    sprintf(generalPrint,"%d continuous have nonzero objective, %d have zero objective",
     4046                                            numberContinuous,numberZeroContinuous);
     4047                                    generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4048                                      << generalPrint
     4049                                      << CoinMessageEol;
     4050                                  }
     4051                                  sprintf(generalPrint,"%d integer have nonzero objective, %d have zero objective, %d different nonzero (taking abs)",
     4052                                          numberSort,numberZero,numberDifferentObj);
     4053                                  generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4054                                    << generalPrint
     4055                                    << CoinMessageEol;
     4056                                  if (numberDifferentObj<=threshold + (numberZero) ? 1 : 0 && numberDifferentObj) {
     4057                                    int * backward=NULL;
     4058                                    if (highPriority) {
     4059                                      newPriorities = new int [numberTotalIntegers+numberDifferentObj+numberColumns];
     4060                                      backward=newPriorities+numberTotalIntegers+numberDifferentObj;
     4061                                      numberTotalIntegers=0;
     4062                                      for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     4063                                        if (solver2->isInteger(iColumn)) {
     4064                                          backward[iColumn]=numberTotalIntegers;
     4065                                          newPriorities[numberTotalIntegers++]=10000;
     4066                                        }
     4067                                      }
     4068                                    }
     4069                                    int iLast=0;
     4070                                    double last=obj[0];
     4071                                    for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     4072                                      if (fabs(obj[jColumn]-last)>1.0e-12) {
     4073                                        sprintf(generalPrint,"%d variables have objective of %g",
     4074                                               jColumn-iLast,last);
     4075                                        generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4076                                          << generalPrint
     4077                                          << CoinMessageEol;
     4078                                        iLast=jColumn;
     4079                                        last=obj[jColumn];
     4080                                      }
     4081                                    }
     4082                                    sprintf(generalPrint,"%d variables have objective of %g",
     4083                                           numberSort-iLast,last);
     4084                                    generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4085                                      << generalPrint
     4086                                      << CoinMessageEol;
     4087                                    int spaceNeeded=numberSort+numberDifferentObj;
     4088                                    int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     4089                                    double * elementAdd = new double[spaceNeeded];
     4090                                    int * rowAdd = new int[numberDifferentObj+1];
     4091                                    double * objectiveNew = new double[3*numberDifferentObj];
     4092                                    double * lowerNew = objectiveNew+numberDifferentObj;
     4093                                    double * upperNew = lowerNew+numberDifferentObj;
     4094                                    memset(columnAdd+spaceNeeded,0,
     4095                                           (numberDifferentObj+1)*sizeof(int));
     4096                                    iLast=0;
     4097                                    last=obj[0];
     4098                                    numberDifferentObj=0;
     4099                                    int priorityLevel=9999;
     4100                                    int numberElements=0;
     4101                                    rowAdd[0]=0;
     4102                                    for (int jColumn = 1; jColumn < numberSort+1; jColumn++) {
     4103                                      if (jColumn==numberSort||fabs(obj[jColumn]-last)>1.0e-12) {
     4104                                        // not if just one
     4105                                        if (jColumn-iLast>1) {
     4106                                          // do priority
     4107                                          if (highPriority==1) {
     4108                                            newPriorities[numberTotalIntegers+numberDifferentObj]
     4109                                              = 500;
     4110                                          } else if (highPriority==2) {
     4111                                            newPriorities[numberTotalIntegers+numberDifferentObj]
     4112                                              = priorityLevel;
     4113                                            priorityLevel--;
     4114                                          }
     4115                                          int iColumn=which[iLast];
     4116                                          objectiveNew[numberDifferentObj]=objective[iColumn];
     4117                                          double lower=0.0;
     4118                                          double upper=0.0;
     4119                                          for (int kColumn=iLast;kColumn<jColumn;kColumn++) {
     4120                                            iColumn=which[kColumn];
     4121                                            solver2->setObjCoeff(iColumn,0.0);
     4122                                            double lowerValue=columnLower[iColumn];
     4123                                            double upperValue=columnUpper[iColumn];
     4124                                            double elementValue=-1.0;
     4125                                            if (objectiveNew[numberDifferentObj]*objective[iColumn]<0.0) {
     4126                                              lowerValue=-columnUpper[iColumn];
     4127                                              upperValue=-columnLower[iColumn];
     4128                                              elementValue=1.0;
     4129                                            }
     4130                                            columnAdd[numberElements]=iColumn;
     4131                                            elementAdd[numberElements++]=elementValue;
     4132                                            if (lower!=-COIN_DBL_MAX) {
     4133                                              if (lowerValue!=-COIN_DBL_MAX)
     4134                                                lower += lowerValue;
     4135                                              else
     4136                                                lower=-COIN_DBL_MAX;
     4137                                            }
     4138                                            if (upper!=COIN_DBL_MAX) {
     4139                                              if (upperValue!=COIN_DBL_MAX)
     4140                                                upper += upperValue;
     4141                                              else
     4142                                                upper=COIN_DBL_MAX;
     4143                                            }
     4144                                          }
     4145                                          columnAdd[numberElements]=numberColumns+numberDifferentObj;
     4146                                          elementAdd[numberElements++]=1.0;
     4147                                          lowerNew[numberDifferentObj]=lower;
     4148                                          upperNew[numberDifferentObj]=upper;
     4149                                          numberDifferentObj++;
     4150                                          rowAdd[numberDifferentObj]=numberElements;
     4151                                        } else if (highPriority) {
     4152                                          // just one
     4153                                          // do priority
     4154                                          int iColumn=which[iLast];
     4155                                          int iInt=backward[iColumn];
     4156                                          if (highPriority==1) {
     4157                                            newPriorities[iInt] = 500;
     4158                                          } else {
     4159                                            newPriorities[iInt] = priorityLevel;
     4160                                            priorityLevel--;
     4161                                          }
     4162                                        }
     4163                                        if (jColumn<numberSort) {
     4164                                          iLast=jColumn;
     4165                                          last=obj[jColumn];
     4166                                        }
     4167                                      }
     4168                                    }
     4169                                    if (numberDifferentObj) {
     4170                                      // add columns
     4171                                      solver2->addCols(numberDifferentObj,
     4172                                                       columnAdd+spaceNeeded, NULL, NULL,
     4173                                                       lowerNew, upperNew,objectiveNew);
     4174                                      // add constraints and make integer if all integer in group
     4175                                      for (int iObj=0; iObj < numberDifferentObj; iObj++) {
     4176                                        lowerNew[iObj]=0.0;
     4177                                        upperNew[iObj]=0.0;
     4178                                        solver2->setInteger(numberColumns+iObj);
     4179                                      }
     4180                                      solver2->addRows(numberDifferentObj,
     4181                                                       rowAdd,columnAdd,elementAdd,
     4182                                                       lowerNew, upperNew);
     4183                                      sprintf(generalPrint,"Replacing model - %d new variables",numberDifferentObj);
     4184                                      generalMessageHandler->message(CLP_GENERAL, generalMessages)
     4185                                        << generalPrint
     4186                                        << CoinMessageEol;
     4187                                      truncateColumns=numberColumns;
     4188                                    }
     4189                                    delete [] columnAdd;
     4190                                    delete [] elementAdd;
     4191                                    delete [] rowAdd;
     4192                                    delete [] objectiveNew;
     4193                                  }
     4194                                  delete [] which;
     4195                                  delete [] obj;
     4196                                }
    39044197                                babModel_->assignSolver(solver2);
    3905                                 babModel_->setOriginalColumns(process.originalColumns());
     4198                                babModel_->setOriginalColumns(process.originalColumns(),
     4199                                                              truncateColumns);
    39064200                                babModel_->initialSolve();
    39074201                                babModel_->setMaximumSeconds(timeLeft - (CoinCpuTime() - time2));
     
    40284322                                        else if (useCosts == 5)
    40294323                                            dsort[n++] = -columnLength[iColumn];
     4324                                        else if (useCosts == 6)
     4325                                            dsort[n++] = (columnLength[iColumn]==1) ? -1.0 : 0.0;
     4326                                        else if (useCosts == 7)
     4327                                            dsort[n++] = (objective[iColumn]) ? -1.0 : 0.0;
    40304328                                    }
    40314329                                }
     
    40414339                                    priority[iPut] = level;
    40424340                                }
     4341                                if(newPriorities ) {
     4342                                  // get rid of
     4343                                  delete [] newPriorities;
     4344                                  newPriorities = NULL;
     4345                                }
    40434346                                babModel_->passInPriorities( priority, false);
    40444347                                integersOK = true;
     
    40724375                            int numberGenerators = 0;
    40734376                            int translate[] = { -100, -1, -99, -98, 1, -1098, -999, 1, 1, 1, -1};
     4377                            int maximumSlowPasses =
     4378                              parameters_[whichParam(CBC_PARAM_INT_MAX_SLOW_CUTS,
     4379                                                     numberParameters_, parameters_)].intValue();
    40744380                            if (probingAction) {
    40754381                                int numberColumns = babModel_->solver()->getNumCols();
     
    41564462                                  int when = laGomory/3;
    41574463                                  char atEnd = (when<2) ? 1 : 0;
    4158                                   int gomoryTypeMajor = 0;
     4464                                  int gomoryTypeMajor = 10;
    41594465                                  if (when<3) {
    41604466                                    // normal as well
     
    41634469                                    switches[numberGenerators++] = 0;
    41644470                                    if (when==2)
    4165                                       gomoryTypeMajor=10;
     4471                                      gomoryTypeMajor=20;
    41664472                                  } else {
    41674473                                    when--; // so on
     
    41774483                                    accuracyFlag[numberGenerators] = 3;
    41784484                                    doAtEnd[numberGenerators]=atEnd;
     4485                                    if (atEnd) {
     4486                                      babModel_->cutGenerator(numberGenerators)->setMaximumTries(99999999);
     4487                                      babModel_->cutGenerator(numberGenerators)->setHowOften(1);
     4488                                    }
    41794489                                    switches[numberGenerators++] = 0;
    41804490                                  }
     
    41854495                                    accuracyFlag[numberGenerators] = 3;
    41864496                                    doAtEnd[numberGenerators]=atEnd;
     4497                                    if (atEnd) {
     4498                                      babModel_->cutGenerator(numberGenerators)->setMaximumTries(99999999);
     4499                                      babModel_->cutGenerator(numberGenerators)->setHowOften(1);
     4500                                    }
    41874501                                    switches[numberGenerators++] = 0;
    41884502                                  }
     
    42034517                                babModel_->addCutGenerator(&redsplitGen, translate[redsplitAction], "Reduce-and-split");
    42044518                                accuracyFlag[numberGenerators] = 5;
    4205                                 switches[numberGenerators++] = 1;
     4519                                // slow ? - just do a few times
     4520                                if (redsplitAction!=1) {
     4521                                  babModel_->cutGenerator(numberGenerators)->setMaximumTries(maximumSlowPasses);
     4522                                  babModel_->cutGenerator(numberGenerators)->setHowOften(10);
     4523                                }
     4524                                switches[numberGenerators++] = 1;
     4525                            }
     4526                            if (redsplit2Action && !complicatedInteger) {
     4527                                int maxLength=256;
     4528                                if (redsplit2Action>2) {
     4529                                  redsplit2Action-=2;
     4530                                  maxLength=COIN_INT_MAX;
     4531                                }
     4532                                CglRedSplit2Param & parameters = redsplit2Gen.getParam();
     4533                                parameters.setMaxNonzeroesTab(maxLength);
     4534                                babModel_->addCutGenerator(&redsplit2Gen, translate[redsplit2Action], "Reduce-and-split(2)");
     4535                                accuracyFlag[numberGenerators] = 5;
     4536                                // slow ? - just do a few times
     4537                                if (redsplit2Action!=1) {
     4538                                  babModel_->cutGenerator(numberGenerators)->setHowOften(maximumSlowPasses);
     4539                                  babModel_->cutGenerator(numberGenerators)->setMaximumTries(maximumSlowPasses);
     4540                                  babModel_->cutGenerator(numberGenerators)->setHowOften(5);
     4541                                }
     4542                               
     4543                                switches[numberGenerators++] = 1;
     4544                            }
     4545                            if (GMIAction && !complicatedInteger) {
     4546                                if (GMIAction>5) {
     4547                                  // long
     4548                                  GMIAction-=5;
     4549                                  CglGMIParam & parameters = GMIGen.getParam();
     4550                                  parameters.setMaxSupportRel(1.0);
     4551                                }
     4552                                babModel_->addCutGenerator(&GMIGen, translate[GMIAction], "Gomory(2)");
     4553                                if (GMIAction==5) {
     4554                                  // just at end and root
     4555                                  GMIAction=2;
     4556                                  doAtEnd[numberGenerators]=1;
     4557                                  babModel_->cutGenerator(numberGenerators)->setMaximumTries(99999999);
     4558                                  babModel_->cutGenerator(numberGenerators)->setHowOften(1);
     4559                                }
     4560                                accuracyFlag[numberGenerators] = 5;
     4561                                switches[numberGenerators++] = 0;
    42064562                            }
    42074563                            if (cliqueAction) {
     
    42304586                                    twomirGen.setMaxElements(2000);
    42314587                                }
    4232                                 babModel_->addCutGenerator(&twomirGen, translate[twomirAction], "TwoMirCuts");
    4233                                 accuracyFlag[numberGenerators] = 4;
    4234                                 switches[numberGenerators++] = 1;
     4588                                int laTwomir = parameters_[whichParam(CBC_PARAM_STR_LATWOMIRCUTS, numberParameters_, parameters_)].currentOptionAsInteger();
     4589                                int twomirType = translate[twomirAction];
     4590                                if (!laTwomir) {
     4591                                  // Normal
     4592                                  babModel_->addCutGenerator(&twomirGen, translate[twomirAction], "TwoMirCuts");
     4593                                  accuracyFlag[numberGenerators] = 4;
     4594                                  switches[numberGenerators++] = 1;
     4595                                } else {
     4596                                  laTwomir--;
     4597                                  int type = (laTwomir % 3)+1;
     4598                                  int when = laTwomir/3;
     4599                                  char atEnd = (when<2) ? 1 : 0;
     4600                                  int twomirTypeMajor = 10;
     4601                                  if (when<3) {
     4602                                    // normal as well
     4603                                    babModel_->addCutGenerator(&twomirGen, translate[twomirAction], "TwoMirCuts");
     4604                                    accuracyFlag[numberGenerators] = 4;
     4605                                    switches[numberGenerators++] = 1;
     4606                                    if (when==2)
     4607                                      twomirTypeMajor=10;
     4608                                  } else {
     4609                                    when--; // so on
     4610                                    twomirTypeMajor=20;
     4611                                  }
     4612                                  if (!when)
     4613                                    twomirType=-99; // root
     4614                                  twomirGen.passInOriginalSolver(babModel_->solver());
     4615                                  if ((type&1) !=0) {
     4616                                    // clean
     4617                                    twomirGen.setTwomirType(twomirTypeMajor+1);
     4618                                    babModel_->addCutGenerator(&twomirGen, twomirType, "TwoMirCutsL1");
     4619                                    accuracyFlag[numberGenerators] = 4;
     4620                                    doAtEnd[numberGenerators]=atEnd;
     4621                                    switches[numberGenerators++] = atEnd ? 0 : 1;
     4622                                  }
     4623                                  if ((type&2) !=0) {
     4624                                    // simple
     4625                                    twomirGen.setTwomirType(twomirTypeMajor+2);
     4626                                    babModel_->addCutGenerator(&twomirGen, twomirType, "TwoMirCutsL2");
     4627                                    accuracyFlag[numberGenerators] = 4;
     4628                                    doAtEnd[numberGenerators]=atEnd;
     4629                                    switches[numberGenerators++] = atEnd ? 0 : 1;
     4630                                  }
     4631                                }
    42354632                            }
    42364633#ifndef DEBUG_MALLOC
     
    42384635                                babModel_->addCutGenerator(&landpGen, translate[landpAction], "LiftAndProject");
    42394636                                accuracyFlag[numberGenerators] = 5;
     4637                                // slow ? - just do a few times
     4638                                if (landpAction!=1) {
     4639                                  babModel_->cutGenerator(numberGenerators)->setMaximumTries(maximumSlowPasses);
     4640                                  babModel_->cutGenerator(numberGenerators)->setHowOften(10);
     4641                                }
    42404642                                switches[numberGenerators++] = 1;
    42414643                            }
     
    42654667                                CbcCutGenerator * generator = babModel_->cutGenerator(iGenerator);
    42664668                                int howOften = generator->howOften();
    4267                                 if (howOften == -98 || howOften == -99)
     4669                                if (howOften == -98 || howOften == -99 || generator->maximumTries()>0)
    42684670                                    generator->setSwitchOffIfLessThan(switches[iGenerator]);
    42694671                                // Use if any at root as more likely later and fairly cheap
     
    42734675                                if (doAtEnd[iGenerator]) {
    42744676                                    generator->setWhetherCallAtEnd(true);
    4275                                     generator->setMustCallAgain(true);
     4677                                    //generator->setMustCallAgain(true);
    42764678                                }
    42774679                                generator->setTiming(true);
     
    45244926#endif
    45254927                                const int * originalColumns = preProcess ? process.originalColumns() : NULL;
    4526 
    45274928                                if (mipStart.size())
    45284929                                {
     4930                                   std::vector< std::string > colNames;
    45294931                                   if (preProcess)
    45304932                                   {
    4531                                       std::vector< std::string > colNames;
     4933                                     for ( int i=0 ; (i<babModel_->solver()->getNumCols()) ; ++i ) {
     4934                                       int iColumn = babModel_->originalColumns()[i];
     4935                                       if (iColumn>=0) {
     4936                                         colNames.push_back( model_.solver()->getColName( iColumn ) );
     4937                                       } else {
     4938                                         // created variable
     4939                                         char newName[15];
     4940                                         sprintf(newName,"C%7.7d",i);
     4941                                         colNames.push_back( newName );
     4942                                       }
     4943                                     }
     4944                                   } else {
    45324945                                      for ( int i=0 ; (i<babModel_->solver()->getNumCols()) ; ++i )
    4533                                          colNames.push_back( model_.solver()->getColName( babModel_->originalColumns()[i] ) );
    4534                                       //printf("--- %s %d\n", babModel_->solver()->getColName(0).c_str(), babModel_->solver()->getColNames().size() );
    4535                                       //printf("-- SIZES of models %d %d %d\n", model_.getNumCols(),  babModel_->solver()->getNumCols(), babModel_->solver()->getColNames().size() );
    4536                                       std::vector< double > x( babModel_->getNumCols(), 0.0 );
    4537                                       double obj;
    4538                                       int status = computeCompleteSolution( babModel_, colNames, mipStart, &x[0], obj );
    4539                                       if (!status)
    4540                                          babModel_->setBestSolution( &x[0], x.size(), obj, false );
    4541                                    }
    4542                                 }
     4946                                         colNames.push_back( model_.solver()->getColName(i) );
     4947                                   }
     4948                                   //printf("--- %s %d\n", babModel_->solver()->getColName(0).c_str(), babModel_->solver()->getColNames().size() );
     4949                                   //printf("-- SIZES of models %d %d %d\n", model_.getNumCols(),  babModel_->solver()->getNumCols(), babModel_->solver()->getColNames().size() );
     4950                                   std::vector< double > x( babModel_->getNumCols(), 0.0 );
     4951                                   double obj;
     4952                                   int status = computeCompleteSolution( babModel_, colNames, mipStart, &x[0], obj );
     4953                                   if (!status)
     4954                                     babModel_->setBestSolution( &x[0], x.size(), obj, false );
     4955                                }
    45434956
    45444957                                if (solutionIn && useSolution >= 0) {
     
    45724985                                            prioritiesIn2[i] = 1000000;
    45734986                                        }
     4987#ifndef NDEBUG
    45744988                                        int iLast = -1;
     4989#endif
    45754990                                        for (i = 0; i < numberColumns; i++) {
    45764991                                            int iColumn = originalColumns[i];
     4992#ifndef NDEBUG
    45774993                                            assert (iColumn > iLast);
    45784994                                            iLast = iColumn;
     4995#endif
    45794996                                            solutionIn2[i] = solutionIn2[iColumn];
    45804997                                            if (prioritiesIn)
     
    46215038                                        // extend arrays in case SOS
    46225039                                        assert (originalColumns);
    4623                                         int n = originalColumns[numberColumns-1] + 1;
     5040                                        int n = CoinMin(truncateColumns,numberColumns);
     5041                                        n = originalColumns[n-1] + 1;
    46245042                                        n = CoinMax(n, CoinMax(numberColumns, numberOriginalColumns));
    46255043                                        int * newColumn = new int[n];
     
    46275045                                        for (i = 0; i < numberOriginalColumns; i++)
    46285046                                            newColumn[i] = -1;
    4629                                         for (i = 0; i < numberColumns; i++)
     5047                                        for (i = 0; i < CoinMin(truncateColumns,numberColumns); i++)
    46305048                                            newColumn[originalColumns[i]] = i;
    46315049                                        if (!integersOK) {
     
    52165634                                    babModel_->setBranchingMethod(decision);
    52175635                                    if (useCosts && testOsiOptions >= 0) {
     5636                                      if(newPriorities ) {
     5637                                        // get rid of
     5638                                        delete [] newPriorities;
     5639                                        newPriorities = NULL;
     5640                                      }
    52185641                                        int numberColumns = babModel_->getNumCols();
    52195642                                        int * sort = new int[numberColumns];
     
    56266049                                    donor.setStoredRowCuts(NULL);
    56276050                                }
     6051                                // We may have priorities from extra variables
     6052                                if(newPriorities ) {
     6053                                  if (truncateColumns<babModel_->getNumCols()) {
     6054                                    // set new ones as high prority
     6055                                    babModel_->passInPriorities(newPriorities,false);
     6056                                  }
     6057                                  delete [] newPriorities;
     6058                                }
    56286059#ifdef JJF_ZERO
    56296060                                int extra5 = parameters_[whichParam(EXTRA5, numberParameters_, parameters_)].intValue();
     
    56436074                                }
    56446075#endif
    5645                                 int multipleRoot = parameters_[whichParam(CBC_PARAM_INT_MULTIPLEROOTS, numberParameters_, parameters_)].intValue();
    5646                                 babModel_->setMultipleRootTries(multipleRoot);
    56476076                                int specialOptions = parameters_[whichParam(CBC_PARAM_INT_STRONG_STRATEGY, numberParameters_, parameters_)].intValue();
    56486077                                if (specialOptions>=0)
    56496078                                  babModel_->setStrongStrategy(specialOptions);
     6079                                int jParam = whichParam(CBC_PARAM_STR_CUTOFF_CONSTRAINT,
     6080                                                        numberParameters_, parameters_);
     6081                                if(parameters_[jParam].currentOptionAsInteger())
     6082                                  babModel_->setCutoffAsConstraint(true);
     6083                                int multipleRoot = parameters_[whichParam(CBC_PARAM_INT_MULTIPLEROOTS, numberParameters_, parameters_)].intValue();
     6084                                if (multipleRoot<10000) {
     6085                                  babModel_->setMultipleRootTries(multipleRoot);
     6086                                } else {
     6087                                  // will be doing repeated solves and saves
     6088                                  int numberGoes=multipleRoot/10000;
     6089                                  multipleRoot-=10000*numberGoes;
     6090                                  int moreOptions=babModel_->moreSpecialOptions();
     6091                                  if (numberGoes<100) {
     6092                                    remove("global.cuts");
     6093                                    remove("global.fix");
     6094                                    moreOptions |= (67108864|134217728);
     6095                                  } else {
     6096                                    moreOptions |= 67108864*(numberGoes/100);
     6097                                    numberGoes=numberGoes%100;
     6098                                  }
     6099                                  babModel_->setMultipleRootTries(multipleRoot);
     6100                                  babModel_->setMoreSpecialOptions(moreOptions);
     6101                                  int numberColumns=babModel_->getNumCols();
     6102                                  double * bestValues=new double [numberGoes];
     6103                                  double ** bestSolutions=new double * [numberGoes];
     6104                                  int * which=new int[numberGoes];
     6105                                  int numberSolutions=0;
     6106                                  sprintf(generalPrint,"Starting %d passes each with %d solvers",
     6107                                          numberGoes, multipleRoot%10);
     6108                                  generalMessageHandler->message(CLP_GENERAL, generalMessages)
     6109                                    << generalPrint
     6110                                    << CoinMessageEol;
     6111                                  for (int iGo=0;iGo<numberGoes;iGo++) {
     6112                                    sprintf(generalPrint,"Starting pass %d",iGo+1);
     6113                                    generalMessageHandler->message(CLP_GENERAL, generalMessages)
     6114                                      << generalPrint
     6115                                      << CoinMessageEol;
     6116                                    CbcModel tempModel=*babModel_;
     6117                                    tempModel.setMaximumNodes(0);
     6118                                    // switch off cuts if none generated
     6119                                    int numberGenerators = tempModel.numberCutGenerators();
     6120                                    for (int iGenerator = 0; iGenerator < numberGenerators; iGenerator++) {
     6121                                      CbcCutGenerator * generator = tempModel.cutGenerator(iGenerator);
     6122                                      generator->setSwitchOffIfLessThan(1);
     6123                                    }
     6124                                    // random
     6125                                    tempModel.setRandomSeed(tempModel.getRandomSeed()+100000000*(iGo+1+5*numberGoes));
     6126                                    for (int i=0;i<tempModel.numberHeuristics();i++)
     6127                                      tempModel.heuristic(i)->setSeed(tempModel.heuristic(i)->getSeed()+100000000*iGo);
     6128#ifndef CBC_OTHER_SOLVER
     6129                                    OsiClpSolverInterface * solver = dynamic_cast<OsiClpSolverInterface *> (tempModel.solver());
     6130                                    ClpSimplex * simplex = solver->getModelPtr();
     6131                                    int solverSeed=simplex->randomNumberGenerator()->getSeed();
     6132                                    simplex->setRandomSeed(solverSeed+100000000*(iGo+1));
     6133#endif
     6134                                    tempModel.branchAndBound();
     6135                                    if (tempModel.bestSolution()) {
     6136                                      bestSolutions[numberSolutions]=
     6137                                        CoinCopyOfArray(tempModel.bestSolution(),
     6138                                                        numberColumns);
     6139                                      bestValues[numberSolutions]=-tempModel.getMinimizationObjValue();
     6140                                      which[numberSolutions]=numberSolutions;
     6141                                      numberSolutions++;
     6142                                    }
     6143                                  }
     6144                                  // allow solutions
     6145                                  double sense = babModel_->solver()->getObjSense();;
     6146                                  CoinSort_2(bestValues,bestValues+numberSolutions,which);
     6147                                  babModel_->setMoreSpecialOptions(moreOptions&(~16777216));
     6148                                  for (int i=0;i<numberSolutions;i++) {
     6149                                    int k=which[i];
     6150                                    if (bestValues[i]<babModel_->getCutoff()) {
     6151                                      babModel_->setBestSolution(bestSolutions[k],numberColumns,
     6152                                                                 -bestValues[i]*sense,true);
     6153                                      babModel_->incrementUsed(bestSolutions[k]);
     6154                                    }
     6155                                    delete [] bestSolutions[k];
     6156                                  }
     6157                                  babModel_->setMoreSpecialOptions(moreOptions);
     6158                                  if (numberSolutions)
     6159                                    sprintf(generalPrint,"Ending major passes - best solution %g",-bestValues[numberSolutions-1]);
     6160                                  else
     6161                                    sprintf(generalPrint,"Ending major passes - no solution found");
     6162                                    generalMessageHandler->message(CLP_GENERAL, generalMessages)
     6163                                      << generalPrint
     6164                                      << CoinMessageEol;
     6165                                  delete [] which;
     6166                                  delete [] bestValues;
     6167                                  delete [] bestSolutions;
     6168                                }
     6169                                if (biLinearProblem)
     6170                                  babModel_->setSpecialOptions(babModel_->specialOptions() &(~(512|32768)));
    56506171                                babModel_->branchAndBound(statistics);
     6172                                if (truncateColumns<babModel_->solver()->getNumCols()) {
     6173                                  OsiSolverInterface * solverX = babModel_->solver();
     6174                                  int numberColumns=solverX->getNumCols();
     6175                                  int numberRows=solverX->getNumRows();
     6176                                  int numberDelete = numberColumns-truncateColumns;
     6177                                  int * delStuff=new int [numberDelete];
     6178                                  for (int i=0;i<numberDelete;i++)
     6179                                    delStuff[i]=i+truncateColumns;
     6180                                  solverX->deleteCols(numberDelete,delStuff);
     6181                                  for (int i=0;i<numberDelete;i++)
     6182                                    delStuff[i]=i+numberRows-numberDelete;
     6183                                  solverX->deleteRows(numberDelete,delStuff);
     6184                                  delete [] delStuff;
     6185                                }
    56516186                                //#define CLP_FACTORIZATION_INSTRUMENT
    56526187#ifdef CLP_FACTORIZATION_INSTRUMENT
     
    71987733                            double msObj;
    71997734                            readMIPStart( &model_, fileName.c_str(), mipStart, msObj );
     7735                            // copy to before preprocess if has .before.
     7736                            if (strstr(fileName.c_str(),".before.")) {
     7737                              mipStartBefore = mipStart;
     7738                              sprintf(generalPrint,"file %s will be used before preprocessing.",fileName.c_str() );
     7739                              generalMessageHandler->message(CLP_GENERAL, generalMessages)
     7740                                << generalPrint
     7741                                << CoinMessageEol;
     7742                            }
    72007743                        } else {
    72017744#ifndef DISALLOW_PRINTING
     
    88059348    parameters[whichParam(CBC_PARAM_STR_ZEROHALFCUTS, numberParameters, parameters)].setCurrentOption("off");
    88069349    parameters[whichParam(CBC_PARAM_STR_REDSPLITCUTS, numberParameters, parameters)].setCurrentOption("off");
     9350    parameters[whichParam(CBC_PARAM_STR_REDSPLIT2CUTS, numberParameters, parameters)].setCurrentOption("off");
     9351    parameters[whichParam(CBC_PARAM_STR_GMICUTS, numberParameters, parameters)].setCurrentOption("off");
    88079352    parameters[whichParam(CBC_PARAM_STR_CLIQUECUTS, numberParameters, parameters)].setCurrentOption("ifmove");
    88089353    parameters[whichParam(CBC_PARAM_STR_MIXEDCUTS, numberParameters, parameters)].setCurrentOption("ifmove");
  • stable/2.8/Cbc/src/CbcSolverAnalyze.cpp

    r1854 r1883  
    307307        int logLevel = generalMessageHandler->logLevel();
    308308        CbcModel model(*solver);
    309         model.passInMessageHandler(generalMessageHandler);
     309        if (!model.defaultHandler())
     310          model.passInMessageHandler(generalMessageHandler);
    310311        if (noPrinting_)
    311312            model.setLogLevel(0);
  • stable/2.8/Cbc/src/CbcSolverHeuristics.cpp

    r1854 r1883  
    14561456
    14571457    if (useDIVING > 0) {
     1458        int majorIterations=64;
    14581459        int diveOptions2 = parameters_[whichParam(CBC_PARAM_INT_DIVEOPT, numberParameters_, parameters_)].intValue();
    14591460        int diveOptions;
    14601461        if (diveOptions2 > 99) {
    14611462            // switch on various active set stuff
    1462             diveOptions = diveOptions2 % 100;
    1463             diveOptions2 -= diveOptions;
     1463            diveOptions = diveOptions2%100;
     1464            diveOptions2 /= 100;
    14641465        } else {
    14651466            diveOptions = diveOptions2;
     
    14721473            heuristicDV.setHeuristicName("DiveVectorLength");
    14731474            heuristicDV.setWhen(diveOptions);
     1475            if (diveOptions2) {
     1476              heuristicDV.setMaxIterations(majorIterations);
     1477              heuristicDV.setPercentageToFix(0.0);
     1478              heuristicDV.setMaxSimplexIterations(COIN_INT_MAX);
     1479              heuristicDV.setMaxSimplexIterationsAtRoot(COIN_INT_MAX-(diveOptions2-1));
     1480            }
    14741481            model->addHeuristic(&heuristicDV) ;
    14751482        }
     
    14781485            heuristicDG.setHeuristicName("DiveGuided");
    14791486            heuristicDG.setWhen(diveOptions);
     1487            if (diveOptions2) {
     1488              heuristicDG.setMaxIterations(majorIterations);
     1489              heuristicDG.setPercentageToFix(0.0);
     1490              heuristicDG.setMaxSimplexIterations(COIN_INT_MAX);
     1491              heuristicDG.setMaxSimplexIterationsAtRoot(COIN_INT_MAX-(diveOptions2-1));
     1492            }
    14801493            model->addHeuristic(&heuristicDG) ;
    14811494        }
     
    14841497            heuristicDF.setHeuristicName("DiveFractional");
    14851498            heuristicDF.setWhen(diveOptions);
     1499            if (diveOptions2) {
     1500              heuristicDF.setMaxIterations(majorIterations);
     1501              heuristicDF.setPercentageToFix(0.0);
     1502              heuristicDF.setMaxSimplexIterations(COIN_INT_MAX);
     1503              heuristicDF.setMaxSimplexIterationsAtRoot(COIN_INT_MAX-(diveOptions2-1));
     1504            }
    14861505            model->addHeuristic(&heuristicDF) ;
    14871506        }
     
    14901509            heuristicDC.setHeuristicName("DiveCoefficient");
    14911510            heuristicDC.setWhen(diveOptions);
     1511            if (diveOptions2) {
     1512              heuristicDC.setMaxIterations(majorIterations);
     1513              heuristicDC.setPercentageToFix(0.0);
     1514              heuristicDC.setMaxSimplexIterations(COIN_INT_MAX);
     1515              heuristicDC.setMaxSimplexIterationsAtRoot(COIN_INT_MAX-(diveOptions2-1));
     1516            }
    14921517            model->addHeuristic(&heuristicDC) ;
    14931518        }
     
    14961521            heuristicDL.setHeuristicName("DiveLineSearch");
    14971522            heuristicDL.setWhen(diveOptions);
     1523            if (diveOptions2) {
     1524              heuristicDL.setMaxIterations(majorIterations);
     1525              heuristicDL.setPercentageToFix(0.0);
     1526              heuristicDL.setMaxSimplexIterations(COIN_INT_MAX);
     1527              heuristicDL.setMaxSimplexIterationsAtRoot(COIN_INT_MAX-(diveOptions2-1));
     1528            }
    14981529            model->addHeuristic(&heuristicDL) ;
    14991530        }
     
    15011532            CbcHeuristicDivePseudoCost heuristicDP(*model);
    15021533            heuristicDP.setHeuristicName("DivePseudoCost");
    1503             heuristicDP.setWhen(diveOptions + diveOptions2);
     1534            heuristicDP.setWhen(diveOptions /*+ diveOptions2*/);
     1535            if (diveOptions2) {
     1536              heuristicDP.setMaxIterations(majorIterations);
     1537              heuristicDP.setPercentageToFix(0.0);
     1538              heuristicDP.setMaxSimplexIterations(COIN_INT_MAX);
     1539              heuristicDP.setMaxSimplexIterationsAtRoot(COIN_INT_MAX-(diveOptions2-1));
     1540            }
    15041541            model->addHeuristic(&heuristicDP) ;
    15051542        }
  • stable/2.8/Cbc/src/CbcSubProblem.cpp

    r1854 r1883  
    2929// Default Constructor
    3030CbcSubProblem::CbcSubProblem()
    31         : objectiveValue_(0.0),
    32         sumInfeasibilities_(0.0),
    33         variables_(NULL),
    34         newBounds_(NULL),
    35         status_(NULL),
    36         depth_(0),
    37         numberChangedBounds_(0),
    38         numberInfeasibilities_(0)
     31  : objectiveValue_(0.0),
     32    sumInfeasibilities_(0.0),
     33    branchValue_(0.0),
     34    djValue_(0.0),
     35    variables_(NULL),
     36    newBounds_(NULL),
     37    status_(NULL),
     38    depth_(0),
     39    numberChangedBounds_(0),
     40    numberInfeasibilities_(0),
     41    problemStatus_(0),
     42    branchVariable_(0)
    3943{
    4044}
     
    4650                              const unsigned char * status,
    4751                              int depth)
    48         : objectiveValue_(0.0),
    49         sumInfeasibilities_(0.0),
    50         variables_(NULL),
    51         newBounds_(NULL),
    52         status_(NULL),
    53         depth_(depth),
    54         numberChangedBounds_(0),
    55         numberInfeasibilities_(0)
     52  : objectiveValue_(0.0),
     53    sumInfeasibilities_(0.0),
     54    branchValue_(0.0),
     55    djValue_(0.0),
     56    variables_(NULL),
     57    newBounds_(NULL),
     58    status_(NULL),
     59    depth_(depth),
     60    numberChangedBounds_(0),
     61    numberInfeasibilities_(0),
     62    problemStatus_(0),
     63    branchVariable_(0)
    5664{
    5765    const double * lower = solver->getColLower();
     
    110118CbcSubProblem::CbcSubProblem ( const CbcSubProblem & rhs)
    111119        : objectiveValue_(rhs.objectiveValue_),
    112         sumInfeasibilities_(rhs.sumInfeasibilities_),
    113         variables_(NULL),
    114         newBounds_(NULL),
    115         status_(NULL),
    116         depth_(rhs.depth_),
    117         numberChangedBounds_(rhs.numberChangedBounds_),
    118         numberInfeasibilities_(rhs.numberInfeasibilities_)
     120          sumInfeasibilities_(rhs.sumInfeasibilities_),
     121          branchValue_(rhs.branchValue_),
     122          djValue_(rhs.djValue_),
     123          variables_(NULL),
     124          newBounds_(NULL),
     125          status_(NULL),
     126          depth_(rhs.depth_),
     127          numberChangedBounds_(rhs.numberChangedBounds_),
     128          numberInfeasibilities_(rhs.numberInfeasibilities_),
     129          problemStatus_(rhs.problemStatus_),
     130          branchVariable_(rhs.branchVariable_)
    119131{
    120132    if (numberChangedBounds_) {
     
    137149        objectiveValue_ = rhs.objectiveValue_;
    138150        sumInfeasibilities_ = rhs.sumInfeasibilities_;
     151        branchValue_ = rhs.branchValue_;
     152        djValue_ = rhs.djValue_;
    139153        depth_ = rhs.depth_;
    140154        numberChangedBounds_ = rhs.numberChangedBounds_;
    141155        numberInfeasibilities_ = rhs.numberInfeasibilities_;
     156        problemStatus_ = rhs.problemStatus_;
     157        branchVariable_ = rhs.branchVariable_;
    142158        if (numberChangedBounds_) {
    143159            variables_ = CoinCopyOfArray(rhs.variables_, numberChangedBounds_);
     
    155171    return *this;
    156172}
     173// Take over
     174void
     175CbcSubProblem::takeOver( CbcSubProblem & rhs, bool cleanUp)
     176{
     177    if (this != &rhs) {
     178        delete [] variables_;
     179        delete [] newBounds_;
     180        delete status_;
     181        objectiveValue_ = rhs.objectiveValue_;
     182        sumInfeasibilities_ = rhs.sumInfeasibilities_;
     183        branchValue_ = rhs.branchValue_;
     184        djValue_ = rhs.djValue_;
     185        depth_ = rhs.depth_;
     186        numberChangedBounds_ = rhs.numberChangedBounds_;
     187        numberInfeasibilities_ = rhs.numberInfeasibilities_;
     188        problemStatus_ = rhs.problemStatus_;
     189        branchVariable_ = rhs.branchVariable_;
     190        variables_ = rhs.variables_;
     191        newBounds_ = rhs.newBounds_;
     192        rhs.variables_ = NULL;
     193        rhs.newBounds_ = NULL;
     194        status_ = rhs.status_;
     195        rhs.status_ = NULL;
     196        if (cleanUp) {
     197          delete [] variables_;
     198          delete [] newBounds_;
     199          variables_ = new int [1];
     200          newBounds_ = new double [1];
     201          // swap way and make only fix
     202          numberChangedBounds_=1;
     203          if ((problemStatus_&1)==0) {
     204            // last way was down
     205            newBounds_[0] = ceil(branchValue_);
     206            variables_[0] = branchVariable_;
     207          } else {
     208            // last way was up
     209            newBounds_[0] = floor(branchValue_);
     210            variables_[0] = branchVariable_ | 0x80000000;
     211          }
     212        }
     213    }
     214}
    157215
    158216// Destructor
     
    169227    int i;
    170228    if ((what&1) != 0) {
     229    printf("CbcSubapply depth %d column %d way %d bvalue %g obj %g\n",
     230                 this->depth_,this->branchVariable_,this->problemStatus_,
     231                 this->branchValue_,this->objectiveValue_);
     232    printf("current bounds %g <= %g <= %g\n",solver->getColLower()[branchVariable_],branchValue_,solver->getColUpper()[branchVariable_]);
    171233#ifndef NDEBUG
    172234        int nSame = 0;
     
    228290#endif
    229291#endif
     292    printf("new bounds %g <= %g <= %g\n",solver->getColLower()[branchVariable_],branchValue_,solver->getColUpper()[branchVariable_]);
    230293    }
    231294#ifdef JJF_ZERO
     
    258321        assert (clpSolver);
    259322        clpSolver->setBasis(*status_);
    260         delete status_;
    261         status_ = NULL;
    262     }
    263 }
    264 
     323        if ((what&16)==0) {
     324          delete status_;
     325          status_ = NULL;
     326        }
     327    }
     328}
     329
  • stable/2.8/Cbc/src/CbcSubProblem.hpp

    r1854 r1883  
    4040    virtual ~CbcSubProblem ();
    4141
     42    /// Take over
     43  void takeOver ( CbcSubProblem &, bool cleanup);
    4244    /// Apply subproblem (1=bounds, 2=basis, 3=both)
    4345    void apply(OsiSolverInterface * model, int what = 3) const;
     
    4850    /// Sum of infeasibilities
    4951    double sumInfeasibilities_;
     52    /// Branch value
     53    double branchValue_;
     54    /// Dj on branching variable at end
     55    double djValue_;
    5056    /** Which variable (top bit if upper bound changing)
    5157        next bit if changing on down branch only */
     
    6167    /// Number of infeasibilities
    6268    int numberInfeasibilities_;
     69    /** Status 1 bit going up on first, 2 bit set first branch infeasible on second, 4 bit redundant branch,
     70        bits after 256 give reason for stopping (just last node)
     71        0 - solution
     72        1 - infeasible
     73        2 - maximum depth
     74        >2 - error or max time or something
     75    */
     76    int problemStatus_;
     77    /// Variable branched on
     78    int branchVariable_;
    6379};
    6480
  • stable/2.8/Cbc/src/CbcThread.cpp

    r1854 r1883  
    10131013        saveObjects_[iObject]->updateBefore(object[iObject]);
    10141014    }
     1015    //#define FAKE_PARALLEL
     1016#ifndef FAKE_PARALLEL
    10151017    for (iThread = 0; iThread < numberThreads_; iThread++) {
    10161018        children_[iThread].setReturnCode( 0);
     
    10311033    for (iThread = 0; iThread < numberThreads_; iThread++)
    10321034        children_[iThread].setReturnCode(-1);