Changeset 854


Ignore:
Timestamp:
Jan 11, 2008 5:05:20 PM (12 years ago)
Author:
forrest
Message:

try and make a bit faster

Location:
trunk/Cbc/src
Files:
11 edited

Legend:

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

    r848 r854  
    899899CbcSimpleInteger::resetSequenceEtc(int numberColumns, const int * originalColumns)
    900900{
     901  assert (numberColumns>0);
    901902  int iColumn;
     903#if 0
    902904  for (iColumn=0;iColumn<numberColumns;iColumn++) {
    903905    if (columnNumber_==originalColumns[iColumn])
     
    905907  }
    906908  assert (iColumn<numberColumns);
     909#else
     910  iColumn=originalColumns[columnNumber_];
     911  assert (iColumn>=0);
     912#endif
    907913  columnNumber_ = iColumn;
    908914}
  • trunk/Cbc/src/CbcHeuristic.cpp

    r838 r854  
    388388        model.setParentModel(*model_);
    389389        model.setOriginalColumns(process.originalColumns());
    390         model.branchAndBound();
     390        if (model.getNumCols()) {
     391          setCutAndHeuristicOptions(model);
     392          model.branchAndBound();
     393        } else {
     394          // empty model
     395          model.setMinimizationObjValue(model.solver()->getObjSense()*model.solver()->getObjValue());
     396        }
    391397        if (logLevel>1)
    392398          model_->messageHandler()->message(CBC_END_SUB,model_->messages())
     
    395401        if (model.getMinimizationObjValue()<CoinMin(cutoff,1.0e30)) {
    396402          // solution
    397           returnCode=model.isProvenOptimal() ? 3 : 1;
     403          if (model.getNumCols())
     404            returnCode=model.isProvenOptimal() ? 3 : 1;
     405          else
     406            returnCode=3;
    398407          // post process
    399408#ifdef COIN_HAS_CLP
     
    13761385
    13771386// Default Constructor
     1387CbcHeuristicPartial::CbcHeuristicPartial()
     1388  :CbcHeuristic()
     1389{
     1390  fixPriority_ = 10000;
     1391}
     1392
     1393// Constructor from model
     1394CbcHeuristicPartial::CbcHeuristicPartial(CbcModel & model, int fixPriority, int numberNodes)
     1395  :CbcHeuristic(model)
     1396{
     1397  fixPriority_ = fixPriority;
     1398  setNumberNodes(numberNodes);
     1399  validate();
     1400}
     1401
     1402// Destructor
     1403CbcHeuristicPartial::~CbcHeuristicPartial ()
     1404{
     1405}
     1406
     1407// Clone
     1408CbcHeuristic *
     1409CbcHeuristicPartial::clone() const
     1410{
     1411  return new CbcHeuristicPartial(*this);
     1412}
     1413// Create C++ lines to get to current state
     1414void
     1415CbcHeuristicPartial::generateCpp( FILE * fp)
     1416{
     1417  CbcHeuristicPartial other;
     1418  fprintf(fp,"0#include \"CbcHeuristic.hpp\"\n");
     1419  fprintf(fp,"3  CbcHeuristicPartial partial(*cbcModel);\n");
     1420  CbcHeuristic::generateCpp(fp,"partial");
     1421  if (fixPriority_!=other.fixPriority_)
     1422    fprintf(fp,"3  partial.setFixPriority(%d);\n",fixPriority_);
     1423  else
     1424    fprintf(fp,"4  partial.setFixPriority(%d);\n",fixPriority_);
     1425  fprintf(fp,"3  cbcModel->addHeuristic(&partial);\n");
     1426}
     1427//#define NEW_PARTIAL
     1428// Copy constructor
     1429CbcHeuristicPartial::CbcHeuristicPartial(const CbcHeuristicPartial & rhs)
     1430:
     1431  CbcHeuristic(rhs),
     1432  fixPriority_(rhs.fixPriority_)
     1433{
     1434}
     1435
     1436// Assignment operator
     1437CbcHeuristicPartial &
     1438CbcHeuristicPartial::operator=( const CbcHeuristicPartial& rhs)
     1439{
     1440  if (this!=&rhs) {
     1441    CbcHeuristic::operator=(rhs);
     1442    fixPriority_ = rhs.fixPriority_;
     1443  }
     1444  return *this;
     1445}
     1446
     1447// Resets stuff if model changes
     1448void
     1449CbcHeuristicPartial::resetModel(CbcModel * model)
     1450{
     1451  model_=model;
     1452  // Get a copy of original matrix (and by row for partial);
     1453  assert(model_->solver());
     1454  validate();
     1455}
     1456// See if partial will give solution
     1457// Sets value of solution
     1458// Assumes rhs for original matrix still okay
     1459// At present only works with integers
     1460// Fix values if asked for
     1461// Returns 1 if solution, 0 if not
     1462int
     1463CbcHeuristicPartial::solution(double & solutionValue,
     1464                      double * betterSolution)
     1465{
     1466  // Return if already done
     1467  if (fixPriority_<0)
     1468    return 0; // switched off
     1469  const double * hotstartSolution = model_->hotstartSolution();
     1470  const int * hotstartPriorities = model_->hotstartPriorities();
     1471  if (!hotstartSolution)
     1472    return 0;
     1473  OsiSolverInterface * solver = model_->solver();
     1474 
     1475  int numberIntegers = model_->numberIntegers();
     1476  const int * integerVariable = model_->integerVariable();
     1477 
     1478  OsiSolverInterface * newSolver = model_->continuousSolver()->clone();
     1479  const double * colLower = newSolver->getColLower();
     1480  const double * colUpper = newSolver->getColUpper();
     1481
     1482  double primalTolerance;
     1483  solver->getDblParam(OsiPrimalTolerance,primalTolerance);
     1484   
     1485  int i;
     1486  int numberFixed=0;
     1487  int returnCode=0;
     1488
     1489  for (i=0;i<numberIntegers;i++) {
     1490    int iColumn=integerVariable[i];
     1491    if (abs(hotstartPriorities[iColumn])<=fixPriority_) {
     1492      double value = hotstartSolution[iColumn];
     1493      double lower = colLower[iColumn];
     1494      double upper = colUpper[iColumn];
     1495      value = CoinMax(value,lower);
     1496      value = CoinMin(value,upper);
     1497      if (fabs(value-floor(value+0.5))<1.0e-8) {
     1498        value = floor(value+0.5);
     1499        newSolver->setColLower(iColumn,value);
     1500        newSolver->setColUpper(iColumn,value);
     1501        numberFixed++;
     1502      }
     1503    }
     1504  }
     1505  if (numberFixed>numberIntegers/5-100000000) {
     1506#ifdef COIN_DEVELOP
     1507    printf("%d integers fixed\n",numberFixed);
     1508#endif
     1509    returnCode = smallBranchAndBound(newSolver,numberNodes_,betterSolution,solutionValue,
     1510                                     model_->getCutoff(),"CbcHeuristicPartial");
     1511    if (returnCode<0)
     1512      returnCode=0; // returned on size
     1513    //printf("return code %d",returnCode);
     1514    if ((returnCode&2)!=0) {
     1515      // could add cut
     1516      returnCode &= ~2;
     1517      //printf("could add cut with %d elements (if all 0-1)\n",nFix);
     1518    } else {
     1519      //printf("\n");
     1520    }
     1521  }
     1522  fixPriority_=-1; // switch off
     1523 
     1524  delete newSolver;
     1525  return returnCode;
     1526}
     1527// update model
     1528void CbcHeuristicPartial::setModel(CbcModel * model)
     1529{
     1530  model_ = model;
     1531  assert(model_->solver());
     1532  // make sure model okay for heuristic
     1533  validate();
     1534}
     1535// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
     1536void
     1537CbcHeuristicPartial::validate()
     1538{
     1539  if (model_&&when()<10) {
     1540    if (model_->numberIntegers()!=
     1541        model_->numberObjects())
     1542      setWhen(0);
     1543  }
     1544}
     1545
     1546// Default Constructor
    13781547CbcSerendipity::CbcSerendipity()
    13791548  :CbcHeuristic()
  • trunk/Cbc/src/CbcHeuristic.hpp

    r841 r854  
    221221};
    222222
     223/** Partial solution class
     224    If user knows a partial solution this tries to get an integer solution
     225    it uses hotstart information
     226 */
     227
     228class CbcHeuristicPartial : public CbcHeuristic {
     229public:
     230
     231  // Default Constructor
     232  CbcHeuristicPartial ();
     233
     234  /** Constructor with model - assumed before cuts
     235      Fixes all variables with priority <= given
     236      and does given number of nodes
     237  */
     238  CbcHeuristicPartial (CbcModel & model, int fixPriority=10000, int numberNodes=200);
     239 
     240  // Copy constructor
     241  CbcHeuristicPartial ( const CbcHeuristicPartial &);
     242   
     243  // Destructor
     244  ~CbcHeuristicPartial ();
     245 
     246  /// Assignment operator
     247  CbcHeuristicPartial & operator=(const CbcHeuristicPartial& rhs);
     248
     249  /// Clone
     250  virtual CbcHeuristic * clone() const;
     251  /// Create C++ lines to get to current state
     252  virtual void generateCpp( FILE * fp) ;
     253
     254  /// Resets stuff if model changes
     255  virtual void resetModel(CbcModel * model);
     256
     257  /// update model (This is needed if cliques update matrix etc)
     258  virtual void setModel(CbcModel * model);
     259 
     260  using CbcHeuristic::solution ;
     261  /** returns 0 if no solution, 1 if valid solution
     262      with better objective value than one passed in
     263      Sets solution values if good, sets objective value (only if good)
     264      This is called after cuts have been added - so can not add cuts
     265  */
     266  virtual int solution(double & objectiveValue,
     267                       double * newSolution);
     268  /// Validate model i.e. sets when_ to 0 if necessary (may be NULL)
     269  virtual void validate();
     270
     271
     272  /// Set priority level
     273  void setFixPriority(int value)
     274  { fixPriority_ = value;}
     275
     276protected:
     277  // Data
     278
     279  // All variables with abs priority <= this will be fixed
     280  int fixPriority_;
     281};
     282
    223283/** heuristic - just picks up any good solution
    224284    found by solver - see OsiBabSolver
  • trunk/Cbc/src/CbcLinked.cpp

    r815 r854  
    44164416    int iColumn = members_[j];
    44174417    int i;
     4418#if 0
    44184419    for (i=0;i<numberColumns;i++) {
    44194420      if (originalColumns[i]==iColumn)
    44204421        break;
    44214422    }
    4422     if (i<numberColumns) {
     4423#else
     4424    i=originalColumns[iColumn];
     4425#endif
     4426    if (i>=0&&i<numberColumns) {
    44234427      members_[n2]=i;
    44244428      weights_[n2++]=weights_[j];
     
    60756079{
    60766080  int i;
     6081#if 0
    60776082  for (i=0;i<numberColumns;i++) {
    60786083    if (originalColumns[i]==firstLambda_)
    60796084      break;
    60806085  }
    6081   if (i<numberColumns) {
     6086#else
     6087    i=originalColumns[firstLambda_];
     6088#endif
     6089  if (i>=0&&i<numberColumns) {
    60826090    firstLambda_ = i;
    60836091    for (int j=0;j<4;j++) {
  • trunk/Cbc/src/CbcModel.cpp

    r842 r854  
    925925  std::string problemName ;
    926926  solver_->getStrParam(OsiProbName,problemName) ;
    927   if (!strcmp(problemName.c_str(),"PP08A")) solver_->activateRowCutDebugger(problemName.c_str()) ;
     927  if (!strcmp(problemName.c_str(),"EGOUT")) solver_->activateRowCutDebugger(problemName.c_str()) ;
    928928#endif
    929929  if (strategy_) {
     
    10021002        */
    10031003        numberIntegers_=0;
     1004        int n=originalColumns[numberColumns-1]+1;
     1005        int * backward = new int[n];
     1006        int i;
     1007        for ( i=0;i<n;i++)
     1008          backward[i]=-1;
     1009        for (i=0;i<numberColumns;i++)
     1010          backward[originalColumns[i]]=i;
    10041011        for (iColumn=0;iColumn<numberColumns;iColumn++) {
    10051012          int jColumn = originalColumns[iColumn];
     
    10111018              object_[numberIntegers_] = originalObject[iObject]->clone();
    10121019              // redo ids etc
    1013               object_[numberIntegers_]->resetSequenceEtc(numberColumns,originalColumns);
     1020              //object_[numberIntegers_]->resetSequenceEtc(numberColumns,originalColumns);
     1021              object_[numberIntegers_]->resetSequenceEtc(numberColumns,backward);
    10141022              integerVariable_[numberIntegers_++]=iColumn;
    10151023            }
     
    10201028          }
    10211029        }
     1030        delete [] backward;
    10221031        numberObjects_=numberIntegers_;
    10231032        // Now append other column stuff
     
    11431152*/
    11441153  findIntegers(false) ;
     1154  // Say not dynamic pseudo costs
     1155  ownership_ &= ~0x40000000;
    11451156  // If dynamic pseudo costs then do
    11461157  if (numberBeforeTrust_)
     
    13691380     ClpSimplex * simplex = clpSolver->getModelPtr();
    13701381     simplex->setPersistenceFlag(1);
     1382#if 0
    13711383     clpSolver->deleteScaleFactors();
    13721384     int value=131072;
     
    13741386     if ((clpSolver->specialOptions()&value)!=0)
    13751387       simplex->setSpecialOptions(simplex->specialOptions()|value);
     1388#else
     1389#undef CLP_QUICK_OPTIONS
    13761390     //if (simplex->numberRows()<50)
    13771391     //simplex->setAlphaAccuracy(1.0);
    1378      //clpSolver->setSpecialOptions((clpSolver->specialOptions()&~128)|65536);
     1392     clpSolver->setSpecialOptions((clpSolver->specialOptions()&~128)|65536);
     1393     //simplex->setMoreSpecialOptions(simplex->moreSpecialOptions()|4);
     1394     //simplex->setSpecialOptions(simplex->specialOptions()|65536);
     1395     //simplex->startPermanentArrays();
     1396#endif
    13791397#endif
    13801398     if ((specialOptions_&32)==0) {
     
    13841402     }
    13851403     // no crunch if mostly continuous
     1404     //int numberColumns = solver_->getNumCols()+1000000; // fake for testing
    13861405     int numberColumns = solver_->getNumCols();
    13871406     if (numberColumns>1000&&numberIntegers_*4<numberColumns)
     
    13971416
    13981417  numberRowsAtContinuous_ = getNumRows() ;
     1418  solver_->saveBaseModel();
    13991419/*
    14001420  Check the objective to see if we can deduce a nontrivial increment. If
     
    14181438  addedCuts_ = NULL ;
    14191439  OsiObject ** saveObjects=NULL;
     1440  maximumRows_ = numberRowsAtContinuous_;
     1441  workingBasis_.resize(maximumRows_,numberColumns);
    14201442/*
    14211443  Set up an empty heap and associated data structures to hold the live set
     
    21172139    if (numberNodes_>=lastPrintEvery) {
    21182140      lastPrintEvery = numberNodes_ + printFrequency_;
     2141#ifdef CBC_INSTRUMENT
     2142      if (0) {
     2143        printf("==Start instrument\n");
     2144        for (int iObject=0;iObject<numberObjects_;iObject++) {
     2145          CbcSimpleIntegerDynamicPseudoCost * obj =
     2146            dynamic_cast <CbcSimpleIntegerDynamicPseudoCost *>(object_[iObject]) ;
     2147          if (obj)
     2148            obj->print();
     2149        }
     2150        printf("==End instrument\n");
     2151      }
     2152#endif
    21192153#ifndef CBC_DETERMINISTIC_THREAD
    21202154      lockThread();
     
    25922626        assert (createdNode);
    25932627        if (!createdNode->active()) {
     2628          //if (createdNode->nodeInfo()) {
     2629          //createdNode->nodeInfo()->throwAway();
     2630          //}
    25942631          delete createdNode;
    25952632          createdNode=NULL;
     
    34693506  currentPassNumber_(0),
    34703507  maximumWhich_(1000),
     3508  maximumRows_(0),
    34713509  whichGenerator_(NULL),
    34723510  maximumStatistics_(0),
     
    36083646  currentPassNumber_(0),
    36093647  maximumWhich_(1000),
     3648  maximumRows_(0),
    36103649  whichGenerator_(NULL),
    36113650  maximumStatistics_(0),
     
    38323871  currentPassNumber_(rhs.currentPassNumber_),
    38333872  maximumWhich_(rhs.maximumWhich_),
     3873  maximumRows_(0),
    38343874  whichGenerator_(NULL),
    38353875  maximumStatistics_(0),
     
    41584198    if (maximumWhich_&&rhs.whichGenerator_)
    41594199      whichGenerator_ = CoinCopyOfArray(rhs.whichGenerator_,maximumWhich_);
     4200    maximumRows_=0;
     4201    workingBasis_ = CoinWarmStartBasis();
    41604202    for (i=0;i<maximumStatistics_;i++)
    41614203      delete statistics_[i];
     
    47234765  the reference isn't clear to me).
    47244766*/
     4767  solver_->restoreBaseModel(numberRowsAtContinuous_);
     4768#if 0
    47254769  int currentNumberCuts = solver_->getNumRows()-numberRowsAtContinuous_;
    47264770  int *which = new int[currentNumberCuts];
     
    47294773  solver_->deleteRows(currentNumberCuts,which);
    47304774  delete [] which;
     4775#endif
    47314776/*
    47324777  Accumulate the path from node to the root in walkback_, and accumulate a
     
    47364781  old node (for cuts?)
    47374782*/
    4738   currentNumberCuts = 0;
     4783  int currentNumberCuts = 0;
    47394784  while (nodeInfo) {
    47404785    //printf("nNode = %d, nodeInfo = %x\n",nNode,nodeInfo);
     
    48384883  int i;
    48394884  int numberColumns = getNumCols();
     4885  if (solver_->getNumRows()>maximumRows_) {
     4886    maximumRows_ = solver_->getNumRows();
     4887    workingBasis_.resize(maximumRows_,numberColumns);
     4888  }
    48404889  CbcNodeInfo * nodeInfo = node->nodeInfo();
    48414890  double cutoff = getCutoff() ;
     
    49334982                 numberRowsAtContinuous_+numberToAdd);
    49344983#         endif
    4935           addCuts[numberToAdd++] = new OsiRowCut(*addedCuts_[i]);
     4984          addCuts[numberToAdd++] = addedCuts_[i];
    49364985        } else {
    49374986#         ifdef CHECK_CUT_COUNTS
     
    49515000      lastws->print();
    49525001#     endif
    4953       for (i=0;i<numberToAdd;i++)
    4954         delete addCuts[i];
     5002      //for (i=0;i<numberToAdd;i++)
     5003      //delete addCuts[i];
    49555004      delete [] addCuts;
    49565005      delete [] cutsToDrop ;
     
    65606609          <<i
    65616610          <<generator_[i]->cutGeneratorName()
    6562           <<countRowCuts[i]<<count[i]
     6611          //<<countRowCuts[i]<<count[i]
     6612          << generator_[i]->numberCutsInTotal()<<generator_[i]->numberCutsActive()
    65636613          <<countColumnCuts[i];
    65646614        handler_->printing(!numberNodes_&&generator_[i]->timing())
     
    77237773    }
    77247774  }
     7775  if (allDynamic)
     7776    ownership_ |= 0x40000000;
    77257777  if (!branchingMethod_&&allDynamic) {
    77267778    // create one
     
    83368388                  {
    83378389                    const OsiRowCut * thisCut = theseCuts.rowCutPtr(j);
    8338                     if (thisCut->globallyValid())
    8339                       {
    8340                         //           if ((specialOptions_&1)!=0)
    8341                         //           {
    8342                         //             /* As these are global cuts -
    8343                         //             a) Always get debugger object
    8344                         // b) Not fatal error to cutoff optimal (if we have just got optimal)
    8345                         // */
    8346                         //             const OsiRowCutDebugger *debugger = solver_->getRowCutDebuggerAlways() ;
    8347                         //             if (debugger)
    8348                         //             {
    8349                         //               if(debugger->invalidCut(*thisCut))
    8350                         //                 printf("ZZZZ Global cut - cuts off optimal solution!\n");
    8351                         //             }
    8352                         //           }
    8353                         // add to global list
    8354                         OsiRowCut newCut(*thisCut);
    8355                         newCut.setGloballyValid(true);
    8356                         newCut.mutableRow().setTestForDuplicateIndex(false);
    8357                         globalCuts_.insert(newCut) ;
    8358                         generator_[i]->incrementNumberCutsInTotal();
    8359                       }
     8390                    if (thisCut->globallyValid()) {
     8391                      //           if ((specialOptions_&1)!=0)
     8392                      //           {
     8393                      //             /* As these are global cuts -
     8394                      //             a) Always get debugger object
     8395                      // b) Not fatal error to cutoff optimal (if we have just got optimal)
     8396                      // */
     8397                      //             const OsiRowCutDebugger *debugger = solver_->getRowCutDebuggerAlways() ;
     8398                      //             if (debugger)
     8399                      //             {
     8400                      //               if(debugger->invalidCut(*thisCut))
     8401                      //                 printf("ZZZZ Global cut - cuts off optimal solution!\n");
     8402                      //             }
     8403                      //           }
     8404                      // add to global list
     8405                      OsiRowCut newCut(*thisCut);
     8406                      newCut.setGloballyValid(true);
     8407                      newCut.mutableRow().setTestForDuplicateIndex(false);
     8408                      globalCuts_.insert(newCut) ;
     8409                      generator_[i]->incrementNumberCutsInTotal();
     8410                    } else {
     8411                      // obviously wrong
     8412                      if (handler_->logLevel()>0)
     8413                        printf("Cut generator %s set to run on new solution but NOT globally valid!!\n",
     8414                               generator_[i]->cutGeneratorName());
     8415                    }
    83608416                  }
    83618417              }
     
    1025910315    int numberColumns = solver_->getNumCols();
    1026010316    hotstartSolution_ = CoinCopyOfArray(solution,numberColumns);
     10317    hotstartPriorities_ = CoinCopyOfArray(priorities,numberColumns);
    1026110318    for (int i=0;i<numberColumns;i++) {
     10319      if (hotstartSolution_[i]==-COIN_DBL_MAX) {
     10320        hotstartSolution_[i]=0.0;
     10321        hotstartPriorities_[i]+= 10000;
     10322      }
    1026210323      if (solver_->isInteger(i))
    1026310324        hotstartSolution_[i]=floor(hotstartSolution_[i]+0.5);
    1026410325    }
    10265     hotstartPriorities_ = CoinCopyOfArray(priorities,numberColumns);
    1026610326  }
    1026710327}
     
    1033910399  bool feasible=true;
    1034010400  int branchingState=-1;
     10401#if 0
     10402  // Say not on optimal path
     10403  bool onOptimalPath=false;
     10404  if ((specialOptions_&1)!=0) {
     10405    /*
     10406      This doesn't work as intended --- getRowCutDebugger will return null
     10407      unless the current feasible solution region includes the optimal solution
     10408      that RowCutDebugger knows. There's no way to tell inactive from off the
     10409      optimal path.
     10410    */
     10411    const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     10412    if (debugger) {
     10413      onOptimalPath=true;
     10414      printf("On optimal path - choose\n") ;
     10415    }
     10416  }
     10417#endif
    1034110418  currentNode_=newNode; // so can be used elsewhere
    1034210419  while (anyAction == -1) {
     
    1039510472      if (onOptimalPath)
    1039610473      assert (anyAction!=-2); // can be useful but gives false positives on strong
    10397     */
     10474      */
    1039810475    numberPassesLeft--;
    1039910476    if (numberPassesLeft<=-1) {
     
    1048510562  }
    1048610563  stateOfSearch_ =0; // outside chooseBranch
     10564#if 0
     10565  if (onOptimalPath) {
     10566    const OsiRowCutDebugger *debugger = solver_->getRowCutDebugger() ;
     10567    if (!debugger) {
     10568      printf("NOT On optimal path - choose\n") ;
     10569      abort();
     10570    } else {
     10571      printf("Still On optimal path - choose\n") ;
     10572      if (anyAction==-2) {
     10573        printf("anyAction 2!!\n");
     10574        abort();
     10575      }
     10576    }
     10577  }
     10578#endif
    1048710579  return anyAction;
    1048810580}
     
    1063410726    */
    1063510727    numberIntegers_=0;
     10728    int n=originalColumns[numberColumns-1]+1;
     10729    int * backward = new int[n];
     10730    int i;
     10731    for ( i=0;i<n;i++)
     10732      backward[i]=-1;
     10733    for (i=0;i<numberColumns;i++)
     10734      backward[originalColumns[i]]=i;
    1063610735    for (iColumn=0;iColumn<numberColumns;iColumn++) {
    1063710736      int jColumn = originalColumns[iColumn];
     
    1064310742          object_[numberIntegers_] = originalObject[iObject]->clone();
    1064410743          // redo ids etc
    10645           object_[numberIntegers_]->resetSequenceEtc(numberColumns,originalColumns);
     10744          //object_[numberIntegers_]->resetSequenceEtc(numberColumns,originalColumns);
     10745          object_[numberIntegers_]->resetSequenceEtc(numberColumns,backward);
    1064610746          integerVariable_[numberIntegers_++]=iColumn;
    1064710747        }
     
    1065210752      }
    1065310753    }
     10754    delete [] backward;
    1065410755    numberObjects_=numberIntegers_;
    1065510756    // Now append other column stuff
     
    1172311824#else
    1172411825          newNode->setActive(false);
    11725           printf("at 11370\n");
    1172611826#endif
    1172711827        }
     
    1185111951CbcModel::addUpdateInformation(const CbcObjectUpdateData & data)
    1185211952{
     11953#if 0
    1185311954  CbcObject * object = dynamic_cast<CbcObject *> (data.object_);
    11854 #if 0
    1185511955  bool found=false;
    1185611956  for (int j=0;j<numberObjects_;j++) {
     
    1266212762  int nNode=0;
    1266312763  CbcNodeInfo * nodeInfo = node->nodeInfo();
    12664   int nWhere=-1;
     12764  int nWhere=-1; 
    1266512765
    1266612766/*
  • trunk/Cbc/src/CbcModel.hpp

    r838 r854  
    11481148  inline void setResolveAfterTakeOffCuts(bool yesNo)
    11491149  { resolveAfterTakeOffCuts_=yesNo;}
     1150  /// Maximum number of rows
     1151  inline int maximumRows() const
     1152  { return maximumRows_;}
     1153  /// Work basis for temporary use
     1154  inline CoinWarmStartBasis & workingBasis()
     1155  { return workingBasis_;}
    11501156  /// Get number of threads
    11511157  inline int getNumberThreads() const
     
    17041710  void incrementStrongInfo(int numberTimes, int numberIterations,
    17051711                           int numberFixed, bool ifInfeasible);
     1712  /// Says whether all dynamic integers
     1713  inline bool allDynamic () { return ((ownership_&0x40000000)!=0) ; }
    17061714  /// Create C++ lines to get to current state
    17071715  void generateCpp( FILE * fp,int options);
     
    17271735  OsiSolverInterface * solver_;
    17281736
    1729   /** Ownership of objects
     1737  /** Ownership of objects and other stuff
    17301738
    17311739      0x80000000 model owns solver
     1740      0x40000000 all variables CbcDynamicPseudoCost
    17321741  */
    17331742  unsigned int ownership_ ;
     
    20412050  /// Maximum number of cuts (for whichGenerator_)
    20422051  int maximumWhich_;
     2052  /// Maximum number of rows
     2053  int maximumRows_;
     2054  /// Work basis for temporary use
     2055  CoinWarmStartBasis workingBasis_;
    20432056  /// Which cut generator generated this cut
    20442057  int * whichGenerator_;
     
    21352148int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    21362149int CbcMain1 (int argc, const char *argv[],CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
     2150// For uniform setting of cut and heuristic options
     2151void setCutAndHeuristicOptions(CbcModel & model);
    21372152#endif
  • trunk/Cbc/src/CbcNode.cpp

    r838 r854  
    204204}
    205205void
    206 CbcNodeInfo::decrementParentCuts(int change)
     206CbcNodeInfo::decrementParentCuts(CbcModel * model,int change)
    207207{
    208208  if (parent_) {
     
    215215    int i;
    216216    // Get over-estimate of space needed for basis
    217     CoinWarmStartBasis dummy;
     217    CoinWarmStartBasis & dummy = model->workingBasis();
    218218    dummy.setSize(0,numberRows_+numberCuts_);
    219219    buildRowBasis(dummy);
     
    256256  }
    257257}
    258 
     258#if 0
    259259void
    260 CbcNodeInfo::incrementParentCuts(int change)
     260CbcNodeInfo::incrementParentCuts(CbcModel * model, int change)
    261261{
    262262  if (parent_) {
    263263    int i;
    264264    // Get over-estimate of space needed for basis
    265     CoinWarmStartBasis dummy;
     265    CoinWarmStartBasis & dummy = model->workingBasis();
    266266    dummy.setSize(0,numberRows_+numberCuts_);
    267267    /* everything is zero (i.e. free) so we can use to see
     
    288288  }
    289289}
    290 
     290#endif
    291291/*
    292292  Append cuts to the cuts_ array in a nodeInfo. The initial reference count
     
    929929  basis.
    930930*/
     931    bool mustDeleteBasis;
    931932    const CoinWarmStartBasis *ws =
    932       dynamic_cast<const CoinWarmStartBasis*>(solver->getWarmStart());
     933      dynamic_cast<const CoinWarmStartBasis*>(solver->getPointerToWarmStart(mustDeleteBasis));
    933934    assert(ws!=NULL); // make sure not volume
    934935    //int numberArtificials = lastws->getNumArtificial();
     
    10911092    delete [] variables;
    10921093    delete expanded ;
    1093     delete ws;
     1094    if  (mustDeleteBasis)
     1095      delete ws;
    10941096  }
    10951097  // Set node number
     
    11311133*/
    11321134  else
    1133   { const CoinWarmStartBasis* ws =
    1134       dynamic_cast<const CoinWarmStartBasis*>(solver->getWarmStart());
     1135  {
     1136    bool mustDeleteBasis;
     1137    const CoinWarmStartBasis* ws =
     1138      dynamic_cast<const CoinWarmStartBasis*>(solver->getPointerToWarmStart(mustDeleteBasis));
    11351139    assert(ws!=NULL); // make sure not volume
    11361140    //int numberArtificials = lastws->getNumArtificial();
     
    12711275    delete [] variables;
    12721276    delete expanded ;
    1273     delete ws;
     1277    if  (mustDeleteBasis)
     1278      delete ws;
    12741279  }
    12751280  // Set node number
     
    13431348  int numberObjects = model->numberObjects();
    13441349  bool checkFeasibility = numberObjects>model->numberIntegers();
    1345   int maximumStrong = CoinMax(CoinMin(model->numberStrong(),numberObjects),1);
     1350  int maximumStrong = CoinMax(CoinMin(numberStrong,numberObjects),1);
    13461351  int numberColumns = model->getNumCols();
    13471352  double * saveUpper = new double[numberColumns];
     
    23212326  else
    23222327    depth_ = 0;
     2328  // Go to other choose if hot start
     2329  if (model->hotstartSolution())
     2330    return -3;
    23232331  delete branch_;
    23242332  branch_=NULL;
     
    25422550  int numberStrongInfeasible=0;
    25432551  int numberStrongIterations=0;
     2552  // so we can save lots of news
     2553  CbcStrongInfo choice;
     2554  CbcDynamicPseudoCostBranchingObject * choiceObject = NULL;
     2555  if (model->allDynamic()) {
     2556    CbcSimpleIntegerDynamicPseudoCost * object = NULL;
     2557    choiceObject=new CbcDynamicPseudoCostBranchingObject(model,0,-1,0.5,object);
     2558  }
     2559  choice.possibleBranch=choiceObject;
    25442560  while(!finished) {
    25452561    finished=true;
     
    32143230      //skipAll=false;
    32153231      for ( iDo=0;iDo<numberToDo;iDo++) {
    3216         CbcStrongInfo choice;
    32173232        int iObject = whichObject[iDo];
    32183233        OsiObject * object = model->modifiableObject(iObject);
     
    32283243          dynamic_cast <CbcSimpleInteger *>(object) ;
    32293244        if (obj) {
    3230           choice.possibleBranch=obj->createBranch(solver,&usefulInfo,preferredWay);
     3245          if (choiceObject) {
     3246            obj->fillCreateBranch(choiceObject,&usefulInfo,preferredWay);
     3247            choiceObject->setObject(dynamicObject);
     3248          } else {
     3249            choice.possibleBranch=obj->createBranch(solver,&usefulInfo,preferredWay);
     3250          }
    32313251        } else {
    32323252          CbcObject * obj =
     
    32723292          canSkip=1; // always skip
    32733293          if (iDo>20) {
    3274             delete choice.possibleBranch;
    3275             choice.possibleBranch=NULL;
     3294            if (!choiceObject) {
     3295              delete choice.possibleBranch;
     3296              choice.possibleBranch=NULL;
     3297            }
    32763298            break; // give up anyway
    32773299          }
     
    32813303          //canSkip=1; // always skip
    32823304          if (iDo>20) {
    3283             delete choice.possibleBranch;
    3284             choice.possibleBranch=NULL;
     3305            if (!choiceObject) {
     3306              delete choice.possibleBranch;
     3307              choice.possibleBranch=NULL;
     3308            }
    32853309            break; // give up anyway
    32863310          }
     
    36693693            }
    36703694            if (betterWay) {
    3671               delete branch_;
    36723695              // C) create branching object
    3673               branch_ = choice.possibleBranch;
    3674               choice.possibleBranch=NULL;
     3696              if (choiceObject) {
     3697                delete branch_;
     3698                branch_ = choice.possibleBranch->clone();
     3699              } else {
     3700                delete branch_;
     3701                branch_ = choice.possibleBranch;
     3702                choice.possibleBranch=NULL;
     3703              }
    36753704              {
    36763705                CbcBranchingObject * branchObj =
     
    36903719              }
    36913720            } else {
    3692               delete choice.possibleBranch;
    3693               choice.possibleBranch=NULL;
     3721              if (!choiceObject) {
     3722                delete choice.possibleBranch;
     3723                choice.possibleBranch=NULL;
     3724              }
    36943725              if (iDo>=2*numberStrong) {
    36953726                delete ws;
     
    36993730              if (!dynamicObject||dynamicObject->numberTimesUp()>1) {
    37003731                if (iDo-whichChoice>=numberStrong) {
    3701                   delete choice.possibleBranch;
    3702                   choice.possibleBranch=NULL;
     3732                  if (!choiceObject) {
     3733                    delete choice.possibleBranch;
     3734                    choice.possibleBranch=NULL;
     3735                  }
    37033736                  break; // give up
    37043737                }
     
    37073740                  delete ws;
    37083741                  ws=NULL;
    3709                   delete choice.possibleBranch;
    3710                   choice.possibleBranch=NULL;
     3742                  if (!choiceObject) {
     3743                    delete choice.possibleBranch;
     3744                    choice.possibleBranch=NULL;
     3745                  }
    37113746                  break; // give up
    37123747                }
     
    37283763              choice.possibleBranch->way(1);
    37293764              choice.possibleBranch->branch();
    3730               delete choice.possibleBranch;
    3731               choice.possibleBranch=NULL;
     3765              if (!choiceObject) {
     3766                delete choice.possibleBranch;
     3767                choice.possibleBranch=NULL;
     3768              }
    37323769              delete ws;
    37333770              ws=NULL;
     
    37363773              choice.fix=1;
    37373774              fixObject[numberToFix++]=choice;
    3738               choice.possibleBranch=NULL;
     3775              if (!choiceObject) {
     3776                choice.possibleBranch=NULL;
     3777              } else {
     3778                choiceObject = new CbcDynamicPseudoCostBranchingObject(*choiceObject);
     3779                choice.possibleBranch=choiceObject;
     3780              }
    37393781#define FIXNOW
    37403782#ifdef FIXNOW
     
    37503792                // neither side feasible
    37513793                anyAction=-2;
    3752                 delete choice.possibleBranch;
    3753                 choice.possibleBranch=NULL;
     3794                if (!choiceObject) {
     3795                  delete choice.possibleBranch;
     3796                  choice.possibleBranch=NULL;
     3797                }
    37543798                //printf("Both infeasible for choice %d sequence %d\n",i,
    37553799                // model->object(choice.objectNumber)->columnNumber());
     
    37773821              choice.possibleBranch->way(-1);
    37783822              choice.possibleBranch->branch();
    3779               delete choice.possibleBranch;
    3780               choice.possibleBranch=NULL;
     3823              if (!choiceObject) {
     3824                delete choice.possibleBranch;
     3825                choice.possibleBranch=NULL;
     3826              }
    37813827              delete ws;
    37823828              ws=NULL;
     
    37853831              choice.fix=-1;
    37863832              fixObject[numberToFix++]=choice;
    3787               choice.possibleBranch=NULL;
     3833              if (!choiceObject) {
     3834                choice.possibleBranch=NULL;
     3835              } else {
     3836                choiceObject = new CbcDynamicPseudoCostBranchingObject(*choiceObject);
     3837                choice.possibleBranch=choiceObject;
     3838              }
    37883839#ifdef FIXNOW
    37893840              double value = floor(saveSolution[iColumn]);
     
    37983849                // neither side feasible
    37993850                anyAction=-2;
    3800                 delete choice.possibleBranch;
    3801                 choice.possibleBranch=NULL;
     3851                if (!choiceObject) {
     3852                  delete choice.possibleBranch;
     3853                  choice.possibleBranch=NULL;
     3854                }
    38023855                //printf("Both infeasible for choice %d sequence %d\n",i,
    38033856                // model->object(choice.objectNumber)->columnNumber());
     
    38113864            // neither side feasible
    38123865            anyAction=-2;
    3813             delete choice.possibleBranch;
    3814             choice.possibleBranch=NULL;
     3866            if (!choiceObject) {
     3867              delete choice.possibleBranch;
     3868              choice.possibleBranch=NULL;
     3869            }
    38153870            //printf("Both infeasible for choice %d sequence %d\n",i,
    38163871            // model->object(choice.objectNumber)->columnNumber());
     
    38363891          distanceToCutoff=-COIN_DBL_MAX;
    38373892        }
    3838         delete choice.possibleBranch;
     3893        if (!choiceObject) {
     3894          delete choice.possibleBranch;
     3895        }
    38393896      }
    38403897      double averageChange = model->sumChangeObjective()/((double) model->getNodeCount());
     
    40034060  if (!model->branchingMethod())
    40044061    delete decision;
    4005    
     4062
     4063  delete choiceObject;
    40064064  delete [] fixObject;
    40074065  delete [] sort;
     
    44844542  }
    44854543#endif
    4486   if (nodeInfo_&&(state_&2)!=0) {
     4544  if (nodeInfo_) {
     4545    // was if (nodeInfo_&&(state_&2)!=0) {
    44874546    nodeInfo_->nullOwner();
    44884547    int numberToDelete=nodeInfo_->numberBranchesLeft();
    44894548    //    CbcNodeInfo * parent = nodeInfo_->parent();
    44904549    //assert (nodeInfo_->numberPointingToThis()>0);
    4491     if (nodeInfo_->decrement(numberToDelete)==0) {
     4550    if (nodeInfo_->decrement(numberToDelete)==0||(state_&2)==0) {
     4551      if ((state_&2)==0)
     4552        nodeInfo_->nullParent();
    44924553      delete nodeInfo_;
    44934554    } else {
     
    45134574}
    45144575void
    4515 CbcNode::decrementParentCuts(int change)
     4576CbcNode::decrementParentCuts(CbcModel * model, int change)
    45164577{
    45174578  if (nodeInfo_)
     
    45204581    assert ((state_&2)==0);
    45214582  if(nodeInfo_) {
    4522     nodeInfo_->decrementParentCuts(change);
     4583    nodeInfo_->decrementParentCuts(model, change);
    45234584  }
    45244585}
  • trunk/Cbc/src/CbcNode.hpp

    r838 r854  
    184184
    185185  /// Decrement all active cut counts in chain starting at parent
    186   void decrementParentCuts(int change=1);
     186  void decrementParentCuts(CbcModel * model, int change=1);
    187187
    188188  /// Increment all active cut counts in parent chain
    189   void incrementParentCuts(int change=1);
     189  void incrementParentCuts(CbcModel * model, int change=1);
    190190
    191191  /// Array of pointers to cuts
     
    572572
    573573  /// Decrement all active cut counts in chain starting at parent
    574   void decrementParentCuts(int change=1);
     574  void decrementParentCuts(CbcModel * model, int change=1);
    575575
    576576  /// Nulls out node info
  • trunk/Cbc/src/CbcSolver.cpp

    r840 r854  
    143143#include "OsiClpSolverInterface.hpp"
    144144#include "CbcSolver.hpp"
     145#define IN_BRANCH_AND_BOUND (0x01000000|262144)
    145146CbcSolver::CbcSolver()
    146147  : babModel_(NULL),
     
    39093910    int useCosts=0;
    39103911    // don't use input solution
    3911     int useSolution=0;
     3912    int useSolution=-1;
    39123913   
    39133914    // total number of commands read
     
    42444245              else if (parameters_[iParam].type()==PROCESSTUNE)
    42454246                tunePreProcess = value;
     4247              else if (parameters_[iParam].type()==USESOLUTION)
     4248                useSolution = value;
    42464249              else if (parameters_[iParam].type()==VERBOSE)
    42474250                verbose = value;
     
    45044507              preProcess = action;
    45054508              break;
    4506             case USESOLUTION:
    4507               useSolution = action;
    45084509              break;
    45094510            default:
     
    52935294                      cbcModel->setThreadMode(numberThreads/100);
    52945295#endif
     5296                      //setCutAndHeuristicOptions(*cbcModel);
    52955297                      cbcModel->branchAndBound();
    52965298                      OsiSolverLinearizedQuadratic * solver3 = dynamic_cast<OsiSolverLinearizedQuadratic *> (model2.solver());
     
    53895391                  return returnCode;
    53905392                }
    5391                 clpSolver->setSpecialOptions(clpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound)
     5393                clpSolver->setSpecialOptions(clpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
    53925394                if (!noPrinting_) {
    53935395                  sprintf(generalPrint,"Continuous objective value is %g - %.2f seconds",
     
    61666168#endif               
    61676169                const int * originalColumns = preProcess ? process.originalColumns() : NULL;
    6168                 if (solutionIn&&useSolution) {
     6170                if (solutionIn&&useSolution>=0) {
    61696171                  if (preProcess) {
    61706172                    int numberColumns = babModel_->getNumCols();
     
    70757077                }
    70767078#endif
     7079                if (useSolution>0) {
     7080                  // use hotstart to try and find solution
     7081                  CbcHeuristicPartial partial(*babModel_,10000,useSolution);
     7082                  partial.setHeuristicName("Partial solution given");
     7083                  babModel_->addHeuristic(&partial);
     7084                }
    70777085                if (logLevel<=1)
    70787086                  babModel_->solver()->setHintParam(OsiDoReducePrint,true,OsiHintTry);
     
    71967204                  OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (babModel_->solver());
    71977205                  ClpSimplex * lpSolver = clpSolver->getModelPtr();
    7198                   lpSolver->setSpecialOptions(lpSolver->specialOptions()|0x01000000); // say is Cbc (and in branch and bound)
     7206                  lpSolver->setSpecialOptions(lpSolver->specialOptions()|IN_BRANCH_AND_BOUND); // say is Cbc (and in branch and bound)
    71997207                  process.postProcess(*babModel_->solver());
    72007208                  // Solution now back in saveSolver
     
    79877995                  if (got[0]>=0&&!lpSolver->lengthNames())
    79887996                    good=false;
     7997                  int numberFields=99;
     7998                  if (good&&(strstr(fileName.c_str(),".mst")||strstr(fileName.c_str(),".MST"))) {
     7999                    numberFields=0;
     8000                    for (i=2;i<(int) (sizeof(got)/sizeof(int));i++) {
     8001                      if (got[i]>=0)
     8002                        numberFields++;
     8003                    }
     8004                    if (!numberFields) {
     8005                      // Like Cplex format
     8006                      order[nAcross]=6;
     8007                      got[6]=nAcross++;
     8008                    }
     8009                  }
    79898010                  if (good) {
    79908011                    char ** columnNames = new char * [numberColumns];
     
    80008021                    if (got[6]>=0) {
    80018022                      solutionIn = (double *) malloc(numberColumns*sizeof(double));
    8002                       CoinZeroN(solutionIn,numberColumns);
     8023                      for (iColumn=0;iColumn<numberColumns;iColumn++)
     8024                        solutionIn[iColumn]=-COIN_DBL_MAX;
    80038025                    }
    8004                     if (got[7]>=0) {
     8026                    if (got[7]>=0||!numberFields) {
    80058027                      prioritiesIn = (int *) malloc(numberColumns*sizeof(int));
    80068028                      for (iColumn=0;iColumn<numberColumns;iColumn++)
     
    80228044                    int nLine=0;
    80238045                    while (fgets(line,1000,fp)) {
     8046                      if (!strncmp(line,"ENDATA",6))
     8047                        break;
    80248048                      nLine++;
    80258049                      iColumn = -1;
     
    80328056                      char * pos = line;
    80338057                      char * put = line;
     8058                      if (!numberFields) {
     8059                        // put in ,
     8060                        for (i=4;i<100;i++) {
     8061                          if (line[i]==' '||line[i]=='\t') {
     8062                            line[i]=',';
     8063                            break;
     8064                          }
     8065                        }
     8066                      }
    80348067                      while (*pos>=' '&&*pos!='\n') {
    80358068                        if (*pos!=' '&&*pos!='\t') {
  • trunk/Cbc/src/CbcStrategy.cpp

    r838 r854  
    146146  // Only look at rows with fewer than this number of elements
    147147  generator1.setMaxElements(200);
     148  generator1.setMaxElementsRoot(300);
    148149  //generator1.setRowCuts(3);
    149150
     
    375376    generator1.setMaxProbeRoot(CoinMin(3000,solver->getNumCols()));
    376377    generator1.setMaxElements(100);
     378    generator1.setMaxElementsRoot(200);
    377379    generator1.setMaxLookRoot(50);
    378380    generator1.setRowCuts(3);
     
    468470            int * fake = new int[n];
    469471            int i;
     472            // This was wrong (now is correct) - so could never have been called
     473            abort();
    470474            for ( i=0;i<n;i++)
    471475              fake[i]=-1;
     
    799803  model.setNumberBeforeTrust(numberBeforeTrust_);
    800804}
     805// For uniform setting of cut and heuristic options
     806void
     807setCutAndHeuristicOptions(CbcModel & model)
     808{
     809  int numberGenerators = model.numberCutGenerators();
     810  int iGenerator;
     811  for (iGenerator=0;iGenerator<numberGenerators;iGenerator++) {
     812    CglCutGenerator * generator = model.cutGenerator(iGenerator)->generator();
     813    CglProbing * cglProbing = dynamic_cast<CglProbing *>(generator);
     814    if (cglProbing) {
     815      cglProbing->setUsingObjective(1);
     816      cglProbing->setMaxPass(1);
     817      cglProbing->setMaxPassRoot(1);
     818      // Number of unsatisfied variables to look at
     819      cglProbing->setMaxProbe(10);
     820      cglProbing->setMaxProbeRoot(50);
     821      // How far to follow the consequences
     822      cglProbing->setMaxLook(10);
     823      cglProbing->setMaxLookRoot(50);
     824      cglProbing->setMaxLookRoot(10);
     825      // Only look at rows with fewer than this number of elements
     826      cglProbing->setMaxElements(200);
     827      cglProbing->setMaxElementsRoot(300);
     828      cglProbing->setRowCuts(3);
     829    }
     830#if 0
     831    CglGomory * cglGomory = dynamic_cast<CglGomory *>(generator);
     832    if (cglGomory) {
     833      // try larger limit
     834      cglGomory->setLimitAtRoot(1000);
     835      cglGomory->setLimit(50);
     836    }
     837    CglKnapsackCover * cglKnapsackCover = dynamic_cast<CglKnapsackCover *>(generator);
     838    if (cglKnapsackCoverq) {
     839    }
     840#endif
     841  }
     842}
    801843
    802844
  • trunk/Cbc/src/unitTestClp.cpp

    r848 r854  
    1111#include "OsiClpSolverInterface.hpp"
    1212#include "OsiRowCutDebugger.hpp"
    13 
    1413//#############################################################################
    1514
     
    124123    */
    125124    // 0 for no test, 1 for some, 2 for many, 3 for all
     125    //PUSH_MPS("blend2",274,353,7.598985,6.9156751140,7);
    126126#define HOWMANY 2
    127127#if HOWMANY
    128128#if HOWMANY>1
    129     //PUSH_MPS("blend2",274,353,7.598985,6.9156751140,7);
    130129    PUSH_MPS("10teams",230,2025,924,917,7);
    131130#endif
     
    346345      model->solver()->activateRowCutDebugger(problemName.c_str()) ;
    347346    }
     347    setCutAndHeuristicOptions(*model);
    348348    model->branchAndBound();
    349349     
Note: See TracChangeset for help on using the changeset viewer.