Changeset 1221


Ignore:
Timestamp:
Sep 3, 2009 11:43:48 AM (10 years ago)
Author:
forrest
Message:

for examples

Location:
trunk/Cbc/src
Files:
14 edited

Legend:

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

    r1212 r1221  
    10841084  depthCutGeneratorInSub_ = value;
    10851085}
     1086// Create C++ lines to get to current state
     1087void
     1088CbcCutGenerator::generateTuning( FILE * fp)
     1089{
     1090  fprintf(fp,"// Cbc tuning for generator %s\n",generatorName_);
     1091  fprintf(fp,"   generator->setHowOften(%d);\n",whenCutGenerator_);
     1092  fprintf(fp,"   generator->setSwitchOffIfLessThan(%d);\n",switchOffIfLessThan_);
     1093  fprintf(fp,"   generator->setWhatDepth(%d);\n",depthCutGenerator_);
     1094  fprintf(fp,"   generator->setInaccuracy(%d);\n",inaccuracy_);
     1095  if (timing())
     1096    fprintf(fp,"   generator->setTiming(true);\n");
     1097  if (normal())
     1098    fprintf(fp,"   generator->setNormal(true);\n");
     1099  if (atSolution())
     1100    fprintf(fp,"   generator->setAtSolution(true);\n");
     1101  if (whenInfeasible())
     1102    fprintf(fp,"   generator->setWhenInfeasible(true);\n");
     1103  if (needsOptimalBasis())
     1104    fprintf(fp,"   generator->setNeedsOptimalBasis(true);\n");
     1105  if (mustCallAgain())
     1106    fprintf(fp,"   generator->setMustCallAgain(true);\n");
     1107  if (whetherToUse())
     1108    fprintf(fp,"   generator->setWhetherToUse(true);\n");
     1109}
    10861110
    10871111
  • trunk/Cbc/src/CbcCutGenerator.hpp

    r1212 r1221  
    105105  { return generatorName_;}
    106106
     107  /// Create C++ lines to show how to tune
     108  void generateTuning( FILE * fp);
    107109  /** Set the cut generation interval
    108110
     
    253255  inline void setIneffectualCuts(bool yesNo)
    254256  { switches_&=~512;switches_ |= yesNo ? 512 : 0;}
    255   /// Whether to use if nay cuts generated
     257  /// Whether to use if any cuts generated
    256258  inline bool whetherToUse() const
    257259  { return (switches_&1024)!=0;}
  • trunk/Cbc/src/CbcEventHandler.cpp

    r1173 r1221  
    1818//-------------------------------------------------------------------
    1919
    20 CbcEventHandler::CbcEventHandler (const CbcModel *model)
     20CbcEventHandler::CbcEventHandler (CbcModel *model)
    2121  : model_(model),
    2222    dfltAction_(CbcEventHandler::noAction),
  • trunk/Cbc/src/CbcEventHandler.hpp

    r1173 r1221  
    9090    solution,
    9191    /*! A heuristic solution has been found. */
    92     heuristicSolution
     92    heuristicSolution,
     93    /*! A solution will be found unless user takes action. */
     94    beforeSolution,
     95    /*! End of search. */
     96    endSearch
    9397  } ;
    9498
     
    108112    restart,
    109113    /*! RestartRoot --- undo root node and start branch-and-cut afresh. */
    110     restartRoot
     114    restartRoot,
     115    /*! Pretend solution never happened. */
     116    killSolution
     117     
    111118  } ;
    112119
     
    135142  /*! \brief Default constructor. */
    136143
    137   CbcEventHandler(const CbcModel *model = NULL) ;
     144  CbcEventHandler(CbcModel *model = NULL) ;
    138145
    139146  /*! \brief Copy constructor. */
     
    193200  /*! \brief Pointer to associated CbcModel */
    194201
    195   const CbcModel *model_ ;
     202  CbcModel *model_ ;
    196203
    197204  /*! \brief Default action */
  • trunk/Cbc/src/CbcHeuristic.cpp

    r1219 r1221  
    9292
    9393//==============================================================================
    94 
     94#define DEFAULT_WHERE ((255-2-16)*(1+256))
    9595// Default Constructor
    9696CbcHeuristic::CbcHeuristic() :
     
    104104  decayFactor_(0.0),
    105105  switches_(0),
    106   whereFrom_((255-2-16)*(1+256)),
     106  whereFrom_(DEFAULT_WHERE),
    107107  shallowDepth_(1),
    108108  howOftenShallow_(1),
     
    131131  decayFactor_(0.0),
    132132  switches_(0),
    133   whereFrom_((255-2-16)*(1+256)),
     133  whereFrom_(DEFAULT_WHERE),
    134134  shallowDepth_(1),
    135135  howOftenShallow_(1),
     
    156156  heuristicName_ = rhs.heuristicName_;
    157157  howOften_ = rhs.howOften_;
    158   decayFactor_ = rhs.howOften_;
     158  decayFactor_ = rhs.decayFactor_;
    159159  switches_ = rhs.switches_;
    160160  whereFrom_ = rhs.whereFrom_;
     
    460460  else
    461461    fprintf(fp,"4  %s.setNumberNodes(%d);\n",heuristic,numberNodes_);
     462  if (feasibilityPumpOptions_!=-1)
     463    fprintf(fp,"3  %s.setFeasibilityPumpOptions(%d);\n",heuristic,feasibilityPumpOptions_);
     464  else
     465    fprintf(fp,"4  %s.setFeasibilityPumpOptions(%d);\n",heuristic,feasibilityPumpOptions_);
    462466  if (fractionSmall_!=1.0)
    463467    fprintf(fp,"3  %s.setFractionSmall(%g);\n",heuristic,fractionSmall_);
     
    470474    fprintf(fp,"4  %s.setHeuristicName(\"%s\");\n",
    471475            heuristic,heuristicName_.c_str()) ;
     476  if (decayFactor_!=0.0)
     477    fprintf(fp,"3  %s.setDecayFactor(%g);\n",heuristic,decayFactor_);
     478  else
     479    fprintf(fp,"4  %s.setDecayFactor(%g);\n",heuristic,decayFactor_);
     480  if (switches_!=0)
     481    fprintf(fp,"3  %s.setSwitches(%d);\n",heuristic,switches_);
     482  else
     483    fprintf(fp,"4  %s.setSwitches(%d);\n",heuristic,switches_);
     484  if (whereFrom_!=DEFAULT_WHERE)
     485    fprintf(fp,"3  %s.setWhereFrom(%d);\n",heuristic,whereFrom_);
     486  else
     487    fprintf(fp,"4  %s.setWhereFrom(%d);\n",heuristic,whereFrom_);
     488  if (shallowDepth_!=1)
     489    fprintf(fp,"3  %s.setShallowDepth(%d);\n",heuristic,shallowDepth_);
     490  else
     491    fprintf(fp,"4  %s.setShallowDepth(%d);\n",heuristic,shallowDepth_);
     492  if (howOftenShallow_!=1)
     493    fprintf(fp,"3  %s.setHowOftenShallow(%d);\n",heuristic,howOftenShallow_);
     494  else
     495    fprintf(fp,"4  %s.setHowOftenShallow(%d);\n",heuristic,howOftenShallow_);
     496  if (minDistanceToRun_!=1)
     497    fprintf(fp,"3  %s.setMinDistanceToRun(%d);\n",heuristic,minDistanceToRun_);
     498  else
     499    fprintf(fp,"4  %s.setMinDistanceToRun(%d);\n",heuristic,minDistanceToRun_);
    472500}
    473501// Destructor
     
    14991527{
    15001528  // matrix and row copy will automatically be empty
    1501   seed_=1;
     1529  seed_=7654321;
    15021530  down_ = NULL;
    15031531  up_ = NULL;
     
    15161544    validate();
    15171545  }
    1518   seed_=1;
     1546  seed_=7654321;
    15191547}
    15201548
  • trunk/Cbc/src/CbcHeuristic.hpp

    r1219 r1221  
    211211  /// Set random number generator seed
    212212  void setSeed(int value);
     213  /// Sets decay factor (for howOften) on failure
     214  inline void setDecayFactor(double value)
     215  { decayFactor_=value;}
    213216  /// Set input solution
    214217  void setInputSolution(const double * solution, double objValue);
     218  /* Runs if bit set
     219      0 - before cuts at root node (or from doHeuristics)
     220      1 - during cuts at root
     221      2 - after root node cuts
     222      3 - after cuts at other nodes
     223      4 - during cuts at other nodes
     224          8 added if previous heuristic in loop found solution
     225   */
     226  inline void setWhereFrom(int value)
     227  { whereFrom_=value;}
     228  /** Upto this depth we call the tree shallow and the heuristic can be called
     229      multiple times. That is, the test whether the current node is far from
     230      the others where the jeuristic was invoked will not be done, only the
     231      frequency will be tested. After that depth the heuristic will can be
     232      invoked only once per node, right before branching. That's when it'll be
     233      tested whether the heur should run at all. */
     234  inline void setShallowDepth(int value)
     235  { shallowDepth_=value;}
     236  /** How often to invoke the heuristics in the shallow part of the tree */
     237  inline void setHowOftenShallow(int value)
     238  { howOftenShallow_=value;}
     239  /** How "far" should this node be from every other where the heuristic was
     240      run in order to allow the heuristic to run in this node, too. Currently
     241      this is tested, but we may switch to avgDistanceToRun_ in the future. */
     242  inline void setMinDistanceToRun(int value)
     243  { minDistanceToRun_=value;}
    215244
    216245  /** Check whether the heuristic should run at all
     
    239268      Add 4 to say quite likely infeasible so give up easily.*/
    240269  OsiSolverInterface * cloneBut(int type);
    241 
    242270protected:
    243271
  • trunk/Cbc/src/CbcHeuristicDive.cpp

    r1219 r1221  
    7777  else
    7878    fprintf(fp,"4  %s.setMaxIterations(%d);\n",heuristic,maxIterations_);
    79   if (maxSimplexIterations_!=100)
    80     fprintf(fp,"3  %s.setMaxIterations(%d);\n",heuristic,maxSimplexIterations_);
     79  if (maxSimplexIterations_!=10000)
     80    fprintf(fp,"3  %s.setMaxSimplexIterations(%d);\n",heuristic,maxSimplexIterations_);
    8181  else
    82     fprintf(fp,"4  %s.setMaxIterations(%d);\n",heuristic,maxSimplexIterations_);
     82    fprintf(fp,"4  %s.setMaxSimplexIterations(%d);\n",heuristic,maxSimplexIterations_);
    8383  if (maxTime_!=600)
    8484    fprintf(fp,"3  %s.setMaxTime(%.2f);\n",heuristic,maxTime_);
  • trunk/Cbc/src/CbcHeuristicFPump.cpp

    r1219 r1221  
    127127  else
    128128    fprintf(fp,"4  heuristicFPump.setDefaultRounding(%g);\n",defaultRounding_);
    129   fprintf(fp,"3  cbcModel->addHeuristic(&heuristicFPump);\n");
    130129  if (initialWeight_!=other.initialWeight_)
    131130    fprintf(fp,"3  heuristicFPump.setInitialWeight(%g);\n",initialWeight_);
     
    136135  else
    137136    fprintf(fp,"4  heuristicFPump.setWeightFactor(%g);\n",weightFactor_);
     137  if (artificialCost_!=other.artificialCost_)
     138    fprintf(fp,"3  heuristicFPump.setArtificialCost(%g);\n",artificialCost_);
     139  else
     140    fprintf(fp,"4  heuristicFPump.setArtificialCost(%g);\n",artificialCost_);
     141  if (iterationRatio_!=other.iterationRatio_)
     142    fprintf(fp,"3  heuristicFPump.setIterationRatio(%g);\n",iterationRatio_);
     143  else
     144    fprintf(fp,"4  heuristicFPump.setIterationRatio(%g);\n",iterationRatio_);
     145  if (reducedCostMultiplier_!=other.reducedCostMultiplier_)
     146    fprintf(fp,"3  heuristicFPump.setReducedCostMultiplier(%g);\n",reducedCostMultiplier_);
     147  else
     148    fprintf(fp,"4  heuristicFPump.setReducedCostMultiplier(%g);\n",reducedCostMultiplier_);
     149  fprintf(fp,"3  cbcModel->addHeuristic(&heuristicFPump);\n");
    138150}
    139151
     
    760772              bestBasis = * basis;
    761773              delete basis;
    762               CbcEventHandler * handler = model_->getEventHandler();
    763               if (handler) {
     774              int action = model_->dealWithEventHandler(CbcEventHandler::heuristicSolution,newSolutionValue,betterSolution);
     775              if (action==0) {
    764776                double * saveOldSolution = CoinCopyOfArray(model_->bestSolution(),numberColumns);
    765777                double saveObjectiveValue = model_->getMinimizationObjValue();
    766778                model_->setBestSolution(betterSolution,numberColumns,newSolutionValue);
    767                 int action = handler->event(CbcEventHandler::heuristicSolution);
    768779                if (saveOldSolution&&saveObjectiveValue<model_->getMinimizationObjValue())
    769780                  model_->setBestSolution(saveOldSolution,numberColumns,saveObjectiveValue);
    770781                delete [] saveOldSolution;
    771                 if (!action||model_->maximumSecondsReached()) {
    772                   exitAll=true; // exit
    773                   break;
    774                 }
     782              }
     783              if (action==0||model_->maximumSecondsReached()) {
     784                exitAll=true; // exit
     785                break;
    775786              }
    776787            }
     
    10021013                bestBasis = * basis;
    10031014                delete basis;
    1004                 CbcEventHandler * handler = model_->getEventHandler();
    1005                 if (handler) {
     1015                int action = model_->dealWithEventHandler(CbcEventHandler::heuristicSolution,newSolutionValue,betterSolution);
     1016                if (!action) {
    10061017                  double * saveOldSolution = CoinCopyOfArray(model_->bestSolution(),numberColumns);
    10071018                  double saveObjectiveValue = model_->getMinimizationObjValue();
    10081019                  model_->setBestSolution(betterSolution,numberColumns,newSolutionValue);
    1009                   int action = handler->event(CbcEventHandler::heuristicSolution);
    10101020                  if (saveOldSolution&&saveObjectiveValue<model_->getMinimizationObjValue())
    10111021                    model_->setBestSolution(saveOldSolution,numberColumns,saveObjectiveValue);
    10121022                  delete [] saveOldSolution;
    1013                   if (!action||model_->maximumSecondsReached()) {
    1014                     exitAll=true; // exit
    1015                     break;
    1016                   }
     1023                }
     1024                if (!action||model_->maximumSecondsReached()) {
     1025                  exitAll=true; // exit
     1026                  break;
    10171027                }
    10181028              }
     
    18401850            bestBasis = * basis;
    18411851            delete basis;
    1842             CbcEventHandler * handler = model_->getEventHandler();
    1843             if (handler) {
     1852            int action = model_->dealWithEventHandler(CbcEventHandler::heuristicSolution,newSolutionValue,betterSolution);
     1853            if (action==0) {
    18441854              double * saveOldSolution = CoinCopyOfArray(model_->bestSolution(),numberColumns);
    18451855              double saveObjectiveValue = model_->getMinimizationObjValue();
    18461856              model_->setBestSolution(betterSolution,numberColumns,newSolutionValue);
    1847               int action = handler->event(CbcEventHandler::heuristicSolution);
    1848               //printf("cutoff %g\n",model_->getCutoff());
    18491857              if (saveOldSolution&&saveObjectiveValue<model_->getMinimizationObjValue())
    18501858                model_->setBestSolution(saveOldSolution,numberColumns,saveObjectiveValue);
    18511859              delete [] saveOldSolution;
    1852               if (!action||model_->getCurrentSeconds()>model_->getMaximumSeconds()) {
    1853                 exitAll=true; // exit
    1854                 break;
    1855               }
     1860            }
     1861            if (!action||model_->getCurrentSeconds()>model_->getMaximumSeconds()) {
     1862              exitAll=true; // exit
     1863              break;
    18561864            }
    18571865          }
  • trunk/Cbc/src/CbcHeuristicFPump.hpp

    r1219 r1221  
    88#include "OsiClpSolverInterface.hpp"
    99
    10 /** Rounding class
     10/** Feasibility Pump class
    1111 */
    1212
  • trunk/Cbc/src/CbcHeuristicRINS.cpp

    r1219 r1221  
    7272    numberSolutions_ = rhs.numberSolutions_;
    7373    howOften_ = rhs.howOften_;
    74     decayFactor_ = rhs.decayFactor_;
    7574    numberSuccesses_ = rhs.numberSuccesses_;
    7675    numberTries_ = rhs.numberTries_;
     
    109108  numberSolutions_(rhs.numberSolutions_),
    110109  howOften_(rhs.howOften_),
    111   decayFactor_(rhs.decayFactor_),
    112110  numberSuccesses_(rhs.numberSuccesses_),
    113111  numberTries_(rhs.numberTries_),
     
    447445    numberSolutions_ = rhs.numberSolutions_;
    448446    howOften_ = rhs.howOften_;
    449     decayFactor_ = rhs.decayFactor_;
    450447    numberSuccesses_ = rhs.numberSuccesses_;
    451448    numberTries_ = rhs.numberTries_;
     
    481478  else
    482479    fprintf(fp,"4  heuristicDINS.setHowOften(%d);\n",howOften_);
     480  if (maximumKeepSolutions_!=other.maximumKeepSolutions_)
     481    fprintf(fp,"3  heuristicDINS.setMaximumKeep(%d);\n",maximumKeepSolutions_);
     482  else
     483    fprintf(fp,"4  heuristicDINS.setMaximumKeep(%d);\n",maximumKeepSolutions_);
    483484  fprintf(fp,"3  cbcModel->addHeuristic(&heuristicDINS);\n");
    484485}
     
    490491  numberSolutions_(rhs.numberSolutions_),
    491492  howOften_(rhs.howOften_),
    492   decayFactor_(rhs.decayFactor_),
    493493  numberSuccesses_(rhs.numberSuccesses_),
    494494  numberTries_(rhs.numberTries_),
  • trunk/Cbc/src/CbcHeuristicRINS.hpp

    r1205 r1221  
    5757  inline void setHowOften(int value)
    5858  { howOften_=value;}
    59   /// Sets decay factor (for howOften) on failure
    60   inline void setDecayFactor(double value)
    61   { decayFactor_=value;}
    6259  /// Used array so we can set
    6360  inline char * used() const
     
    7168  /// How often to do (code can change)
    7269  int howOften_;
    73   /// How much to increase how often
    74   double decayFactor_;
    7570  /// Number of successes
    7671  int numberSuccesses_;
     
    179174  inline void setHowOften(int value)
    180175  { howOften_=value;}
    181   /// Sets decay factor (for howOften) on failure
    182   inline void setDecayFactor(double value)
    183   { decayFactor_=value;}
    184176  /// Sets maximum number of solutions kept
    185177  inline void setMaximumKeep(int value)
     
    196188  /// How often to do (code can change)
    197189  int howOften_;
    198   /// How much to increase how often
    199   double decayFactor_;
    200190  /// Number of successes
    201191  int numberSuccesses_;
  • trunk/Cbc/src/CbcModel.cpp

    r1219 r1221  
    39273927  numberNodes_ += numberExtraNodes_;
    39283928  numberIterations_ += numberExtraIterations_;
     3929  if (eventHandler) {
     3930    eventHandler->event(CbcEventHandler::endSearch);
     3931  }
    39293932  if (!status_) {
    39303933    // Set best possible unless stopped on gap
     
    68126815      for ( i = 0;i<numberCuts;i++) {
    68136816        OsiRowCut * thisCut = globalCuts_.rowCutPtr(i) ;
    6814         if (thisCut->violated(cbcColSolution_)>primalTolerance) {
     6817        if (thisCut->violated(cbcColSolution_)>primalTolerance||
     6818            thisCut->effectiveness()==COIN_DBL_MAX) {
    68156819          //printf("Global cut added - violation %g\n",
    68166820          // thisCut->violated(cbcColSolution_)) ;
     
    1061610620    if (objectiveValue>cutoff&&objectiveValue<cutoff+1.0e-8+1.0e-8*fabs(cutoff))
    1061710621      cutoff = objectiveValue; // relax
     10622    CbcEventHandler::CbcAction action =
     10623      dealWithEventHandler(CbcEventHandler::beforeSolution,
     10624                           objectiveValue,solution);
     10625    if (action==CbcEventHandler::killSolution) {
     10626      // Pretend solution never happened
     10627      objectiveValue = cutoff+1.0e30;
     10628    }
    1061810629    if (objectiveValue > cutoff||objectiveValue>1.0e30) {
    1061910630      if (objectiveValue>1.0e30)
     
    1085110862  return ;
    1085210863}
    10853 
     10864// Deals with event handler and solution
     10865CbcEventHandler::CbcAction
     10866CbcModel::dealWithEventHandler(CbcEventHandler::CbcEvent event,
     10867                                                   double objValue,
     10868                                                   double * solution)
     10869{
     10870  CbcEventHandler *eventHandler = getEventHandler() ;
     10871  if (eventHandler) {
     10872    // Temporarily put in best
     10873    double saveObj = bestObjective_;
     10874    double * saveSol = bestSolution_;
     10875    bestObjective_ = objValue;
     10876    bestSolution_ = solution;
     10877    CbcEventHandler::CbcAction action =
     10878      eventHandler->event(event);
     10879    bestObjective_ = saveObj;
     10880    bestSolution_ = saveSol;
     10881    return action;
     10882  } else {
     10883    return CbcEventHandler::noAction;
     10884  }
     10885}
    1085410886
    1085510887/* Test the current solution for feasibility.
     
    1236512397          if (ifSol>0) {
    1236612398            // better solution found
    12367             heuristic_[i]->incrementNumberSolutionsFound();
    12368             found = i ;
    12369             incrementUsed(newSolution);
    12370             // increment number of solutions so other heuristics can test
    12371             numberSolutions_++;
    12372             numberHeuristicSolutions_++;
     12399            double currentObjective = bestObjective_;
     12400            CbcHeuristic * saveHeuristic = lastHeuristic_;
    1237312401            lastHeuristic_ = heuristic_[i];
     12402            setBestSolution(CBC_ROUNDING,heuristicValue,newSolution) ;
     12403            if (bestObjective_<currentObjective) {
     12404              heuristic_[i]->incrementNumberSolutionsFound();
     12405              found = i ;
     12406              incrementUsed(newSolution);
     12407              // increment number of solutions so other heuristics can test
     12408              numberSolutions_++;
     12409              numberHeuristicSolutions_++;
    1237412410#ifdef CLP_INVESTIGATE
    12375             printf("HEUR %s where %d C\n",
    12376                    lastHeuristic_->heuristicName(),whereFrom);
    12377 #endif
    12378             setBestSolution(CBC_ROUNDING,heuristicValue,newSolution) ;
    12379             whereFrom |= 8; // say solution found
    12380             if (heuristic_[i]->exitNow(bestObjective_))
    12381               break;
     12411              printf("HEUR %s where %d C\n",
     12412                     lastHeuristic_->heuristicName(),whereFrom);
     12413#endif
     12414              whereFrom |= 8; // say solution found
     12415              if (heuristic_[i]->exitNow(bestObjective_))
     12416                break;
     12417            } else {
     12418              // NOT better solution
     12419#ifdef CLP_INVESTIGATE
     12420              printf("HEUR %s where %d REJECTED i==%d\n",
     12421                     heuristic_[i]->heuristicName(),whereFrom,i);
     12422#endif
     12423              lastHeuristic_ = saveHeuristic;
     12424              heuristicValue = saveValue ;
     12425            }
    1238212426          } else {
    1238312427            heuristicValue = saveValue ;
  • trunk/Cbc/src/CbcModel.hpp

    r1216 r1221  
    1414#include "CbcCompareBase.hpp"
    1515#include "CbcMessage.hpp"
     16#include "CbcEventHandler.hpp"
    1617
    1718//class OsiSolverInterface;
     
    10601061  /// Just update objectiveValue
    10611062  void setBestObjectiveValue( double objectiveValue);
     1063  /// Deals with event handler and solution
     1064  CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
     1065                                                   double objValue,
     1066                                                   double * solution);
    10621067
    10631068  /** Call this to really test if a valid solution can be feasible
  • trunk/Cbc/src/CbcSolver.cpp

    r1219 r1221  
    786786  return new CbcStopNow(*this);
    787787}
    788 #ifdef CLP_FAST_CODE
    789 // force new style solver
    790 #ifndef NEW_STYLE_SOLVER
    791 #define NEW_STYLE_SOLVER 1
    792 #endif
    793 #else
    794 // Not new style solver
    795788#ifndef NEW_STYLE_SOLVER
    796789#define NEW_STYLE_SOLVER 0
    797 #endif
    798790#endif
    799791#ifdef CPX_KEEP_RESULTS
     
    810802#define NEW_STYLE_SOLVER 0
    811803#endif
    812 //#undef COIN_HAS_ASL
    813804#ifdef COIN_HAS_ASL
    814805#include "Cbc_ampl.h"
Note: See TracChangeset for help on using the changeset viewer.