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
01179 double checkSolution(double cutoff, double * solution,
01180 int fixVariables, double originalObjValue);
01187 bool feasibleSolution(int & numberIntegerInfeasibilities,
01188 int & numberObjectInfeasibilities) const;
01189
01195 inline double * currentSolution() const {
01196 return currentSolution_;
01197 }
01201 inline const double * testSolution() const {
01202 return testSolution_;
01203 }
01204 inline void setTestSolution(const double * solution) {
01205 testSolution_ = solution;
01206 }
01208 void reserveCurrentSolution(const double * solution = NULL);
01209
01211 inline const double * getColSolution() const {
01212 return solver_->getColSolution();
01213 }
01214
01216 inline const double * getRowPrice() const {
01217 return solver_->getRowPrice();
01218 }
01219
01221 inline const double * getReducedCost() const {
01222 return solver_->getReducedCost();
01223 }
01224
01226 inline const double * getRowActivity() const {
01227 return solver_->getRowActivity();
01228 }
01229
01231 inline double getCurrentObjValue() const {
01232 return dblParam_[CbcCurrentObjectiveValue];
01233 }
01235 inline double getCurrentMinimizationObjValue() const {
01236 return dblParam_[CbcCurrentMinimizationObjectiveValue];
01237 }
01238
01240 inline double getMinimizationObjValue() const {
01241 return bestObjective_;
01242 }
01244 inline void setMinimizationObjValue(double value) {
01245 bestObjective_ = value;
01246 }
01247
01249 inline double getObjValue() const {
01250 return bestObjective_ * solver_->getObjSense() ;
01251 }
01257 double getBestPossibleObjValue() const;
01259 inline void setObjValue(double value) {
01260 bestObjective_ = value * solver_->getObjSense() ;
01261 }
01263 inline double getSolverObjValue() const {
01264 return solver_->getObjValue() * solver_->getObjSense() ;
01265 }
01266
01273 inline double * bestSolution() const {
01274 return bestSolution_;
01275 }
01282 void setBestSolution(const double * solution, int numberColumns,
01283 double objectiveValue, bool check = false);
01284
01286 inline int getSolutionCount() const {
01287 return numberSolutions_;
01288 }
01289
01291 inline void setSolutionCount(int value) {
01292 numberSolutions_ = value;
01293 }
01295 int numberSavedSolutions() const;
01297 inline int maximumSavedSolutions() const {
01298 return maximumSavedSolutions_;
01299 }
01301 void setMaximumSavedSolutions(int value);
01303 const double * savedSolution(int which) const;
01305 double savedSolutionObjective(int which) const;
01306
01315 inline int phase() const {
01316 return phase_;
01317 }
01318
01320 inline int getNumberHeuristicSolutions() const {
01321 return numberHeuristicSolutions_;
01322 }
01324 inline void setNumberHeuristicSolutions(int value) {
01325 numberHeuristicSolutions_ = value;
01326 }
01327
01329 inline void setObjSense(double s) {
01330 dblParam_[CbcOptimizationDirection] = s;
01331 solver_->setObjSense(s);
01332 }
01333
01335 inline double getContinuousObjective() const {
01336 return originalContinuousObjective_;
01337 }
01338 inline void setContinuousObjective(double value) {
01339 originalContinuousObjective_ = value;
01340 }
01342 inline int getContinuousInfeasibilities() const {
01343 return continuousInfeasibilities_;
01344 }
01345 inline void setContinuousInfeasibilities(int value) {
01346 continuousInfeasibilities_ = value;
01347 }
01349 inline double rootObjectiveAfterCuts() const {
01350 return continuousObjective_;
01351 }
01353 inline double sumChangeObjective() const {
01354 return sumChangeObjective1_;
01355 }
01358 inline int numberGlobalViolations() const {
01359 return numberGlobalViolations_;
01360 }
01361 inline void clearNumberGlobalViolations() {
01362 numberGlobalViolations_ = 0;
01363 }
01365 inline bool resolveAfterTakeOffCuts() const {
01366 return resolveAfterTakeOffCuts_;
01367 }
01368 inline void setResolveAfterTakeOffCuts(bool yesNo) {
01369 resolveAfterTakeOffCuts_ = yesNo;
01370 }
01372 inline int maximumRows() const {
01373 return maximumRows_;
01374 }
01376 inline CoinWarmStartBasis & workingBasis() {
01377 return workingBasis_;
01378 }
01380 inline int getStopNumberIterations() const {
01381 return stopNumberIterations_;
01382 }
01384 inline void setStopNumberIterations(int value) {
01385 stopNumberIterations_ = value;
01386 }
01388
01391
01392 inline CbcCompareBase * nodeComparison() const {
01393 return nodeCompare_;
01394 }
01395 void setNodeComparison(CbcCompareBase * compare);
01396 void setNodeComparison(CbcCompareBase & compare);
01398
01401
01402 inline CbcFeasibilityBase * problemFeasibility() const {
01403 return problemFeasibility_;
01404 }
01405 void setProblemFeasibility(CbcFeasibilityBase * feasibility);
01406 void setProblemFeasibility(CbcFeasibilityBase & feasibility);
01408
01411
01412 inline CbcTree * tree() const {
01413 return tree_;
01414 }
01416 void passInTreeHandler(CbcTree & tree);
01420 void passInSubTreeModel(CbcModel & model);
01425 CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const;
01427 inline int numberStoppedSubTrees() const {
01428 return numberStoppedSubTrees_;
01429 }
01431 inline void incrementSubTreeStopped() {
01432 numberStoppedSubTrees_++;
01433 }
01439 inline int typePresolve() const {
01440 return presolve_;
01441 }
01442 inline void setTypePresolve(int value) {
01443 presolve_ = value;
01444 }
01445
01447
01453
01455 inline CbcBranchDecision * branchingMethod() const {
01456 return branchingMethod_;
01457 }
01459 inline void setBranchingMethod(CbcBranchDecision * method) {
01460 delete branchingMethod_;
01461 branchingMethod_ = method->clone();
01462 }
01467 inline void setBranchingMethod(CbcBranchDecision & method) {
01468 delete branchingMethod_;
01469 branchingMethod_ = method.clone();
01470 }
01472 inline CbcCutModifier * cutModifier() const {
01473 return cutModifier_;
01474 }
01476 void setCutModifier(CbcCutModifier * modifier);
01481 void setCutModifier(CbcCutModifier & modifier);
01483
01486
01493 inline int stateOfSearch() const {
01494 return stateOfSearch_;
01495 }
01496 inline void setStateOfSearch(int state) {
01497 stateOfSearch_ = state;
01498 }
01500 inline int searchStrategy() const {
01501 return searchStrategy_;
01502 }
01504 inline void setSearchStrategy(int value) {
01505 searchStrategy_ = value;
01506 }
01507
01509 inline int numberCutGenerators() const {
01510 return numberCutGenerators_;
01511 }
01513 inline CbcCutGenerator ** cutGenerators() const {
01514 return generator_;
01515 }
01517 inline CbcCutGenerator * cutGenerator(int i) const {
01518 return generator_[i];
01519 }
01521 inline CbcCutGenerator * virginCutGenerator(int i) const {
01522 return virginGenerator_[i];
01523 }
01532 void addCutGenerator(CglCutGenerator * generator,
01533 int howOften = 1, const char * name = NULL,
01534 bool normal = true, bool atSolution = false,
01535 bool infeasible = false, int howOftenInSub = -100,
01536 int whatDepth = -1, int whatDepthInSub = -1);
01538
01543
01545 inline CbcStrategy * strategy() const {
01546 return strategy_;
01547 }
01549 void setStrategy(CbcStrategy & strategy);
01551 inline void setStrategy(CbcStrategy * strategy) {
01552 strategy_ = strategy;
01553 }
01555 inline CbcModel * parentModel() const {
01556 return parentModel_;
01557 }
01559 inline void setParentModel(CbcModel & parentModel) {
01560 parentModel_ = &parentModel;
01561 }
01563
01564
01571 void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
01572 int before = -1);
01574 inline CbcHeuristic * heuristic(int i) const {
01575 return heuristic_[i];
01576 }
01578 inline int numberHeuristics() const {
01579 return numberHeuristics_;
01580 }
01582 inline CbcHeuristic * lastHeuristic() const {
01583 return lastHeuristic_;
01584 }
01586 inline void setLastHeuristic(CbcHeuristic * last) {
01587 lastHeuristic_ = last;
01588 }
01589
01608 void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);
01609
01611 inline int priority(int sequence) const {
01612 return object_[sequence]->priority();
01613 }
01614
01619 void passInEventHandler(const CbcEventHandler *eventHandler) ;
01620
01622 inline CbcEventHandler* getEventHandler() const {
01623 return (eventHandler_) ;
01624 }
01625
01627
01637 void setApplicationData (void * appData);
01638
01640 void * getApplicationData() const;
01653 void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
01655 inline const OsiBabSolver * solverCharacteristics() const {
01656 return solverCharacteristics_;
01657 }
01659
01660
01661
01664
01665 void passInMessageHandler(CoinMessageHandler * handler);
01667 void newLanguage(CoinMessages::Language language);
01668 inline void setLanguage(CoinMessages::Language language) {
01669 newLanguage(language);
01670 }
01672 inline CoinMessageHandler * messageHandler() const {
01673 return handler_;
01674 }
01676 inline CoinMessages & messages() {
01677 return messages_;
01678 }
01680 inline CoinMessages * messagesPointer() {
01681 return &messages_;
01682 }
01684 void setLogLevel(int value);
01686 inline int logLevel() const {
01687 return handler_->logLevel();
01688 }
01694 inline void setDefaultHandler(bool yesNo) {
01695 defaultHandler_ = yesNo;
01696 }
01698
01700
01701
01726 inline void setSpecialOptions(int value) {
01727 specialOptions_ = value;
01728 }
01730 inline int specialOptions() const {
01731 return specialOptions_;
01732 }
01734 inline void sayEventHappened()
01735 { eventHappened_=true;}
01737 inline bool normalSolver() const {
01738 return (specialOptions_&16) == 0;
01739 }
01744 inline bool waitingForMiniBranchAndBound() const {
01745 return (specialOptions_&1048576) != 0;
01746 }
01761 inline void setMoreSpecialOptions(int value) {
01762 moreSpecialOptions_ = value;
01763 }
01765 inline int moreSpecialOptions() const {
01766 return moreSpecialOptions_;
01767 }
01769 inline void setUseElapsedTime(bool yesNo) {
01770 if (yesNo)
01771 moreSpecialOptions_ |= 131072;
01772 else
01773 moreSpecialOptions_ &= ~131072;
01774 }
01776 inline bool useElapsedTime() const {
01777 return (moreSpecialOptions_&131072)!=0;
01778 }
01780 #ifdef COIN_HAS_CLP
01781 void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
01782 #endif
01784 inline bool ownObjects() const {
01785 return ownObjects_;
01786 }
01788 void checkModel();
01790
01791
01793
01794
01795 CbcModel();
01796
01798 CbcModel(const OsiSolverInterface &);
01799
01808 void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
01809
01821 inline void setModelOwnsSolver (bool ourSolver) {
01822 ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
01823 }
01824
01830 inline bool modelOwnsSolver () {
01831 return ((ownership_&0x80000000) != 0) ;
01832 }
01833
01837 CbcModel(const CbcModel & rhs, bool cloneHandler = false);
01838
01840 CbcModel & operator=(const CbcModel& rhs);
01841
01843 ~CbcModel ();
01844
01846 inline OsiSolverInterface * solver() const {
01847 return solver_;
01848 }
01849
01851 inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) {
01852 OsiSolverInterface * returnSolver = solver_;
01853 solver_ = solver;
01854 return returnSolver;
01855 }
01856
01858 inline OsiSolverInterface * continuousSolver() const {
01859 return continuousSolver_;
01860 }
01861
01863 inline void createContinuousSolver() {
01864 continuousSolver_ = solver_->clone();
01865 }
01867 inline void clearContinuousSolver() {
01868 delete continuousSolver_;
01869 continuousSolver_ = NULL;
01870 }
01871
01873 inline OsiSolverInterface * referenceSolver() const {
01874 return referenceSolver_;
01875 }
01876
01878 void saveReferenceSolver();
01879
01885 void resetToReferenceSolver();
01886
01888 void gutsOfDestructor();
01891 void gutsOfDestructor2();
01894 void resetModel();
01900 void gutsOfCopy(const CbcModel & rhs, int mode = 0);
01902 void moveInfo(const CbcModel & rhs);
01904
01906
01907
01908 static bool haveMultiThreadSupport();
01910 CbcThread * masterThread() const {
01911 return masterThread_;
01912 }
01914 CbcNodeInfo ** walkback() const {
01915 return walkback_;
01916 }
01918 inline int getNumberThreads() const {
01919 return numberThreads_;
01920 }
01922 inline void setNumberThreads(int value) {
01923 numberThreads_ = value;
01924 }
01926 inline int getThreadMode() const {
01927 return threadMode_;
01928 }
01938 inline void setThreadMode(int value) {
01939 threadMode_ = value;
01940 }
01947 inline int parallelMode() const {
01948 if (!numberThreads_) {
01949 if ((threadMode_&1) == 0)
01950 return 0;
01951 else
01952 return -1;
01953 return 0;
01954 } else {
01955 if ((threadMode_&1) == 0)
01956 return 1;
01957 else
01958 return -2;
01959 }
01960 }
01963 bool isLocked() const;
01964 #ifdef CBC_THREAD
01965
01969 void lockThread();
01973 void unlockThread();
01974 #else
01975 inline void lockThread() {}
01976 inline void unlockThread() {}
01977 #endif
01978
01985 void setInfoInChild(int type, CbcThread * info);
01992 void moveToModel(CbcModel * baseModel, int mode);
01994 int splitModel(int numberModels, CbcModel ** model,
01995 int numberNodes);
01997 void startSplitModel(int numberIterations);
01999 void mergeModels(int numberModel, CbcModel ** model,
02000 int numberNodes);
02002
02004
02005
02006 int getNodeCount2() const {
02007 return numberNodes2_;
02008 }
02010 void setPointers(const OsiSolverInterface * solver);
02016 int reducedCostFix() ;
02020 void synchronizeHandlers(int makeDefault);
02022 void saveExtraSolution(const double * solution, double objectiveValue);
02024 void saveBestSolution(const double * solution, double objectiveValue);
02026 void deleteSolutions();
02028 int resolve(OsiSolverInterface * solver);
02029 #ifdef CLP_RESOLVE
02031 int resolveClp(OsiClpSolverInterface * solver, int type);
02032 #endif
02033
02037 int chooseBranch(CbcNode * & newNode, int numberPassesLeft,
02038 CbcNode * oldNode, OsiCuts & cuts,
02039 bool & resolved, CoinWarmStartBasis *lastws,
02040 const double * lowerBefore, const double * upperBefore,
02041 OsiSolverBranch * & branches);
02042 int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);
02043
02050 CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;
02051
02063 int takeOffCuts(OsiCuts &cuts,
02064 bool allowResolve, OsiCuts * saveCuts,
02065 int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;
02066
02080 int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws, bool canFix);
02081
02098 bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
02102 void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn,
02103 double & lower, double & upper, int force);
02108 void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;
02109
02113 void convertToDynamic();
02115 void synchronizeNumberBeforeTrust(int type = 0);
02117 void zapIntegerInformation(bool leaveObjects = true);
02119 int cliquePseudoCosts(int doStatistics);
02121 void pseudoShadow(int type);
02128 void fillPseudoCosts(double * downCosts, double * upCosts,
02129 int * priority = NULL,
02130 int * numberDown = NULL, int * numberUp = NULL,
02131 int * numberDownInfeasible = NULL,
02132 int * numberUpInfeasible = NULL) const;
02138 void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
02140 void adjustHeuristics();
02142 inline const double * hotstartSolution() const {
02143 return hotstartSolution_;
02144 }
02146 inline const int * hotstartPriorities() const {
02147 return hotstartPriorities_;
02148 }
02149
02151 inline CbcCountRowCut ** addedCuts() const {
02152 return addedCuts_;
02153 }
02155 inline int currentNumberCuts() const {
02156 return currentNumberCuts_;
02157 }
02159 inline OsiCuts * globalCuts() {
02160 return &globalCuts_;
02161 }
02163 void setNextRowCut(const OsiRowCut & cut);
02165 inline CbcNode * currentNode() const {
02166 return currentNode_;
02167 }
02169 inline CglTreeProbingInfo * probingInfo() const {
02170 return probingInfo_;
02171 }
02173 inline CoinThreadRandom * randomNumberGenerator() {
02174 return &randomNumberGenerator_;
02175 }
02177 inline void setNumberStrongIterations(int number) {
02178 numberStrongIterations_ = number;
02179 }
02181 inline int numberStrongIterations() const {
02182 return numberStrongIterations_;
02183 }
02185 inline int maximumNumberIterations() const {
02186 return maximumNumberIterations_;
02187 }
02189 inline void setMaximumNumberIterations(int value) {
02190 maximumNumberIterations_ = value;
02191 }
02192 # ifdef COIN_HAS_CLP
02194 inline void setFastNodeDepth(int value) {
02195 fastNodeDepth_ = value;
02196 }
02198 inline int fastNodeDepth() const {
02199 return fastNodeDepth_;
02200 }
02202 inline int continuousPriority() const {
02203 return continuousPriority_;
02204 }
02206 inline void setContinuousPriority(int value) {
02207 continuousPriority_ = value;
02208 }
02209 inline void incrementExtra(int nodes, int iterations) {
02210 numberExtraNodes_ += nodes;
02211 numberExtraIterations_ += iterations;
02212 }
02213 #endif
02215 inline int numberExtraIterations() const {
02216 return numberExtraIterations_;
02217 }
02219 void incrementStrongInfo(int numberTimes, int numberIterations,
02220 int numberFixed, bool ifInfeasible);
02222 inline const int * strongInfo() const {
02223 return strongInfo_;
02224 }
02225
02227 inline int * mutableStrongInfo() {
02228 return strongInfo_;
02229 }
02231 CglStored * storedRowCuts() const {
02232 return storedRowCuts_;
02233 }
02235 void setStoredRowCuts(CglStored * cuts) {
02236 storedRowCuts_ = cuts;
02237 }
02239 inline bool allDynamic () const {
02240 return ((ownership_&0x40000000) != 0) ;
02241 }
02243 void generateCpp( FILE * fp, int options);
02245 OsiBranchingInformation usefulInformation() const;
02252 inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) {
02253 bestSolutionBasis_ = bestSolutionBasis;
02254 }
02256 void redoWalkBack();
02258
02259
02260
02261 private:
02263
02264
02266 OsiSolverInterface * solver_;
02267
02273 unsigned int ownership_ ;
02274
02276 OsiSolverInterface * continuousSolver_;
02277
02279 OsiSolverInterface * referenceSolver_;
02280
02282 CoinMessageHandler * handler_;
02283
02289 bool defaultHandler_;
02290
02292 CoinMessages messages_;
02293
02295 int intParam_[CbcLastIntParam];
02296
02298 double dblParam_[CbcLastDblParam];
02299
02308 mutable CoinWarmStart *emptyWarmStart_ ;
02309
02311 double bestObjective_;
02313 double bestPossibleObjective_;
02315 double sumChangeObjective1_;
02317 double sumChangeObjective2_;
02318
02320 double * bestSolution_;
02322 double ** savedSolutions_;
02323
02328 double * currentSolution_;
02332 mutable const double * testSolution_;
02339 CoinWarmStartBasis bestSolutionBasis_ ;
02341 OsiCuts globalCuts_;
02342
02344 double minimumDrop_;
02346 int numberSolutions_;
02348 int numberSavedSolutions_;
02350 int maximumSavedSolutions_;
02357 int stateOfSearch_;
02359 int whenCuts_;
02361 double * hotstartSolution_;
02363 int * hotstartPriorities_;
02365 int numberHeuristicSolutions_;
02367 int numberNodes_;
02371 int numberNodes2_;
02373 int numberIterations_;
02375 int numberSolves_;
02377 int status_;
02388 int secondaryStatus_;
02390 int numberIntegers_;
02392 int numberRowsAtContinuous_;
02394 int maximumNumberCuts_;
02403 int phase_;
02404
02406 int currentNumberCuts_;
02407
02412 int maximumDepth_;
02418 CbcNodeInfo ** walkback_;
02419 CbcNodeInfo ** lastNodeInfo_;
02420 const OsiRowCut ** lastCut_;
02421 int lastDepth_;
02422 int lastNumberCuts2_;
02423 int maximumCuts_;
02424 int * lastNumberCuts_;
02425
02433 CbcCountRowCut ** addedCuts_;
02434
02438 OsiRowCut * nextRowCut_;
02439
02441 CbcNode * currentNode_;
02442
02444 int * integerVariable_;
02446 char * integerInfo_;
02448 double * continuousSolution_;
02450 int * usedInSolution_;
02474 int specialOptions_;
02489 int moreSpecialOptions_;
02491 CbcCompareBase * nodeCompare_;
02493 CbcFeasibilityBase * problemFeasibility_;
02495 CbcTree * tree_;
02497 CbcModel * subTreeModel_;
02499 int numberStoppedSubTrees_;
02501 CbcBranchDecision * branchingMethod_;
02503 CbcCutModifier * cutModifier_;
02505 CbcStrategy * strategy_;
02507 CbcModel * parentModel_;
02513
02514 const double * cbcColLower_;
02516 const double * cbcColUpper_;
02518 const double * cbcRowLower_;
02520 const double * cbcRowUpper_;
02522 const double * cbcColSolution_;
02524 const double * cbcRowPrice_;
02526 const double * cbcReducedCost_;
02528 const double * cbcRowActivity_;
02530 void * appData_;
02532 int presolve_;
02536 int numberStrong_;
02542 int numberBeforeTrust_;
02546 int numberPenalties_;
02548 int stopNumberIterations_;
02551 double penaltyScaleFactor_;
02553 int numberAnalyzeIterations_;
02555 double * analyzeResults_;
02557 int numberInfeasibleNodes_;
02564 int problemType_;
02566 int printFrequency_;
02568 int numberCutGenerators_;
02569
02570 CbcCutGenerator ** generator_;
02571
02572 CbcCutGenerator ** virginGenerator_;
02574 int numberHeuristics_;
02576 CbcHeuristic ** heuristic_;
02578 CbcHeuristic * lastHeuristic_;
02580 int fastNodeDepth_;
02582 # ifdef CBC_ONLY_CLP
02583 ClpEventHandler *eventHandler_ ;
02584 # else
02585 CbcEventHandler *eventHandler_ ;
02586 # endif
02587
02589 int numberObjects_;
02590
02601 OsiObject ** object_;
02603 bool ownObjects_;
02604
02606 int * originalColumns_;
02608 int howOftenGlobalScan_;
02611 int numberGlobalViolations_;
02613 int numberExtraIterations_;
02615 int numberExtraNodes_;
02619 double continuousObjective_;
02622 double originalContinuousObjective_;
02624 int continuousInfeasibilities_;
02626 int maximumCutPassesAtRoot_;
02628 int maximumCutPasses_;
02630 int preferredWay_;
02632 int currentPassNumber_;
02634 int maximumWhich_;
02636 int maximumRows_;
02638 int currentDepth_;
02640 mutable CoinThreadRandom randomNumberGenerator_;
02642 CoinWarmStartBasis workingBasis_;
02644 int * whichGenerator_;
02646 int maximumStatistics_;
02648 CbcStatistics ** statistics_;
02650 int maximumDepthActual_;
02652 double numberDJFixed_;
02654 CglTreeProbingInfo * probingInfo_;
02656 int numberFixedAtRoot_;
02658 int numberFixedNow_;
02660 bool stoppedOnGap_;
02662 mutable bool eventHappened_;
02664 int numberLongStrong_;
02666 int numberOldActiveCuts_;
02668 int numberNewCuts_;
02670 int searchStrategy_;
02672 int numberStrongIterations_;
02675 int strongInfo_[7];
02682 OsiBabSolver * solverCharacteristics_;
02684 bool resolveAfterTakeOffCuts_;
02686 int maximumNumberIterations_;
02688 int continuousPriority_;
02690 int numberUpdateItems_;
02692 int maximumNumberUpdateItems_;
02694 CbcObjectUpdateData * updateItems_;
02696 CglStored * storedRowCuts_;
02704 int numberThreads_;
02712 int threadMode_;
02714 CbcBaseModel * master_;
02716 CbcThread * masterThread_;
02718 };
02720 void getIntegerInformation(const OsiObject * object, double & originalLower,
02721 double & originalUpper) ;
02722
02723
02724 class OsiClpSolverInterface;
02725 int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver);
02726 int CbcMain (int argc, const char *argv[], CbcModel & babSolver);
02727
02728 int callCbc(const char * input2, OsiClpSolverInterface& solver1);
02729 int callCbc(const char * input2);
02730 int callCbc(const std::string input2, OsiClpSolverInterface& solver1);
02731 int callCbc(const std::string input2) ;
02732
02733 void CbcMain0 (CbcModel & babSolver);
02734 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
02735
02736 int callCbc(const char * input2, CbcModel & babSolver);
02737 int callCbc(const std::string input2, CbcModel & babSolver);
02738
02739 int callCbc1(const char * input2, CbcModel & babSolver);
02740 int callCbc1(const std::string input2, CbcModel & babSolver);
02741
02742 int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
02743 int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
02744 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
02745
02746 void setCutAndHeuristicOptions(CbcModel & model);
02747 #endif
02748