00001
00002
00003
00004
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
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
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 {
00544
00545
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
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
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
01393 inline CbcCompareBase * nodeComparison() const {
01394 return nodeCompare_;
01395 }
01396 void setNodeComparison(CbcCompareBase * compare);
01397 void setNodeComparison(CbcCompareBase & compare);
01399
01402
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
02571 CbcCutGenerator ** generator_;
02572
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
02724
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
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
02734 void CbcMain0 (CbcModel & babSolver);
02735 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
02736
02737 int callCbc(const char * input2, CbcModel & babSolver);
02738 int callCbc(const std::string input2, CbcModel & babSolver);
02739
02740 int callCbc1(const char * input2, CbcModel & babSolver);
02741 int callCbc1(const std::string input2, CbcModel & babSolver);
02742
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
02747 void setCutAndHeuristicOptions(CbcModel & model);
02748 #endif
02749