# CbcModel.hpp

Go to the documentation of this file.

    00001 /* $Id: CbcModel.hpp 1795 2012-09-03 12:58:59Z stefan $ */
    00002 // Copyright (C) 2002, International Business Machines
    00003 // Corporation and others.  All Rights Reserved.
    00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
    00005
    00006 #ifndef CbcModel_H
    00007 #define CbcModel_H
    00008 #include <string>
    00009 #include <vector>
    00010 #include "CoinMessageHandler.hpp"
    00011 #include "OsiSolverInterface.hpp"
    00012 #include "OsiBranchingObject.hpp"
    00013 #include "OsiCuts.hpp"
    00014 #include "CoinWarmStartBasis.hpp"
    00015 #include "CbcCompareBase.hpp"
    00016 #include "CbcMessage.hpp"
    00017 #include "CbcEventHandler.hpp"
    00018 #include "ClpDualRowPivot.hpp"
    00019
    00020
    00021 class CbcCutGenerator;
    00022 class CbcBaseModel;
    00023 class OsiRowCut;
    00024 class OsiBabSolver;
    00025 class OsiRowCutDebugger;
    00026 class CglCutGenerator;
    00027 class CglStored;
    00028 class CbcCutModifier;
    00029 class CglTreeProbingInfo;
    00030 class CbcHeuristic;
    00031 class OsiObject;
    00032 class CbcThread;
    00033 class CbcTree;
    00034 class CbcStrategy;
    00035 class CbcFeasibilityBase;
    00036 class CbcStatistics;
    00037 class CbcEventHandler ;
    00038 class CglPreProcess;
    00039 # ifdef COIN_HAS_CLP
    00040 class OsiClpSolverInterface;
    00041 class ClpNodeStuff;
    00042 #endif
    00043 // #define CBC_CHECK_BASIS 1
    00044
    00045 //#############################################################################
    00046
    00099 class CbcModel  {
    00100
    00101 public:
    00102
    00103     enum CbcIntParam {
    00105         CbcMaxNumNode = 0,
    00107         CbcMaxNumSol,
    00117         CbcFathomDiscipline,
    00121         CbcPrinting,
    00124         CbcNumberBranches,
    00126         CbcLastIntParam
    00127     };
    00128
    00129     enum CbcDblParam {
    00132         CbcIntegerTolerance = 0,
    00135         CbcInfeasibilityWeight,
    00138         CbcCutoffIncrement,
    00145         CbcAllowableGap,
    00152         CbcAllowableFractionGap,
    00155         CbcMaximumSeconds,
    00157         CbcCurrentCutoff,
    00159         CbcOptimizationDirection,
    00161         CbcCurrentObjectiveValue,
    00163         CbcCurrentMinimizationObjectiveValue,
    00166         CbcStartSeconds,
    00174         CbcHeuristicGap,
    00182         CbcHeuristicFractionGap,
    00184         CbcSmallestChange,
    00186         CbcSumChange,
    00188         CbcLargestChange,
    00190         CbcSmallChange,
    00192         CbcLastDblParam
    00193     };
    00194
    00195     //---------------------------------------------------------------------------
    00196
    00197 public:
    00199
    00200
    00204     void initialSolve();
    00205
    00216     void branchAndBound(int doStatistics = 0);
    00217 private:
    00218
    00226     bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node);
    00234     int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
    00242     int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
    00249     CbcNode ** solveOneNode(int whichSolver, CbcNode * node,
    00250                             int & numberNodesOutput, int & status) ;
    00252     void resizeWhichGenerator(int numberNow, int numberAfter);
    00253 public:
    00254 #ifdef CBC_KEEP_DEPRECATED
    00255     // See if anyone is using these any more!!
    00260     CbcModel *  cleanModel(const double * lower, const double * upper);
    00277     int subBranchAndBound(CbcModel * model2,
    00278                           CbcModel * presolvedModel,
    00279                           int maximumNodes);
    00295     int subBranchAndBound(const double * lower, const double * upper,
    00296                           int maximumNodes);
    00297
    00304     OsiSolverInterface *  strengthenedModel();
    00314     CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5,
    00315                                 int tuning = 5);
    00318     void postProcess(CglPreProcess * process);
    00319 #endif
    00321     void addUpdateInformation(const CbcObjectUpdateData & data);
    00322
    00328     int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);
    00329
    00330 public:
    00344     int resolve(CbcNodeInfo * parent, int whereFrom,
    00345                 double * saveSolution = NULL,
    00346                 double * saveLower = NULL,
    00347                 double * saveUpper = NULL);
    00349     void makeGlobalCuts(int numberRows, const int * which);
    00351     void makeGlobalCut(const OsiRowCut * cut);
    00353     void makeGlobalCut(const OsiRowCut & cut);
    00355     void makeGlobalCut(const OsiColCut * cut);
    00357     void makeGlobalCut(const OsiColCut & cut);
    00359
    00362
    00374     CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
    00375                            int lessThanThis, int defaultValue = 1000);
    00376
    00385     CbcModel * integerPresolve(bool weak = false);
    00386
    00391     bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false);
    00392
    00393
    00395     void originalModel(CbcModel * presolvedModel, bool weak);
    00396
    00417     bool tightenVubs(int type, bool allowMultipleBinary = false,
    00418                      double useCutoff = 1.0e50);
    00419
    00425     bool tightenVubs(int numberVubs, const int * which,
    00426                      double useCutoff = 1.0e50);
    00430     void analyzeObjective();
    00431
    00435     void AddIntegers();
    00436
    00440     void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible);
    00441
    00443
    00449
    00451     inline int numberObjects() const {
    00452         return numberObjects_;
    00453     }
    00455     inline void setNumberObjects(int number) {
    00456         numberObjects_ = number;
    00457     }
    00458
    00460     inline OsiObject ** objects() const {
    00461         return object_;
    00462     }
    00463
    00465     const inline OsiObject * object(int which) const {
    00466         return object_[which];
    00467     }
    00469     inline OsiObject * modifiableObject(int which) const {
    00470         return object_[which];
    00471     }
    00472
    00473     void setOptionalInteger(int index);
    00474
    00476     void deleteObjects(bool findIntegers = true);
    00477
    00482     void addObjects(int numberObjects, OsiObject ** objects);
    00483
    00488     void addObjects(int numberObjects, CbcObject ** objects);
    00489
    00491     void synchronizeModel() ;
    00492
    00502     void findIntegers(bool startAgain, int type = 0);
    00503
    00505
    00506     //---------------------------------------------------------------------------
    00507
    00517
    00518     inline bool setIntParam(CbcIntParam key, int value) {
    00519         intParam_[key] = value;
    00520         return true;
    00521     }
    00523     inline bool setDblParam(CbcDblParam key, double value) {
    00524         dblParam_[key] = value;
    00525         return true;
    00526     }
    00528     inline int getIntParam(CbcIntParam key) const {
    00529         return intParam_[key];
    00530     }
    00532     inline double getDblParam(CbcDblParam key) const {
    00533         return dblParam_[key];
    00534     }
    00540     void setCutoff(double value) ;
    00541
    00543     inline double getCutoff() const { //double value ;
    00544         //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
    00545         //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
    00546         return dblParam_[CbcCurrentCutoff];
    00547     }
    00548
    00550     inline bool setMaximumNodes( int value) {
    00551         return setIntParam(CbcMaxNumNode, value);
    00552     }
    00553
    00555     inline int getMaximumNodes() const {
    00556         return getIntParam(CbcMaxNumNode);
    00557     }
    00558
    00563     inline bool setMaximumSolutions( int value) {
    00564         return setIntParam(CbcMaxNumSol, value);
    00565     }
    00570     inline int getMaximumSolutions() const {
    00571         return getIntParam(CbcMaxNumSol);
    00572     }
    00574     inline bool setPrintingMode( int value) {
    00575         return setIntParam(CbcPrinting, value);
    00576     }
    00577
    00579     inline int getPrintingMode() const {
    00580         return getIntParam(CbcPrinting);
    00581     }
    00582
    00587     inline bool setMaximumSeconds( double value) {
    00588         return setDblParam(CbcMaximumSeconds, value);
    00589     }
    00594     inline double getMaximumSeconds() const {
    00595         return getDblParam(CbcMaximumSeconds);
    00596     }
    00598     double getCurrentSeconds() const ;
    00599
    00601     bool maximumSecondsReached() const ;
    00602
    00606     inline bool setIntegerTolerance( double value) {
    00607         return setDblParam(CbcIntegerTolerance, value);
    00608     }
    00612     inline double getIntegerTolerance() const {
    00613         return getDblParam(CbcIntegerTolerance);
    00614     }
    00615
    00620     inline bool setInfeasibilityWeight( double value) {
    00621         return setDblParam(CbcInfeasibilityWeight, value);
    00622     }
    00627     inline double getInfeasibilityWeight() const {
    00628         return getDblParam(CbcInfeasibilityWeight);
    00629     }
    00630
    00634     inline bool setAllowableGap( double value) {
    00635         return setDblParam(CbcAllowableGap, value);
    00636     }
    00640     inline double getAllowableGap() const {
    00641         return getDblParam(CbcAllowableGap);
    00642     }
    00643
    00647     inline bool setAllowableFractionGap( double value) {
    00648         return setDblParam(CbcAllowableFractionGap, value);
    00649     }
    00653     inline double getAllowableFractionGap() const {
    00654         return getDblParam(CbcAllowableFractionGap);
    00655     }
    00659     inline bool setAllowablePercentageGap( double value) {
    00660         return setDblParam(CbcAllowableFractionGap, value*0.01);
    00661     }
    00665     inline double getAllowablePercentageGap() const {
    00666         return 100.0*getDblParam(CbcAllowableFractionGap);
    00667     }
    00671     inline bool setHeuristicGap( double value) {
    00672         return setDblParam(CbcHeuristicGap, value);
    00673     }
    00677     inline double getHeuristicGap() const {
    00678         return getDblParam(CbcHeuristicGap);
    00679     }
    00680
    00684     inline bool setHeuristicFractionGap( double value) {
    00685         return setDblParam(CbcHeuristicFractionGap, value);
    00686     }
    00690     inline double getHeuristicFractionGap() const {
    00691         return getDblParam(CbcHeuristicFractionGap);
    00692     }
    00697     inline bool setCutoffIncrement( double value) {
    00698         return setDblParam(CbcCutoffIncrement, value);
    00699     }
    00704     inline double getCutoffIncrement() const {
    00705         return getDblParam(CbcCutoffIncrement);
    00706     }
    00707
    00712     void setHotstartSolution(const double * solution, const int * priorities = NULL) ;
    00713
    00715     inline void setMinimumDrop(double value) {
    00716         minimumDrop_ = value;
    00717     }
    00719     inline double getMinimumDrop() const {
    00720         return minimumDrop_;
    00721     }
    00722
    00725     inline void setMaximumCutPassesAtRoot(int value) {
    00726         maximumCutPassesAtRoot_ = value;
    00727     }
    00729     inline int getMaximumCutPassesAtRoot() const {
    00730         return maximumCutPassesAtRoot_;
    00731     }
    00732
    00735     inline void setMaximumCutPasses(int value) {
    00736         maximumCutPasses_ = value;
    00737     }
    00739     inline int getMaximumCutPasses() const {
    00740         return maximumCutPasses_;
    00741     }
    00744     inline int getCurrentPassNumber() const {
    00745         return currentPassNumber_;
    00746     }
    00747
    00753     void setNumberStrong(int number);
    00757     inline int numberStrong() const {
    00758         return numberStrong_;
    00759     }
    00762     inline void setPreferredWay(int value) {
    00763         preferredWay_ = value;
    00764     }
    00766     inline int getPreferredWay() const {
    00767         return preferredWay_;
    00768     }
    00770     inline int whenCuts() const {
    00771         return whenCuts_;
    00772     }
    00774     inline void setWhenCuts(int value) {
    00775         whenCuts_ = value;
    00776     }
    00782     bool doCutsNow(int allowForTopOfTree) const;
    00783
    00789     void setNumberBeforeTrust(int number);
    00792     inline int numberBeforeTrust() const {
    00793         return numberBeforeTrust_;
    00794     }
    00800     void setNumberPenalties(int number);
    00803     inline int numberPenalties() const {
    00804         return numberPenalties_;
    00805     }
    00807     inline void setNumberAnalyzeIterations(int number) {
    00808         numberAnalyzeIterations_ = number;
    00809     }
    00810     inline int numberAnalyzeIterations() const {
    00811         return numberAnalyzeIterations_;
    00812     }
    00815     inline double penaltyScaleFactor() const {
    00816         return penaltyScaleFactor_;
    00817     }
    00820     void setPenaltyScaleFactor(double value);
    00828     void inline setProblemType(int number) {
    00829         problemType_ = number;
    00830     }
    00831     inline int problemType() const {
    00832         return problemType_;
    00833     }
    00835     inline int currentDepth() const {
    00836         return currentDepth_;
    00837     }
    00838
    00840     void setHowOftenGlobalScan(int number);
    00842     inline int howOftenGlobalScan() const {
    00843         return howOftenGlobalScan_;
    00844     }
    00846     inline int * originalColumns() const {
    00847         return originalColumns_;
    00848     }
    00850     void setOriginalColumns(const int * originalColumns) ;
    00851
    00859     inline void setPrintFrequency(int number) {
    00860         printFrequency_ = number;
    00861     }
    00863     inline int printFrequency() const {
    00864         return printFrequency_;
    00865     }
    00867
    00868     //---------------------------------------------------------------------------
    00870
    00871
    00872     bool isAbandoned() const;
    00874     bool isProvenOptimal() const;
    00876     bool isProvenInfeasible() const;
    00878     bool isContinuousUnbounded() const;
    00880     bool isProvenDualInfeasible() const;
    00882     bool isNodeLimitReached() const;
    00884     bool isSecondsLimitReached() const;
    00886     bool isSolutionLimitReached() const;
    00888     inline int getIterationCount() const {
    00889         return numberIterations_;
    00890     }
    00892     inline void incrementIterationCount(int value) {
    00893         numberIterations_ += value;
    00894     }
    00896     inline int getNodeCount() const {
    00897         return numberNodes_;
    00898     }
    00900     inline void incrementNodeCount(int value) {
    00901         numberNodes_ += value;
    00902     }
    00904     inline int getExtraNodeCount() const {
    00905        return numberExtraNodes_;
    00906     }
    00916     inline int status() const {
    00917         return status_;
    00918     }
    00919     inline void setProblemStatus(int value) {
    00920         status_ = value;
    00921     }
    00933     inline int secondaryStatus() const {
    00934         return secondaryStatus_;
    00935     }
    00936     inline void setSecondaryStatus(int value) {
    00937         secondaryStatus_ = value;
    00938     }
    00940     bool isInitialSolveAbandoned() const ;
    00942     bool isInitialSolveProvenOptimal() const ;
    00944     bool isInitialSolveProvenPrimalInfeasible() const ;
    00946     bool isInitialSolveProvenDualInfeasible() const ;
    00947
    00949
    00950     //---------------------------------------------------------------------------
    00963
    00964     inline int numberRowsAtContinuous() const {
    00965         return numberRowsAtContinuous_;
    00966     }
    00967
    00969     inline int getNumCols() const {
    00970         return solver_->getNumCols();
    00971     }
    00972
    00974     inline int getNumRows() const {
    00975         return solver_->getNumRows();
    00976     }
    00977
    00979     inline CoinBigIndex getNumElements() const {
    00980         return solver_->getNumElements();
    00981     }
    00982
    00984     inline int numberIntegers() const {
    00985         return numberIntegers_;
    00986     }
    00987     // Integer variables
    00988     inline const int * integerVariable() const {
    00989         return integerVariable_;
    00990     }
    00992     inline char integerType(int i) const {
    00993         assert (integerInfo_);
    00994         assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
    00995         return integerInfo_[i];
    00996     }
    00998     inline const char * integerType() const {
    00999         return integerInfo_;
    01000     }
    01001
    01003     inline const double * getColLower() const {
    01004         return solver_->getColLower();
    01005     }
    01006
    01008     inline const double * getColUpper() const {
    01009         return solver_->getColUpper();
    01010     }
    01011
    01021     inline const char * getRowSense() const {
    01022         return solver_->getRowSense();
    01023     }
    01024
    01033     inline const double * getRightHandSide() const {
    01034         return solver_->getRightHandSide();
    01035     }
    01036
    01045     inline const double * getRowRange() const {
    01046         return solver_->getRowRange();
    01047     }
    01048
    01050     inline const double * getRowLower() const {
    01051         return solver_->getRowLower();
    01052     }
    01053
    01055     inline const double * getRowUpper() const {
    01056         return solver_->getRowUpper();
    01057     }
    01058
    01060     inline const double * getObjCoefficients() const {
    01061         return solver_->getObjCoefficients();
    01062     }
    01063
    01065     inline double getObjSense() const {
    01066         //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
    01067         return dblParam_[CbcOptimizationDirection];
    01068     }
    01069
    01071     inline bool isContinuous(int colIndex) const {
    01072         return solver_->isContinuous(colIndex);
    01073     }
    01074
    01076     inline bool isBinary(int colIndex) const {
    01077         return solver_->isBinary(colIndex);
    01078     }
    01079
    01084     inline bool isInteger(int colIndex) const {
    01085         return solver_->isInteger(colIndex);
    01086     }
    01087
    01089     inline bool isIntegerNonBinary(int colIndex) const {
    01090         return solver_->isIntegerNonBinary(colIndex);
    01091     }
    01092
    01094     inline bool isFreeBinary(int colIndex) const {
    01095         return solver_->isFreeBinary(colIndex) ;
    01096     }
    01097
    01099     inline const CoinPackedMatrix * getMatrixByRow() const {
    01100         return solver_->getMatrixByRow();
    01101     }
    01102
    01104     inline const CoinPackedMatrix * getMatrixByCol() const {
    01105         return solver_->getMatrixByCol();
    01106     }
    01107
    01109     inline double getInfinity() const {
    01110         return solver_->getInfinity();
    01111     }
    01113     inline const double * getCbcColLower() const {
    01114         return cbcColLower_;
    01115     }
    01117     inline const double * getCbcColUpper() const {
    01118         return cbcColUpper_;
    01119     }
    01121     inline const double * getCbcRowLower() const {
    01122         return cbcRowLower_;
    01123     }
    01125     inline const double * getCbcRowUpper() const {
    01126         return cbcRowUpper_;
    01127     }
    01129     inline const double * getCbcColSolution() const {
    01130         return cbcColSolution_;
    01131     }
    01133     inline const double * getCbcRowPrice() const {
    01134         return cbcRowPrice_;
    01135     }
    01137     inline const double * getCbcReducedCost() const {
    01138         return cbcReducedCost_;
    01139     }
    01141     inline const double * getCbcRowActivity() const {
    01142         return cbcRowActivity_;
    01143     }
    01145
    01146
    01149
    01150     inline double * continuousSolution() const {
    01151         return continuousSolution_;
    01152     }
    01157     inline int * usedInSolution() const {
    01158         return usedInSolution_;
    01159     }
    01161     void incrementUsed(const double * solution);
    01163     void setBestSolution(CBC_Message how,
    01164                          double & objectiveValue, const double *solution,
    01165                          int fixVariables = 0);
    01167     void setBestObjectiveValue( double objectiveValue);
    01169     CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
    01170             double objValue,
    01171             const double * solution);
    01172
    01180     virtual double checkSolution(double cutoff, double * solution,
    01181                          int fixVariables, double originalObjValue);
    01188     bool feasibleSolution(int & numberIntegerInfeasibilities,
    01189                           int & numberObjectInfeasibilities) const;
    01190
    01196     inline double * currentSolution() const {
    01197         return currentSolution_;
    01198     }
    01202     inline const double * testSolution() const {
    01203         return testSolution_;
    01204     }
    01205     inline void setTestSolution(const double * solution) {
    01206         testSolution_ = solution;
    01207     }
    01209     void reserveCurrentSolution(const double * solution = NULL);
    01210
    01212     inline const double * getColSolution() const {
    01213         return solver_->getColSolution();
    01214     }
    01215
    01217     inline const double * getRowPrice() const {
    01218         return solver_->getRowPrice();
    01219     }
    01220
    01222     inline const double * getReducedCost() const {
    01223         return solver_->getReducedCost();
    01224     }
    01225
    01227     inline const double * getRowActivity() const {
    01228         return solver_->getRowActivity();
    01229     }
    01230
    01232     inline double getCurrentObjValue() const {
    01233         return dblParam_[CbcCurrentObjectiveValue];
    01234     }
    01236     inline double getCurrentMinimizationObjValue() const {
    01237         return dblParam_[CbcCurrentMinimizationObjectiveValue];
    01238     }
    01239
    01241     inline double getMinimizationObjValue() const {
    01242         return bestObjective_;
    01243     }
    01245     inline void setMinimizationObjValue(double value) {
    01246         bestObjective_ = value;
    01247     }
    01248
    01250     inline double getObjValue() const {
    01251         return bestObjective_ * solver_->getObjSense() ;
    01252     }
    01258     double getBestPossibleObjValue() const;
    01260     inline void setObjValue(double value) {
    01261         bestObjective_ = value * solver_->getObjSense() ;
    01262     }
    01264     inline double getSolverObjValue() const {
    01265         return solver_->getObjValue() * solver_->getObjSense() ;
    01266     }
    01267
    01274     inline double * bestSolution() const {
    01275         return bestSolution_;
    01276     }
    01283     void setBestSolution(const double * solution, int numberColumns,
    01284                          double objectiveValue, bool check = false);
    01285
    01287     inline int getSolutionCount() const {
    01288         return numberSolutions_;
    01289     }
    01290
    01292     inline void setSolutionCount(int value) {
    01293         numberSolutions_ = value;
    01294     }
    01296     int numberSavedSolutions() const;
    01298     inline int maximumSavedSolutions() const {
    01299         return maximumSavedSolutions_;
    01300     }
    01302     void setMaximumSavedSolutions(int value);
    01304     const double * savedSolution(int which) const;
    01306     double savedSolutionObjective(int which) const;
    01307
    01316     inline int phase() const {
    01317         return phase_;
    01318     }
    01319
    01321     inline int getNumberHeuristicSolutions() const {
    01322         return numberHeuristicSolutions_;
    01323     }
    01325     inline void setNumberHeuristicSolutions(int value) {
    01326         numberHeuristicSolutions_ = value;
    01327     }
    01328
    01330     inline void setObjSense(double s) {
    01331         dblParam_[CbcOptimizationDirection] = s;
    01332         solver_->setObjSense(s);
    01333     }
    01334
    01336     inline double getContinuousObjective() const {
    01337         return originalContinuousObjective_;
    01338     }
    01339     inline void setContinuousObjective(double value) {
    01340         originalContinuousObjective_ = value;
    01341     }
    01343     inline int getContinuousInfeasibilities() const {
    01344         return continuousInfeasibilities_;
    01345     }
    01346     inline void setContinuousInfeasibilities(int value) {
    01347         continuousInfeasibilities_ = value;
    01348     }
    01350     inline double rootObjectiveAfterCuts() const {
    01351         return continuousObjective_;
    01352     }
    01354     inline double sumChangeObjective() const {
    01355         return sumChangeObjective1_;
    01356     }
    01359     inline int numberGlobalViolations() const {
    01360         return numberGlobalViolations_;
    01361     }
    01362     inline void clearNumberGlobalViolations() {
    01363         numberGlobalViolations_ = 0;
    01364     }
    01366     inline bool resolveAfterTakeOffCuts() const {
    01367         return resolveAfterTakeOffCuts_;
    01368     }
    01369     inline void setResolveAfterTakeOffCuts(bool yesNo) {
    01370         resolveAfterTakeOffCuts_ = yesNo;
    01371     }
    01373     inline int maximumRows() const {
    01374         return maximumRows_;
    01375     }
    01377     inline CoinWarmStartBasis & workingBasis() {
    01378         return workingBasis_;
    01379     }
    01381     inline int getStopNumberIterations() const {
    01382         return stopNumberIterations_;
    01383     }
    01385     inline void setStopNumberIterations(int value) {
    01386         stopNumberIterations_ = value;
    01387     }
    01389
    01392     // Comparison functions (which may be overridden by inheritance)
    01393     inline CbcCompareBase * nodeComparison() const {
    01394         return nodeCompare_;
    01395     }
    01396     void setNodeComparison(CbcCompareBase * compare);
    01397     void setNodeComparison(CbcCompareBase & compare);
    01399
    01402     // Feasibility functions (which may be overridden by inheritance)
    01403     inline CbcFeasibilityBase * problemFeasibility() const {
    01404         return problemFeasibility_;
    01405     }
    01406     void setProblemFeasibility(CbcFeasibilityBase * feasibility);
    01407     void setProblemFeasibility(CbcFeasibilityBase & feasibility);
    01409
    01412
    01413     inline CbcTree * tree() const {
    01414         return tree_;
    01415     }
    01417     void passInTreeHandler(CbcTree & tree);
    01421     void passInSubTreeModel(CbcModel & model);
    01426     CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const;
    01428     inline int numberStoppedSubTrees() const {
    01429         return numberStoppedSubTrees_;
    01430     }
    01432     inline void incrementSubTreeStopped() {
    01433         numberStoppedSubTrees_++;
    01434     }
    01440     inline int typePresolve() const {
    01441         return presolve_;
    01442     }
    01443     inline void setTypePresolve(int value) {
    01444         presolve_ = value;
    01445     }
    01446
    01448
    01454
    01456     inline CbcBranchDecision * branchingMethod() const {
    01457         return branchingMethod_;
    01458     }
    01460     inline void setBranchingMethod(CbcBranchDecision * method) {
    01461         delete branchingMethod_;
    01462         branchingMethod_ = method->clone();
    01463     }
    01468     inline void setBranchingMethod(CbcBranchDecision & method) {
    01469         delete branchingMethod_;
    01470         branchingMethod_ = method.clone();
    01471     }
    01473     inline CbcCutModifier * cutModifier() const {
    01474         return cutModifier_;
    01475     }
    01477     void setCutModifier(CbcCutModifier * modifier);
    01482     void setCutModifier(CbcCutModifier & modifier);
    01484
    01487
    01494     inline int stateOfSearch() const {
    01495         return stateOfSearch_;
    01496     }
    01497     inline void setStateOfSearch(int state) {
    01498         stateOfSearch_ = state;
    01499     }
    01501     inline int searchStrategy() const {
    01502         return searchStrategy_;
    01503     }
    01505     inline void setSearchStrategy(int value) {
    01506         searchStrategy_ = value;
    01507     }
    01508
    01510     inline int numberCutGenerators() const {
    01511         return numberCutGenerators_;
    01512     }
    01514     inline CbcCutGenerator ** cutGenerators() const {
    01515         return generator_;
    01516     }
    01518     inline CbcCutGenerator * cutGenerator(int i) const {
    01519         return generator_[i];
    01520     }
    01522     inline CbcCutGenerator * virginCutGenerator(int i) const {
    01523         return virginGenerator_[i];
    01524     }
    01533     void addCutGenerator(CglCutGenerator * generator,
    01534                          int howOften = 1, const char * name = NULL,
    01535                          bool normal = true, bool atSolution = false,
    01536                          bool infeasible = false, int howOftenInSub = -100,
    01537                          int whatDepth = -1, int whatDepthInSub = -1);
    01539
    01544
    01546     inline CbcStrategy * strategy() const {
    01547         return strategy_;
    01548     }
    01550     void setStrategy(CbcStrategy & strategy);
    01552     inline void setStrategy(CbcStrategy * strategy) {
    01553         strategy_ = strategy;
    01554     }
    01556     inline CbcModel * parentModel() const {
    01557         return parentModel_;
    01558     }
    01560     inline void setParentModel(CbcModel & parentModel) {
    01561         parentModel_ = &parentModel;
    01562     }
    01564
    01565
    01572     void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
    01573                       int before = -1);
    01575     inline CbcHeuristic * heuristic(int i) const {
    01576         return heuristic_[i];
    01577     }
    01579     inline int numberHeuristics() const {
    01580         return numberHeuristics_;
    01581     }
    01583     inline CbcHeuristic * lastHeuristic() const {
    01584         return lastHeuristic_;
    01585     }
    01587     inline void setLastHeuristic(CbcHeuristic * last) {
    01588         lastHeuristic_ = last;
    01589     }
    01590
    01609     void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);
    01610
    01612     inline int priority(int sequence) const {
    01613         return object_[sequence]->priority();
    01614     }
    01615
    01620     void passInEventHandler(const CbcEventHandler *eventHandler) ;
    01621
    01623     inline CbcEventHandler* getEventHandler() const {
    01624         return (eventHandler_) ;
    01625     }
    01626
    01628
    01638     void setApplicationData (void * appData);
    01639
    01641     void * getApplicationData() const;
    01654     void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
    01656     inline const OsiBabSolver * solverCharacteristics() const {
    01657         return solverCharacteristics_;
    01658     }
    01660
    01661     //---------------------------------------------------------------------------
    01662
    01665
    01666     void passInMessageHandler(CoinMessageHandler * handler);
    01668     void newLanguage(CoinMessages::Language language);
    01669     inline void setLanguage(CoinMessages::Language language) {
    01670         newLanguage(language);
    01671     }
    01673     inline CoinMessageHandler * messageHandler() const {
    01674         return handler_;
    01675     }
    01677     inline CoinMessages & messages() {
    01678         return messages_;
    01679     }
    01681     inline CoinMessages * messagesPointer() {
    01682         return &messages_;
    01683     }
    01685     void setLogLevel(int value);
    01687     inline int logLevel() const {
    01688         return handler_->logLevel();
    01689     }
    01695     inline void setDefaultHandler(bool yesNo) {
    01696         defaultHandler_ = yesNo;
    01697     }
    01699     //---------------------------------------------------------------------------
    01701
    01702
    01727     inline void setSpecialOptions(int value) {
    01728         specialOptions_ = value;
    01729     }
    01731     inline int specialOptions() const {
    01732         return specialOptions_;
    01733     }
    01735     inline void sayEventHappened()
    01736     { eventHappened_=true;}
    01738     inline bool normalSolver() const {
    01739         return (specialOptions_&16) == 0;
    01740     }
    01745     inline bool waitingForMiniBranchAndBound() const {
    01746         return (specialOptions_&1048576) != 0;
    01747     }
    01762     inline void setMoreSpecialOptions(int value) {
    01763         moreSpecialOptions_ = value;
    01764     }
    01766     inline int moreSpecialOptions() const {
    01767         return moreSpecialOptions_;
    01768     }
    01770     inline void setUseElapsedTime(bool yesNo) {
    01771         if (yesNo)
    01772           moreSpecialOptions_ |= 131072;
    01773         else
    01774           moreSpecialOptions_ &= ~131072;
    01775     }
    01777     inline bool useElapsedTime() const {
    01778         return (moreSpecialOptions_&131072)!=0;
    01779     }
    01781 #ifdef COIN_HAS_CLP
    01782     void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
    01783 #endif
    01785     inline bool ownObjects() const {
    01786         return ownObjects_;
    01787     }
    01789     void checkModel();
    01791     //---------------------------------------------------------------------------
    01792
    01794
    01795
    01796     CbcModel();
    01797
    01799     CbcModel(const OsiSolverInterface &);
    01800
    01809     void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
    01810
    01822     inline void setModelOwnsSolver (bool ourSolver) {
    01823         ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
    01824     }
    01825
    01831     inline bool modelOwnsSolver () {
    01832         return ((ownership_&0x80000000) != 0) ;
    01833     }
    01834
    01838     CbcModel(const CbcModel & rhs, bool cloneHandler = false);
    01839
    01841     CbcModel & operator=(const CbcModel& rhs);
    01842
    01844     virtual ~CbcModel ();
    01845
    01847     inline OsiSolverInterface * solver() const {
    01848         return solver_;
    01849     }
    01850
    01852     inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) {
    01853         OsiSolverInterface * returnSolver = solver_;
    01854         solver_ = solver;
    01855         return returnSolver;
    01856     }
    01857
    01859     inline OsiSolverInterface * continuousSolver() const {
    01860         return continuousSolver_;
    01861     }
    01862
    01864     inline void createContinuousSolver() {
    01865         continuousSolver_ = solver_->clone();
    01866     }
    01868     inline void clearContinuousSolver() {
    01869         delete continuousSolver_;
    01870         continuousSolver_ = NULL;
    01871     }
    01872
    01874     inline OsiSolverInterface * referenceSolver() const {
    01875         return referenceSolver_;
    01876     }
    01877
    01879     void saveReferenceSolver();
    01880
    01886     void resetToReferenceSolver();
    01887
    01889     void gutsOfDestructor();
    01892     void gutsOfDestructor2();
    01895     void resetModel();
    01901     void gutsOfCopy(const CbcModel & rhs, int mode = 0);
    01903     void moveInfo(const CbcModel & rhs);
    01905
    01907
    01908
    01909     static bool haveMultiThreadSupport();
    01911     CbcThread * masterThread() const {
    01912         return masterThread_;
    01913     }
    01915     CbcNodeInfo ** walkback() const {
    01916         return walkback_;
    01917     }
    01919     inline int getNumberThreads() const {
    01920         return numberThreads_;
    01921     }
    01923     inline void setNumberThreads(int value) {
    01924         numberThreads_ = value;
    01925     }
    01927     inline int getThreadMode() const {
    01928         return threadMode_;
    01929     }
    01939     inline void setThreadMode(int value) {
    01940         threadMode_ = value;
    01941     }
    01948     inline int parallelMode() const {
    01949         if (!numberThreads_) {
    01950             if ((threadMode_&1) == 0)
    01951                 return 0;
    01952             else
    01953                 return -1;
    01954             return 0;
    01955         } else {
    01956             if ((threadMode_&1) == 0)
    01957                 return 1;
    01958             else
    01959                 return -2;
    01960         }
    01961     }
    01964     bool isLocked() const;
    01965 #ifdef CBC_THREAD
    01966
    01970     void lockThread();
    01974     void unlockThread();
    01975 #else
    01976     inline void lockThread() {}
    01977     inline void unlockThread() {}
    01978 #endif
    01979
    01986     void setInfoInChild(int type, CbcThread * info);
    01993     void moveToModel(CbcModel * baseModel, int mode);
    01995     int splitModel(int numberModels, CbcModel ** model,
    01996                    int numberNodes);
    01998     void startSplitModel(int numberIterations);
    02000     void mergeModels(int numberModel, CbcModel ** model,
    02001                      int numberNodes);
    02003
    02005
    02006
    02007     int getNodeCount2() const {
    02008         return numberNodes2_;
    02009     }
    02011     void setPointers(const OsiSolverInterface * solver);
    02017     int reducedCostFix() ;
    02021     void synchronizeHandlers(int makeDefault);
    02023     void saveExtraSolution(const double * solution, double objectiveValue);
    02025     void saveBestSolution(const double * solution, double objectiveValue);
    02027     void deleteSolutions();
    02029     int resolve(OsiSolverInterface * solver);
    02030 #ifdef CLP_RESOLVE
    02032     int resolveClp(OsiClpSolverInterface * solver, int type);
    02033 #endif
    02034
    02038     int chooseBranch(CbcNode * & newNode, int numberPassesLeft,
    02039                      CbcNode * oldNode, OsiCuts & cuts,
    02040                      bool & resolved, CoinWarmStartBasis *lastws,
    02041                      const double * lowerBefore, const double * upperBefore,
    02042                      OsiSolverBranch * & branches);
    02043     int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);
    02044
    02051     CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;
    02052
    02064     int takeOffCuts(OsiCuts &cuts,
    02065                     bool allowResolve, OsiCuts * saveCuts,
    02066                     int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;
    02067
    02081     int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws, bool canFix);
    02082
    02099     bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
    02103     void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn,
    02104                          double & lower, double & upper, int force);
    02109     void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;
    02110
    02114     void convertToDynamic();
    02116     void synchronizeNumberBeforeTrust(int type = 0);
    02118     void zapIntegerInformation(bool leaveObjects = true);
    02120     int cliquePseudoCosts(int doStatistics);
    02122     void pseudoShadow(int type);
    02129     void fillPseudoCosts(double * downCosts, double * upCosts,
    02130                          int * priority = NULL,
    02131                          int * numberDown = NULL, int * numberUp = NULL,
    02132                          int * numberDownInfeasible = NULL,
    02133                          int * numberUpInfeasible = NULL) const;
    02139     void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
    02141     void adjustHeuristics();
    02143     inline const double * hotstartSolution() const {
    02144         return hotstartSolution_;
    02145     }
    02147     inline const int * hotstartPriorities() const {
    02148         return hotstartPriorities_;
    02149     }
    02150
    02152     inline CbcCountRowCut ** addedCuts() const {
    02153         return addedCuts_;
    02154     }
    02156     inline int currentNumberCuts() const {
    02157         return currentNumberCuts_;
    02158     }
    02160     inline OsiCuts * globalCuts() {
    02161         return &globalCuts_;
    02162     }
    02164     void setNextRowCut(const OsiRowCut & cut);
    02166     inline CbcNode * currentNode() const {
    02167         return currentNode_;
    02168     }
    02170     inline CglTreeProbingInfo * probingInfo() const {
    02171         return probingInfo_;
    02172     }
    02174     inline CoinThreadRandom * randomNumberGenerator() {
    02175         return &randomNumberGenerator_;
    02176     }
    02178     inline void setNumberStrongIterations(int number) {
    02179         numberStrongIterations_ = number;
    02180     }
    02182     inline int numberStrongIterations() const {
    02183         return numberStrongIterations_;
    02184     }
    02186     inline int maximumNumberIterations() const {
    02187         return maximumNumberIterations_;
    02188     }
    02190     inline void setMaximumNumberIterations(int value) {
    02191         maximumNumberIterations_ = value;
    02192     }
    02193 # ifdef COIN_HAS_CLP
    02195     inline void setFastNodeDepth(int value) {
    02196         fastNodeDepth_ = value;
    02197     }
    02199     inline int fastNodeDepth() const {
    02200         return fastNodeDepth_;
    02201     }
    02203     inline int continuousPriority() const {
    02204         return continuousPriority_;
    02205     }
    02207     inline void setContinuousPriority(int value) {
    02208         continuousPriority_ = value;
    02209     }
    02210     inline void incrementExtra(int nodes, int iterations) {
    02211         numberExtraNodes_ += nodes;
    02212         numberExtraIterations_ += iterations;
    02213     }
    02214 #endif
    02216     inline int numberExtraIterations() const {
    02217         return numberExtraIterations_;
    02218     }
    02220     void incrementStrongInfo(int numberTimes, int numberIterations,
    02221                              int numberFixed, bool ifInfeasible);
    02223     inline const int * strongInfo() const {
    02224         return strongInfo_;
    02225     }
    02226
    02228     inline int * mutableStrongInfo() {
    02229         return strongInfo_;
    02230     }
    02232     CglStored * storedRowCuts() const {
    02233         return storedRowCuts_;
    02234     }
    02236     void setStoredRowCuts(CglStored * cuts) {
    02237         storedRowCuts_ = cuts;
    02238     }
    02240     inline bool allDynamic () const {
    02241         return ((ownership_&0x40000000) != 0) ;
    02242     }
    02244     void generateCpp( FILE * fp, int options);
    02246     OsiBranchingInformation usefulInformation() const;
    02253     inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) {
    02254         bestSolutionBasis_ = bestSolutionBasis;
    02255     }
    02257     void redoWalkBack();
    02259
    02260 //---------------------------------------------------------------------------
    02261
    02262 private:
    02264
    02265
    02267     OsiSolverInterface * solver_;
    02268
    02274     unsigned int ownership_ ;
    02275
    02277     OsiSolverInterface * continuousSolver_;
    02278
    02280     OsiSolverInterface * referenceSolver_;
    02281
    02283     CoinMessageHandler * handler_;
    02284
    02290     bool defaultHandler_;
    02291
    02293     CoinMessages messages_;
    02294
    02296     int intParam_[CbcLastIntParam];
    02297
    02299     double dblParam_[CbcLastDblParam];
    02300
    02309     mutable CoinWarmStart *emptyWarmStart_ ;
    02310
    02312     double bestObjective_;
    02314     double bestPossibleObjective_;
    02316     double sumChangeObjective1_;
    02318     double sumChangeObjective2_;
    02319
    02321     double * bestSolution_;
    02323     double ** savedSolutions_;
    02324
    02329     double * currentSolution_;
    02333     mutable const double * testSolution_;
    02340     CoinWarmStartBasis bestSolutionBasis_ ;
    02342     OsiCuts globalCuts_;
    02343
    02345     double minimumDrop_;
    02347     int numberSolutions_;
    02349     int numberSavedSolutions_;
    02351     int maximumSavedSolutions_;
    02358     int stateOfSearch_;
    02360     int whenCuts_;
    02362     double * hotstartSolution_;
    02364     int * hotstartPriorities_;
    02366     int numberHeuristicSolutions_;
    02368     int numberNodes_;
    02372     int numberNodes2_;
    02374     int numberIterations_;
    02376     int numberSolves_;
    02378     int status_;
    02389     int secondaryStatus_;
    02391     int numberIntegers_;
    02393     int numberRowsAtContinuous_;
    02395     int maximumNumberCuts_;
    02404     int phase_;
    02405
    02407     int currentNumberCuts_;
    02408
    02413     int maximumDepth_;
    02419     CbcNodeInfo ** walkback_;
    02420     CbcNodeInfo ** lastNodeInfo_;
    02421     const OsiRowCut ** lastCut_;
    02422     int lastDepth_;
    02423     int lastNumberCuts2_;
    02424     int maximumCuts_;
    02425     int * lastNumberCuts_;
    02426
    02434     CbcCountRowCut ** addedCuts_;
    02435
    02439     OsiRowCut * nextRowCut_;
    02440
    02442     CbcNode * currentNode_;
    02443
    02445     int * integerVariable_;
    02447     char * integerInfo_;
    02449     double * continuousSolution_;
    02451     int * usedInSolution_;
    02475     int specialOptions_;
    02490     int moreSpecialOptions_;
    02492     CbcCompareBase * nodeCompare_;
    02494     CbcFeasibilityBase * problemFeasibility_;
    02496     CbcTree * tree_;
    02498     CbcModel * subTreeModel_;
    02500     int numberStoppedSubTrees_;
    02502     CbcBranchDecision * branchingMethod_;
    02504     CbcCutModifier * cutModifier_;
    02506     CbcStrategy * strategy_;
    02508     CbcModel * parentModel_;
    02514
    02515     const double * cbcColLower_;
    02517     const double * cbcColUpper_;
    02519     const double * cbcRowLower_;
    02521     const double * cbcRowUpper_;
    02523     const double * cbcColSolution_;
    02525     const double * cbcRowPrice_;
    02527     const double * cbcReducedCost_;
    02529     const double * cbcRowActivity_;
    02531     void * appData_;
    02533     int presolve_;
    02537     int numberStrong_;
    02543     int numberBeforeTrust_;
    02547     int numberPenalties_;
    02549     int stopNumberIterations_;
    02552     double penaltyScaleFactor_;
    02554     int numberAnalyzeIterations_;
    02556     double * analyzeResults_;
    02558     int numberInfeasibleNodes_;
    02565     int problemType_;
    02567     int printFrequency_;
    02569     int numberCutGenerators_;
    02570     // Cut generators
    02571     CbcCutGenerator ** generator_;
    02572     // Cut generators before any changes
    02573     CbcCutGenerator ** virginGenerator_;
    02575     int numberHeuristics_;
    02577     CbcHeuristic ** heuristic_;
    02579     CbcHeuristic * lastHeuristic_;
    02581     int fastNodeDepth_;
    02583 # ifdef CBC_ONLY_CLP
    02584     ClpEventHandler *eventHandler_ ;
    02585 # else
    02586     CbcEventHandler *eventHandler_ ;
    02587 # endif
    02588
    02590     int numberObjects_;
    02591
    02602     OsiObject ** object_;
    02604     bool ownObjects_;
    02605
    02607     int * originalColumns_;
    02609     int howOftenGlobalScan_;
    02612     int numberGlobalViolations_;
    02614     int numberExtraIterations_;
    02616     int numberExtraNodes_;
    02620     double continuousObjective_;
    02623     double originalContinuousObjective_;
    02625     int continuousInfeasibilities_;
    02627     int maximumCutPassesAtRoot_;
    02629     int maximumCutPasses_;
    02631     int preferredWay_;
    02633     int currentPassNumber_;
    02635     int maximumWhich_;
    02637     int maximumRows_;
    02639     int currentDepth_;
    02641     mutable CoinThreadRandom randomNumberGenerator_;
    02643     CoinWarmStartBasis workingBasis_;
    02645     int * whichGenerator_;
    02647     int maximumStatistics_;
    02649     CbcStatistics ** statistics_;
    02651     int maximumDepthActual_;
    02653     double numberDJFixed_;
    02655     CglTreeProbingInfo * probingInfo_;
    02657     int numberFixedAtRoot_;
    02659     int numberFixedNow_;
    02661     bool stoppedOnGap_;
    02663     mutable bool eventHappened_;
    02665     int numberLongStrong_;
    02667     int numberOldActiveCuts_;
    02669     int numberNewCuts_;
    02671     int searchStrategy_;
    02673     int numberStrongIterations_;
    02676     int strongInfo_[7];
    02683     OsiBabSolver * solverCharacteristics_;
    02685     bool resolveAfterTakeOffCuts_;
    02687     int maximumNumberIterations_;
    02689     int continuousPriority_;
    02691     int numberUpdateItems_;
    02693     int maximumNumberUpdateItems_;
    02695     CbcObjectUpdateData * updateItems_;
    02697     CglStored * storedRowCuts_;
    02705     int numberThreads_;
    02713     int threadMode_;
    02715     CbcBaseModel * master_;
    02717     CbcThread * masterThread_;
    02719 };
    02721 void getIntegerInformation(const OsiObject * object, double & originalLower,
    02722                            double & originalUpper) ;
    02723 // So we can call from other programs
    02724 // Real main program
    02725 class OsiClpSolverInterface;
    02726 int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver);
    02727 int CbcMain (int argc, const char *argv[], CbcModel & babSolver);
    02728 // four ways of calling
    02729 int callCbc(const char * input2, OsiClpSolverInterface& solver1);
    02730 int callCbc(const char * input2);
    02731 int callCbc(const std::string input2, OsiClpSolverInterface& solver1);
    02732 int callCbc(const std::string input2) ;
    02733 // When we want to load up CbcModel with options first
    02734 void CbcMain0 (CbcModel & babSolver);
    02735 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
    02736 // two ways of calling
    02737 int callCbc(const char * input2, CbcModel & babSolver);
    02738 int callCbc(const std::string input2, CbcModel & babSolver);
    02739 // And when CbcMain0 already called to initialize
    02740 int callCbc1(const char * input2, CbcModel & babSolver);
    02741 int callCbc1(const std::string input2, CbcModel & babSolver);
    02742 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
    02743 int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    02744 int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    02745 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
    02746 // For uniform setting of cut and heuristic options
    02747 void setCutAndHeuristicOptions(CbcModel & model);
    02748 #endif
    02749

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines