Cbc
trunk
|
00001 /* $Id$ */ 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 "CbcCountRowCut.hpp" 00017 #include "CbcMessage.hpp" 00018 #include "CbcEventHandler.hpp" 00019 #include "ClpDualRowPivot.hpp" 00020 00021 00022 class CbcCutGenerator; 00023 class CbcBaseModel; 00024 class OsiRowCut; 00025 class OsiBabSolver; 00026 class OsiRowCutDebugger; 00027 class CglCutGenerator; 00028 class CglStored; 00029 class CbcCutModifier; 00030 class CglTreeProbingInfo; 00031 class CbcHeuristic; 00032 class OsiObject; 00033 class CbcThread; 00034 class CbcTree; 00035 class CbcStrategy; 00036 class CbcFeasibilityBase; 00037 class CbcStatistics; 00038 class CbcFullNodeInfo; 00039 class CbcEventHandler ; 00040 class CglPreProcess; 00041 # ifdef COIN_HAS_CLP 00042 class OsiClpSolverInterface; 00043 class ClpNodeStuff; 00044 #endif 00045 // #define CBC_CHECK_BASIS 1 00046 00047 //############################################################################# 00048 00101 class CbcModel { 00102 00103 public: 00104 00105 enum CbcIntParam { 00107 CbcMaxNumNode = 0, 00109 CbcMaxNumSol, 00119 CbcFathomDiscipline, 00123 CbcPrinting, 00126 CbcNumberBranches, 00128 CbcLastIntParam 00129 }; 00130 00131 enum CbcDblParam { 00134 CbcIntegerTolerance = 0, 00137 CbcInfeasibilityWeight, 00140 CbcCutoffIncrement, 00147 CbcAllowableGap, 00154 CbcAllowableFractionGap, 00157 CbcMaximumSeconds, 00159 CbcCurrentCutoff, 00161 CbcOptimizationDirection, 00163 CbcCurrentObjectiveValue, 00165 CbcCurrentMinimizationObjectiveValue, 00168 CbcStartSeconds, 00176 CbcHeuristicGap, 00184 CbcHeuristicFractionGap, 00186 CbcSmallestChange, 00188 CbcSumChange, 00190 CbcLargestChange, 00192 CbcSmallChange, 00194 CbcLastDblParam 00195 }; 00196 00197 //--------------------------------------------------------------------------- 00198 00199 public: 00201 00202 00206 void initialSolve(); 00207 00218 void branchAndBound(int doStatistics = 0); 00219 private: 00220 00228 bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node); 00236 int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts); 00244 int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts); 00251 CbcNode ** solveOneNode(int whichSolver, CbcNode * node, 00252 int & numberNodesOutput, int & status) ; 00254 void resizeWhichGenerator(int numberNow, int numberAfter); 00255 public: 00256 #ifdef CBC_KEEP_DEPRECATED 00257 // See if anyone is using these any more!! 00262 CbcModel * cleanModel(const double * lower, const double * upper); 00279 int subBranchAndBound(CbcModel * model2, 00280 CbcModel * presolvedModel, 00281 int maximumNodes); 00297 int subBranchAndBound(const double * lower, const double * upper, 00298 int maximumNodes); 00299 00306 OsiSolverInterface * strengthenedModel(); 00316 CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5, 00317 int tuning = 5); 00320 void postProcess(CglPreProcess * process); 00321 #endif 00322 00323 void addUpdateInformation(const CbcObjectUpdateData & data); 00330 int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode); 00331 00332 public: 00346 int resolve(CbcNodeInfo * parent, int whereFrom, 00347 double * saveSolution = NULL, 00348 double * saveLower = NULL, 00349 double * saveUpper = NULL); 00351 void makeGlobalCuts(int numberRows, const int * which); 00353 void makeGlobalCut(const OsiRowCut * cut); 00355 void makeGlobalCut(const OsiRowCut & cut); 00357 void makeGlobalCut(const OsiColCut * cut); 00359 void makeGlobalCut(const OsiColCut & cut); 00361 void makePartialCut(const OsiRowCut * cut); 00363 void makeGlobalCuts(); 00365 inline const int * whichGenerator() const 00366 { return whichGenerator_;} 00368 00371 00383 CbcModel * findCliques(bool makeEquality, int atLeastThisMany, 00384 int lessThanThis, int defaultValue = 1000); 00385 00394 CbcModel * integerPresolve(bool weak = false); 00395 00400 bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false); 00401 00402 00404 void originalModel(CbcModel * presolvedModel, bool weak); 00405 00426 bool tightenVubs(int type, bool allowMultipleBinary = false, 00427 double useCutoff = 1.0e50); 00428 00434 bool tightenVubs(int numberVubs, const int * which, 00435 double useCutoff = 1.0e50); 00439 void analyzeObjective(); 00440 00444 void AddIntegers(); 00445 00449 void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible); 00453 void flipModel(); 00454 00456 00462 00464 inline int numberObjects() const { 00465 return numberObjects_; 00466 } 00468 inline void setNumberObjects(int number) { 00469 numberObjects_ = number; 00470 } 00471 00473 inline OsiObject ** objects() const { 00474 return object_; 00475 } 00476 00478 const inline OsiObject * object(int which) const { 00479 return object_[which]; 00480 } 00482 inline OsiObject * modifiableObject(int which) const { 00483 return object_[which]; 00484 } 00485 00486 void setOptionalInteger(int index); 00487 00489 void deleteObjects(bool findIntegers = true); 00490 00495 void addObjects(int numberObjects, OsiObject ** objects); 00496 00501 void addObjects(int numberObjects, CbcObject ** objects); 00502 00504 void synchronizeModel() ; 00505 00515 void findIntegers(bool startAgain, int type = 0); 00516 00518 00519 //--------------------------------------------------------------------------- 00520 00530 00531 inline bool setIntParam(CbcIntParam key, int value) { 00532 intParam_[key] = value; 00533 return true; 00534 } 00536 inline bool setDblParam(CbcDblParam key, double value) { 00537 dblParam_[key] = value; 00538 return true; 00539 } 00541 inline int getIntParam(CbcIntParam key) const { 00542 return intParam_[key]; 00543 } 00545 inline double getDblParam(CbcDblParam key) const { 00546 return dblParam_[key]; 00547 } 00553 void setCutoff(double value) ; 00554 00556 inline double getCutoff() const { //double value ; 00557 //solver_->getDblParam(OsiDualObjectiveLimit,value) ; 00558 //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense()); 00559 return dblParam_[CbcCurrentCutoff]; 00560 } 00561 00563 inline bool setMaximumNodes( int value) { 00564 return setIntParam(CbcMaxNumNode, value); 00565 } 00566 00568 inline int getMaximumNodes() const { 00569 return getIntParam(CbcMaxNumNode); 00570 } 00571 00576 inline bool setMaximumSolutions( int value) { 00577 return setIntParam(CbcMaxNumSol, value); 00578 } 00583 inline int getMaximumSolutions() const { 00584 return getIntParam(CbcMaxNumSol); 00585 } 00587 inline bool setPrintingMode( int value) { 00588 return setIntParam(CbcPrinting, value); 00589 } 00590 00592 inline int getPrintingMode() const { 00593 return getIntParam(CbcPrinting); 00594 } 00595 00600 inline bool setMaximumSeconds( double value) { 00601 return setDblParam(CbcMaximumSeconds, value); 00602 } 00607 inline double getMaximumSeconds() const { 00608 return getDblParam(CbcMaximumSeconds); 00609 } 00611 double getCurrentSeconds() const ; 00612 00614 bool maximumSecondsReached() const ; 00615 00619 inline bool setIntegerTolerance( double value) { 00620 return setDblParam(CbcIntegerTolerance, value); 00621 } 00625 inline double getIntegerTolerance() const { 00626 return getDblParam(CbcIntegerTolerance); 00627 } 00628 00633 inline bool setInfeasibilityWeight( double value) { 00634 return setDblParam(CbcInfeasibilityWeight, value); 00635 } 00640 inline double getInfeasibilityWeight() const { 00641 return getDblParam(CbcInfeasibilityWeight); 00642 } 00643 00647 inline bool setAllowableGap( double value) { 00648 return setDblParam(CbcAllowableGap, value); 00649 } 00653 inline double getAllowableGap() const { 00654 return getDblParam(CbcAllowableGap); 00655 } 00656 00660 inline bool setAllowableFractionGap( double value) { 00661 return setDblParam(CbcAllowableFractionGap, value); 00662 } 00666 inline double getAllowableFractionGap() const { 00667 return getDblParam(CbcAllowableFractionGap); 00668 } 00672 inline bool setAllowablePercentageGap( double value) { 00673 return setDblParam(CbcAllowableFractionGap, value*0.01); 00674 } 00678 inline double getAllowablePercentageGap() const { 00679 return 100.0*getDblParam(CbcAllowableFractionGap); 00680 } 00684 inline bool setHeuristicGap( double value) { 00685 return setDblParam(CbcHeuristicGap, value); 00686 } 00690 inline double getHeuristicGap() const { 00691 return getDblParam(CbcHeuristicGap); 00692 } 00693 00697 inline bool setHeuristicFractionGap( double value) { 00698 return setDblParam(CbcHeuristicFractionGap, value); 00699 } 00703 inline double getHeuristicFractionGap() const { 00704 return getDblParam(CbcHeuristicFractionGap); 00705 } 00710 inline bool setCutoffIncrement( double value) { 00711 return setDblParam(CbcCutoffIncrement, value); 00712 } 00717 inline double getCutoffIncrement() const { 00718 return getDblParam(CbcCutoffIncrement); 00719 } 00721 bool canStopOnGap() const; 00722 00727 void setHotstartSolution(const double * solution, const int * priorities = NULL) ; 00728 00730 inline void setMinimumDrop(double value) { 00731 minimumDrop_ = value; 00732 } 00734 inline double getMinimumDrop() const { 00735 return minimumDrop_; 00736 } 00737 00740 inline void setMaximumCutPassesAtRoot(int value) { 00741 maximumCutPassesAtRoot_ = value; 00742 } 00744 inline int getMaximumCutPassesAtRoot() const { 00745 return maximumCutPassesAtRoot_; 00746 } 00747 00750 inline void setMaximumCutPasses(int value) { 00751 maximumCutPasses_ = value; 00752 } 00754 inline int getMaximumCutPasses() const { 00755 return maximumCutPasses_; 00756 } 00759 inline int getCurrentPassNumber() const { 00760 return currentPassNumber_; 00761 } 00762 00768 void setNumberStrong(int number); 00772 inline int numberStrong() const { 00773 return numberStrong_; 00774 } 00777 inline void setPreferredWay(int value) { 00778 preferredWay_ = value; 00779 } 00781 inline int getPreferredWay() const { 00782 return preferredWay_; 00783 } 00785 inline int whenCuts() const { 00786 return whenCuts_; 00787 } 00789 inline void setWhenCuts(int value) { 00790 whenCuts_ = value; 00791 } 00797 bool doCutsNow(int allowForTopOfTree) const; 00798 00804 void setNumberBeforeTrust(int number); 00807 inline int numberBeforeTrust() const { 00808 return numberBeforeTrust_; 00809 } 00815 void setNumberPenalties(int number); 00818 inline int numberPenalties() const { 00819 return numberPenalties_; 00820 } 00822 inline const CbcFullNodeInfo * topOfTree() const 00823 { return topOfTree_;} 00825 inline void setNumberAnalyzeIterations(int number) { 00826 numberAnalyzeIterations_ = number; 00827 } 00828 inline int numberAnalyzeIterations() const { 00829 return numberAnalyzeIterations_; 00830 } 00833 inline double penaltyScaleFactor() const { 00834 return penaltyScaleFactor_; 00835 } 00838 void setPenaltyScaleFactor(double value); 00846 void inline setProblemType(int number) { 00847 problemType_ = number; 00848 } 00849 inline int problemType() const { 00850 return problemType_; 00851 } 00853 inline int currentDepth() const { 00854 return currentDepth_; 00855 } 00856 00858 void setHowOftenGlobalScan(int number); 00860 inline int howOftenGlobalScan() const { 00861 return howOftenGlobalScan_; 00862 } 00864 inline int * originalColumns() const { 00865 return originalColumns_; 00866 } 00868 void setOriginalColumns(const int * originalColumns) ; 00869 00877 inline void setPrintFrequency(int number) { 00878 printFrequency_ = number; 00879 } 00881 inline int printFrequency() const { 00882 return printFrequency_; 00883 } 00885 00886 //--------------------------------------------------------------------------- 00888 00889 00890 bool isAbandoned() const; 00892 bool isProvenOptimal() const; 00894 bool isProvenInfeasible() const; 00896 bool isContinuousUnbounded() const; 00898 bool isProvenDualInfeasible() const; 00900 bool isNodeLimitReached() const; 00902 bool isSecondsLimitReached() const; 00904 bool isSolutionLimitReached() const; 00906 inline int getIterationCount() const { 00907 return numberIterations_; 00908 } 00910 inline void incrementIterationCount(int value) { 00911 numberIterations_ += value; 00912 } 00914 inline int getNodeCount() const { 00915 return numberNodes_; 00916 } 00918 inline void incrementNodeCount(int value) { 00919 numberNodes_ += value; 00920 } 00922 inline int getExtraNodeCount() const { 00923 return numberExtraNodes_; 00924 } 00934 inline int status() const { 00935 return status_; 00936 } 00937 inline void setProblemStatus(int value) { 00938 status_ = value; 00939 } 00952 inline int secondaryStatus() const { 00953 return secondaryStatus_; 00954 } 00955 inline void setSecondaryStatus(int value) { 00956 secondaryStatus_ = value; 00957 } 00959 bool isInitialSolveAbandoned() const ; 00961 bool isInitialSolveProvenOptimal() const ; 00963 bool isInitialSolveProvenPrimalInfeasible() const ; 00965 bool isInitialSolveProvenDualInfeasible() const ; 00966 00968 00969 //--------------------------------------------------------------------------- 00982 00983 inline int numberRowsAtContinuous() const { 00984 return numberRowsAtContinuous_; 00985 } 00986 00988 inline int getNumCols() const { 00989 return solver_->getNumCols(); 00990 } 00991 00993 inline int getNumRows() const { 00994 return solver_->getNumRows(); 00995 } 00996 00998 inline CoinBigIndex getNumElements() const { 00999 return solver_->getNumElements(); 01000 } 01001 01003 inline int numberIntegers() const { 01004 return numberIntegers_; 01005 } 01006 // Integer variables 01007 inline const int * integerVariable() const { 01008 return integerVariable_; 01009 } 01011 inline char integerType(int i) const { 01012 assert (integerInfo_); 01013 assert (integerInfo_[i] == 0 || integerInfo_[i] == 1); 01014 return integerInfo_[i]; 01015 } 01017 inline const char * integerType() const { 01018 return integerInfo_; 01019 } 01020 01022 inline const double * getColLower() const { 01023 return solver_->getColLower(); 01024 } 01025 01027 inline const double * getColUpper() const { 01028 return solver_->getColUpper(); 01029 } 01030 01040 inline const char * getRowSense() const { 01041 return solver_->getRowSense(); 01042 } 01043 01052 inline const double * getRightHandSide() const { 01053 return solver_->getRightHandSide(); 01054 } 01055 01064 inline const double * getRowRange() const { 01065 return solver_->getRowRange(); 01066 } 01067 01069 inline const double * getRowLower() const { 01070 return solver_->getRowLower(); 01071 } 01072 01074 inline const double * getRowUpper() const { 01075 return solver_->getRowUpper(); 01076 } 01077 01079 inline const double * getObjCoefficients() const { 01080 return solver_->getObjCoefficients(); 01081 } 01082 01084 inline double getObjSense() const { 01085 //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense()); 01086 return dblParam_[CbcOptimizationDirection]; 01087 } 01088 01090 inline bool isContinuous(int colIndex) const { 01091 return solver_->isContinuous(colIndex); 01092 } 01093 01095 inline bool isBinary(int colIndex) const { 01096 return solver_->isBinary(colIndex); 01097 } 01098 01103 inline bool isInteger(int colIndex) const { 01104 return solver_->isInteger(colIndex); 01105 } 01106 01108 inline bool isIntegerNonBinary(int colIndex) const { 01109 return solver_->isIntegerNonBinary(colIndex); 01110 } 01111 01113 inline bool isFreeBinary(int colIndex) const { 01114 return solver_->isFreeBinary(colIndex) ; 01115 } 01116 01118 inline const CoinPackedMatrix * getMatrixByRow() const { 01119 return solver_->getMatrixByRow(); 01120 } 01121 01123 inline const CoinPackedMatrix * getMatrixByCol() const { 01124 return solver_->getMatrixByCol(); 01125 } 01126 01128 inline double getInfinity() const { 01129 return solver_->getInfinity(); 01130 } 01132 inline const double * getCbcColLower() const { 01133 return cbcColLower_; 01134 } 01136 inline const double * getCbcColUpper() const { 01137 return cbcColUpper_; 01138 } 01140 inline const double * getCbcRowLower() const { 01141 return cbcRowLower_; 01142 } 01144 inline const double * getCbcRowUpper() const { 01145 return cbcRowUpper_; 01146 } 01148 inline const double * getCbcColSolution() const { 01149 return cbcColSolution_; 01150 } 01152 inline const double * getCbcRowPrice() const { 01153 return cbcRowPrice_; 01154 } 01156 inline const double * getCbcReducedCost() const { 01157 return cbcReducedCost_; 01158 } 01160 inline const double * getCbcRowActivity() const { 01161 return cbcRowActivity_; 01162 } 01164 01165 01168 01169 inline double * continuousSolution() const { 01170 return continuousSolution_; 01171 } 01176 inline int * usedInSolution() const { 01177 return usedInSolution_; 01178 } 01180 void incrementUsed(const double * solution); 01182 void setBestSolution(CBC_Message how, 01183 double & objectiveValue, const double *solution, 01184 int fixVariables = 0); 01186 void setBestObjectiveValue( double objectiveValue); 01188 CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event, 01189 double objValue, 01190 const double * solution); 01191 01199 virtual double checkSolution(double cutoff, double * solution, 01200 int fixVariables, double originalObjValue); 01207 bool feasibleSolution(int & numberIntegerInfeasibilities, 01208 int & numberObjectInfeasibilities) const; 01209 01215 inline double * currentSolution() const { 01216 return currentSolution_; 01217 } 01221 inline const double * testSolution() const { 01222 return testSolution_; 01223 } 01224 inline void setTestSolution(const double * solution) { 01225 testSolution_ = solution; 01226 } 01228 void reserveCurrentSolution(const double * solution = NULL); 01229 01231 inline const double * getColSolution() const { 01232 return solver_->getColSolution(); 01233 } 01234 01236 inline const double * getRowPrice() const { 01237 return solver_->getRowPrice(); 01238 } 01239 01241 inline const double * getReducedCost() const { 01242 return solver_->getReducedCost(); 01243 } 01244 01246 inline const double * getRowActivity() const { 01247 return solver_->getRowActivity(); 01248 } 01249 01251 inline double getCurrentObjValue() const { 01252 return dblParam_[CbcCurrentObjectiveValue]; 01253 } 01255 inline double getCurrentMinimizationObjValue() const { 01256 return dblParam_[CbcCurrentMinimizationObjectiveValue]; 01257 } 01258 01260 inline double getMinimizationObjValue() const { 01261 return bestObjective_; 01262 } 01264 inline void setMinimizationObjValue(double value) { 01265 bestObjective_ = value; 01266 } 01267 01269 inline double getObjValue() const { 01270 return bestObjective_ * solver_->getObjSense() ; 01271 } 01277 double getBestPossibleObjValue() const; 01279 inline void setObjValue(double value) { 01280 bestObjective_ = value * solver_->getObjSense() ; 01281 } 01283 inline double getSolverObjValue() const { 01284 return solver_->getObjValue() * solver_->getObjSense() ; 01285 } 01286 01293 inline double * bestSolution() const { 01294 return bestSolution_; 01295 } 01302 void setBestSolution(const double * solution, int numberColumns, 01303 double objectiveValue, bool check = false); 01304 01306 inline int getSolutionCount() const { 01307 return numberSolutions_; 01308 } 01309 01311 inline void setSolutionCount(int value) { 01312 numberSolutions_ = value; 01313 } 01315 int numberSavedSolutions() const; 01317 inline int maximumSavedSolutions() const { 01318 return maximumSavedSolutions_; 01319 } 01321 void setMaximumSavedSolutions(int value); 01323 const double * savedSolution(int which) const; 01325 double savedSolutionObjective(int which) const; 01327 void deleteSavedSolution(int which); 01328 01337 inline int phase() const { 01338 return phase_; 01339 } 01340 01342 inline int getNumberHeuristicSolutions() const { 01343 return numberHeuristicSolutions_; 01344 } 01346 inline void setNumberHeuristicSolutions(int value) { 01347 numberHeuristicSolutions_ = value; 01348 } 01349 01351 inline void setObjSense(double s) { 01352 dblParam_[CbcOptimizationDirection] = s; 01353 solver_->setObjSense(s); 01354 } 01355 01357 inline double getContinuousObjective() const { 01358 return originalContinuousObjective_; 01359 } 01360 inline void setContinuousObjective(double value) { 01361 originalContinuousObjective_ = value; 01362 } 01364 inline int getContinuousInfeasibilities() const { 01365 return continuousInfeasibilities_; 01366 } 01367 inline void setContinuousInfeasibilities(int value) { 01368 continuousInfeasibilities_ = value; 01369 } 01371 inline double rootObjectiveAfterCuts() const { 01372 return continuousObjective_; 01373 } 01375 inline double sumChangeObjective() const { 01376 return sumChangeObjective1_; 01377 } 01380 inline int numberGlobalViolations() const { 01381 return numberGlobalViolations_; 01382 } 01383 inline void clearNumberGlobalViolations() { 01384 numberGlobalViolations_ = 0; 01385 } 01387 inline bool resolveAfterTakeOffCuts() const { 01388 return resolveAfterTakeOffCuts_; 01389 } 01390 inline void setResolveAfterTakeOffCuts(bool yesNo) { 01391 resolveAfterTakeOffCuts_ = yesNo; 01392 } 01394 inline int maximumRows() const { 01395 return maximumRows_; 01396 } 01398 inline CoinWarmStartBasis & workingBasis() { 01399 return workingBasis_; 01400 } 01402 inline int getStopNumberIterations() const { 01403 return stopNumberIterations_; 01404 } 01406 inline void setStopNumberIterations(int value) { 01407 stopNumberIterations_ = value; 01408 } 01410 inline CbcModel * heuristicModel() const 01411 { return heuristicModel_;} 01413 inline void setHeuristicModel(CbcModel * model) 01414 { heuristicModel_ = model;} 01416 01419 // Comparison functions (which may be overridden by inheritance) 01420 inline CbcCompareBase * nodeComparison() const { 01421 return nodeCompare_; 01422 } 01423 void setNodeComparison(CbcCompareBase * compare); 01424 void setNodeComparison(CbcCompareBase & compare); 01426 01429 // Feasibility functions (which may be overridden by inheritance) 01430 inline CbcFeasibilityBase * problemFeasibility() const { 01431 return problemFeasibility_; 01432 } 01433 void setProblemFeasibility(CbcFeasibilityBase * feasibility); 01434 void setProblemFeasibility(CbcFeasibilityBase & feasibility); 01436 01439 01440 inline CbcTree * tree() const { 01441 return tree_; 01442 } 01444 void passInTreeHandler(CbcTree & tree); 01448 void passInSubTreeModel(CbcModel & model); 01453 CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const; 01455 inline int numberStoppedSubTrees() const { 01456 return numberStoppedSubTrees_; 01457 } 01459 inline void incrementSubTreeStopped() { 01460 numberStoppedSubTrees_++; 01461 } 01467 inline int typePresolve() const { 01468 return presolve_; 01469 } 01470 inline void setTypePresolve(int value) { 01471 presolve_ = value; 01472 } 01473 01475 01481 01483 inline CbcBranchDecision * branchingMethod() const { 01484 return branchingMethod_; 01485 } 01487 inline void setBranchingMethod(CbcBranchDecision * method) { 01488 delete branchingMethod_; 01489 branchingMethod_ = method->clone(); 01490 } 01495 inline void setBranchingMethod(CbcBranchDecision & method) { 01496 delete branchingMethod_; 01497 branchingMethod_ = method.clone(); 01498 } 01500 inline CbcCutModifier * cutModifier() const { 01501 return cutModifier_; 01502 } 01504 void setCutModifier(CbcCutModifier * modifier); 01509 void setCutModifier(CbcCutModifier & modifier); 01511 01514 01521 inline int stateOfSearch() const { 01522 return stateOfSearch_; 01523 } 01524 inline void setStateOfSearch(int state) { 01525 stateOfSearch_ = state; 01526 } 01528 inline int searchStrategy() const { 01529 return searchStrategy_; 01530 } 01532 inline void setSearchStrategy(int value) { 01533 searchStrategy_ = value; 01534 } 01536 inline int strongStrategy() const { 01537 return strongStrategy_; 01538 } 01540 inline void setStrongStrategy(int value) { 01541 strongStrategy_ = value; 01542 } 01543 01545 inline int numberCutGenerators() const { 01546 return numberCutGenerators_; 01547 } 01549 inline CbcCutGenerator ** cutGenerators() const { 01550 return generator_; 01551 } 01553 inline CbcCutGenerator * cutGenerator(int i) const { 01554 return generator_[i]; 01555 } 01557 inline CbcCutGenerator * virginCutGenerator(int i) const { 01558 return virginGenerator_[i]; 01559 } 01568 void addCutGenerator(CglCutGenerator * generator, 01569 int howOften = 1, const char * name = NULL, 01570 bool normal = true, bool atSolution = false, 01571 bool infeasible = false, int howOftenInSub = -100, 01572 int whatDepth = -1, int whatDepthInSub = -1); 01574 01579 01581 inline CbcStrategy * strategy() const { 01582 return strategy_; 01583 } 01585 void setStrategy(CbcStrategy & strategy); 01587 inline void setStrategy(CbcStrategy * strategy) { 01588 strategy_ = strategy; 01589 } 01591 inline CbcModel * parentModel() const { 01592 return parentModel_; 01593 } 01595 inline void setParentModel(CbcModel & parentModel) { 01596 parentModel_ = &parentModel; 01597 } 01599 01600 01607 void addHeuristic(CbcHeuristic * generator, const char *name = NULL, 01608 int before = -1); 01610 inline CbcHeuristic * heuristic(int i) const { 01611 return heuristic_[i]; 01612 } 01614 inline int numberHeuristics() const { 01615 return numberHeuristics_; 01616 } 01618 inline void setNumberHeuristics(int value) { 01619 numberHeuristics_ = value; 01620 } 01622 inline CbcHeuristic * lastHeuristic() const { 01623 return lastHeuristic_; 01624 } 01626 inline void setLastHeuristic(CbcHeuristic * last) { 01627 lastHeuristic_ = last; 01628 } 01629 01648 void passInPriorities(const int * priorities, bool ifNotSimpleIntegers); 01649 01651 inline int priority(int sequence) const { 01652 return object_[sequence]->priority(); 01653 } 01654 01659 void passInEventHandler(const CbcEventHandler *eventHandler) ; 01660 01662 inline CbcEventHandler* getEventHandler() const { 01663 return (eventHandler_) ; 01664 } 01665 01667 01677 void setApplicationData (void * appData); 01678 01680 void * getApplicationData() const; 01693 void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics); 01695 inline const OsiBabSolver * solverCharacteristics() const { 01696 return solverCharacteristics_; 01697 } 01699 01700 //--------------------------------------------------------------------------- 01701 01704 01705 void passInMessageHandler(CoinMessageHandler * handler); 01707 void newLanguage(CoinMessages::Language language); 01708 inline void setLanguage(CoinMessages::Language language) { 01709 newLanguage(language); 01710 } 01712 inline CoinMessageHandler * messageHandler() const { 01713 return handler_; 01714 } 01716 inline CoinMessages & messages() { 01717 return messages_; 01718 } 01720 inline CoinMessages * messagesPointer() { 01721 return &messages_; 01722 } 01724 void setLogLevel(int value); 01726 inline int logLevel() const { 01727 return handler_->logLevel(); 01728 } 01734 inline void setDefaultHandler(bool yesNo) { 01735 defaultHandler_ = yesNo; 01736 } 01738 //--------------------------------------------------------------------------- 01740 01741 01768 inline void setSpecialOptions(int value) { 01769 specialOptions_ = value; 01770 } 01772 inline int specialOptions() const { 01773 return specialOptions_; 01774 } 01776 inline void setRandomSeed(int value) { 01777 randomSeed_ = value; 01778 } 01780 inline int getRandomSeed() const { 01781 return randomSeed_; 01782 } 01784 inline void setMultipleRootTries(int value) { 01785 multipleRootTries_ = value; 01786 } 01788 inline int getMultipleRootTries() const { 01789 return multipleRootTries_; 01790 } 01792 inline void sayEventHappened() 01793 { eventHappened_=true;} 01795 inline bool normalSolver() const { 01796 return (specialOptions_&16) == 0; 01797 } 01802 inline bool waitingForMiniBranchAndBound() const { 01803 return (specialOptions_&1048576) != 0; 01804 } 01822 inline void setMoreSpecialOptions(int value) { 01823 moreSpecialOptions_ = value; 01824 } 01826 inline int moreSpecialOptions() const { 01827 return moreSpecialOptions_; 01828 } 01830 inline void setUseElapsedTime(bool yesNo) { 01831 if (yesNo) 01832 moreSpecialOptions_ |= 131072; 01833 else 01834 moreSpecialOptions_ &= ~131072; 01835 } 01837 inline bool useElapsedTime() const { 01838 return (moreSpecialOptions_&131072)!=0; 01839 } 01841 #ifdef COIN_HAS_CLP 01842 void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod); 01843 #endif 01844 01845 inline bool ownObjects() const { 01846 return ownObjects_; 01847 } 01849 void checkModel(); 01851 //--------------------------------------------------------------------------- 01852 01854 01855 01856 CbcModel(); 01857 01859 CbcModel(const OsiSolverInterface &); 01860 01869 void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true); 01870 01882 inline void setModelOwnsSolver (bool ourSolver) { 01883 ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ; 01884 } 01885 01891 inline bool modelOwnsSolver () { 01892 return ((ownership_&0x80000000) != 0) ; 01893 } 01894 01898 CbcModel(const CbcModel & rhs, bool cloneHandler = false); 01899 01901 CbcModel & operator=(const CbcModel& rhs); 01902 01904 virtual ~CbcModel (); 01905 01907 inline OsiSolverInterface * solver() const { 01908 return solver_; 01909 } 01910 01912 inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) { 01913 OsiSolverInterface * returnSolver = solver_; 01914 solver_ = solver; 01915 return returnSolver; 01916 } 01917 01919 inline OsiSolverInterface * continuousSolver() const { 01920 return continuousSolver_; 01921 } 01922 01924 inline void createContinuousSolver() { 01925 continuousSolver_ = solver_->clone(); 01926 } 01928 inline void clearContinuousSolver() { 01929 delete continuousSolver_; 01930 continuousSolver_ = NULL; 01931 } 01932 01934 inline OsiSolverInterface * referenceSolver() const { 01935 return referenceSolver_; 01936 } 01937 01939 void saveReferenceSolver(); 01940 01946 void resetToReferenceSolver(); 01947 01949 void gutsOfDestructor(); 01952 void gutsOfDestructor2(); 01955 void resetModel(); 01961 void gutsOfCopy(const CbcModel & rhs, int mode = 0); 01963 void moveInfo(const CbcModel & rhs); 01965 01967 01968 01969 static bool haveMultiThreadSupport(); 01971 CbcThread * masterThread() const { 01972 return masterThread_; 01973 } 01975 CbcNodeInfo ** walkback() const { 01976 return walkback_; 01977 } 01979 inline int getNumberThreads() const { 01980 return numberThreads_; 01981 } 01983 inline void setNumberThreads(int value) { 01984 numberThreads_ = value; 01985 } 01987 inline int getThreadMode() const { 01988 return threadMode_; 01989 } 01999 inline void setThreadMode(int value) { 02000 threadMode_ = value; 02001 } 02008 inline int parallelMode() const { 02009 if (!numberThreads_) { 02010 if ((threadMode_&1) == 0) 02011 return 0; 02012 else 02013 return -1; 02014 return 0; 02015 } else { 02016 if ((threadMode_&1) == 0) 02017 return 1; 02018 else 02019 return -2; 02020 } 02021 } 02024 bool isLocked() const; 02025 #ifdef CBC_THREAD 02026 02030 void lockThread(); 02034 void unlockThread(); 02035 #else 02036 inline void lockThread() {} 02037 inline void unlockThread() {} 02038 #endif 02039 02046 void setInfoInChild(int type, CbcThread * info); 02053 void moveToModel(CbcModel * baseModel, int mode); 02055 int splitModel(int numberModels, CbcModel ** model, 02056 int numberNodes); 02058 void startSplitModel(int numberIterations); 02060 void mergeModels(int numberModel, CbcModel ** model, 02061 int numberNodes); 02063 02065 02066 02067 int getNodeCount2() const { 02068 return numberNodes2_; 02069 } 02071 void setPointers(const OsiSolverInterface * solver); 02077 int reducedCostFix() ; 02081 void synchronizeHandlers(int makeDefault); 02083 void saveExtraSolution(const double * solution, double objectiveValue); 02085 void saveBestSolution(const double * solution, double objectiveValue); 02087 void deleteSolutions(); 02089 int resolve(OsiSolverInterface * solver); 02090 #ifdef CLP_RESOLVE 02091 02092 int resolveClp(OsiClpSolverInterface * solver, int type); 02093 #endif 02094 02098 int chooseBranch(CbcNode * & newNode, int numberPassesLeft, 02099 CbcNode * oldNode, OsiCuts & cuts, 02100 bool & resolved, CoinWarmStartBasis *lastws, 02101 const double * lowerBefore, const double * upperBefore, 02102 OsiSolverBranch * & branches); 02103 int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved); 02104 02111 CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ; 02112 02124 int takeOffCuts(OsiCuts &cuts, 02125 bool allowResolve, OsiCuts * saveCuts, 02126 int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ; 02127 02141 int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws, bool canFix); 02142 02159 bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws); 02163 void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn, 02164 double & lower, double & upper, int force); 02169 void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const; 02170 02174 void convertToDynamic(); 02176 void synchronizeNumberBeforeTrust(int type = 0); 02178 void zapIntegerInformation(bool leaveObjects = true); 02180 int cliquePseudoCosts(int doStatistics); 02182 void pseudoShadow(int type); 02189 void fillPseudoCosts(double * downCosts, double * upCosts, 02190 int * priority = NULL, 02191 int * numberDown = NULL, int * numberUp = NULL, 02192 int * numberDownInfeasible = NULL, 02193 int * numberUpInfeasible = NULL) const; 02199 void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0); 02201 void adjustHeuristics(); 02203 inline const double * hotstartSolution() const { 02204 return hotstartSolution_; 02205 } 02207 inline const int * hotstartPriorities() const { 02208 return hotstartPriorities_; 02209 } 02210 02212 inline CbcCountRowCut ** addedCuts() const { 02213 return addedCuts_; 02214 } 02216 inline int currentNumberCuts() const { 02217 return currentNumberCuts_; 02218 } 02220 inline CbcRowCuts * globalCuts() { 02221 return &globalCuts_; 02222 } 02224 void setNextRowCut(const OsiRowCut & cut); 02226 inline CbcNode * currentNode() const { 02227 return currentNode_; 02228 } 02230 inline CglTreeProbingInfo * probingInfo() const { 02231 return probingInfo_; 02232 } 02234 inline CoinThreadRandom * randomNumberGenerator() { 02235 return &randomNumberGenerator_; 02236 } 02238 inline void setNumberStrongIterations(int number) { 02239 numberStrongIterations_ = number; 02240 } 02242 inline int numberStrongIterations() const { 02243 return numberStrongIterations_; 02244 } 02246 inline int maximumNumberIterations() const { 02247 return maximumNumberIterations_; 02248 } 02250 inline void setMaximumNumberIterations(int value) { 02251 maximumNumberIterations_ = value; 02252 } 02253 # ifdef COIN_HAS_CLP 02254 02255 inline void setFastNodeDepth(int value) { 02256 fastNodeDepth_ = value; 02257 } 02259 inline int fastNodeDepth() const { 02260 return fastNodeDepth_; 02261 } 02263 inline int continuousPriority() const { 02264 return continuousPriority_; 02265 } 02267 inline void setContinuousPriority(int value) { 02268 continuousPriority_ = value; 02269 } 02270 inline void incrementExtra(int nodes, int iterations) { 02271 numberExtraNodes_ += nodes; 02272 numberExtraIterations_ += iterations; 02273 } 02274 #endif 02275 02276 inline int numberExtraIterations() const { 02277 return numberExtraIterations_; 02278 } 02280 void incrementStrongInfo(int numberTimes, int numberIterations, 02281 int numberFixed, bool ifInfeasible); 02283 inline const int * strongInfo() const { 02284 return strongInfo_; 02285 } 02286 02288 inline int * mutableStrongInfo() { 02289 return strongInfo_; 02290 } 02292 CglStored * storedRowCuts() const { 02293 return storedRowCuts_; 02294 } 02296 void setStoredRowCuts(CglStored * cuts) { 02297 storedRowCuts_ = cuts; 02298 } 02300 inline bool allDynamic () const { 02301 return ((ownership_&0x40000000) != 0) ; 02302 } 02304 void generateCpp( FILE * fp, int options); 02306 OsiBranchingInformation usefulInformation() const; 02313 inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) { 02314 bestSolutionBasis_ = bestSolutionBasis; 02315 } 02317 void redoWalkBack(); 02319 02320 //--------------------------------------------------------------------------- 02321 02322 private: 02324 02325 02327 OsiSolverInterface * solver_; 02328 02334 unsigned int ownership_ ; 02335 02337 OsiSolverInterface * continuousSolver_; 02338 02340 OsiSolverInterface * referenceSolver_; 02341 02343 CoinMessageHandler * handler_; 02344 02350 bool defaultHandler_; 02351 02353 CoinMessages messages_; 02354 02356 int intParam_[CbcLastIntParam]; 02357 02359 double dblParam_[CbcLastDblParam]; 02360 02369 mutable CoinWarmStart *emptyWarmStart_ ; 02370 02372 double bestObjective_; 02374 double bestPossibleObjective_; 02376 double sumChangeObjective1_; 02378 double sumChangeObjective2_; 02379 02381 double * bestSolution_; 02383 double ** savedSolutions_; 02384 02389 double * currentSolution_; 02393 mutable const double * testSolution_; 02400 CoinWarmStartBasis bestSolutionBasis_ ; 02402 CbcRowCuts globalCuts_; 02404 CbcRowCuts * globalConflictCuts_; 02405 02407 double minimumDrop_; 02409 int numberSolutions_; 02411 int numberSavedSolutions_; 02413 int maximumSavedSolutions_; 02420 int stateOfSearch_; 02422 int whenCuts_; 02424 double * hotstartSolution_; 02426 int * hotstartPriorities_; 02428 int numberHeuristicSolutions_; 02430 int numberNodes_; 02434 int numberNodes2_; 02436 int numberIterations_; 02438 int numberSolves_; 02440 int status_; 02451 int secondaryStatus_; 02453 int numberIntegers_; 02455 int numberRowsAtContinuous_; 02457 int maximumNumberCuts_; 02466 int phase_; 02467 02469 int currentNumberCuts_; 02470 02475 int maximumDepth_; 02481 CbcNodeInfo ** walkback_; 02482 CbcNodeInfo ** lastNodeInfo_; 02483 const OsiRowCut ** lastCut_; 02484 int lastDepth_; 02485 int lastNumberCuts2_; 02486 int maximumCuts_; 02487 int * lastNumberCuts_; 02488 02496 CbcCountRowCut ** addedCuts_; 02497 02501 OsiRowCut * nextRowCut_; 02502 02504 CbcNode * currentNode_; 02505 02507 int * integerVariable_; 02509 char * integerInfo_; 02511 double * continuousSolution_; 02513 int * usedInSolution_; 02537 int specialOptions_; 02552 int moreSpecialOptions_; 02554 CbcCompareBase * nodeCompare_; 02556 CbcFeasibilityBase * problemFeasibility_; 02558 CbcTree * tree_; 02560 CbcFullNodeInfo * topOfTree_; 02562 CbcModel * subTreeModel_; 02564 CbcModel * heuristicModel_; 02566 int numberStoppedSubTrees_; 02568 CbcBranchDecision * branchingMethod_; 02570 CbcCutModifier * cutModifier_; 02572 CbcStrategy * strategy_; 02574 CbcModel * parentModel_; 02580 02581 const double * cbcColLower_; 02583 const double * cbcColUpper_; 02585 const double * cbcRowLower_; 02587 const double * cbcRowUpper_; 02589 const double * cbcColSolution_; 02591 const double * cbcRowPrice_; 02593 const double * cbcReducedCost_; 02595 const double * cbcRowActivity_; 02597 void * appData_; 02599 int presolve_; 02603 int numberStrong_; 02609 int numberBeforeTrust_; 02613 int numberPenalties_; 02615 int stopNumberIterations_; 02618 double penaltyScaleFactor_; 02620 int numberAnalyzeIterations_; 02622 double * analyzeResults_; 02624 int numberInfeasibleNodes_; 02631 int problemType_; 02633 int printFrequency_; 02635 int numberCutGenerators_; 02636 // Cut generators 02637 CbcCutGenerator ** generator_; 02638 // Cut generators before any changes 02639 CbcCutGenerator ** virginGenerator_; 02641 int numberHeuristics_; 02643 CbcHeuristic ** heuristic_; 02645 CbcHeuristic * lastHeuristic_; 02647 int fastNodeDepth_; 02649 # ifdef CBC_ONLY_CLP 02650 ClpEventHandler *eventHandler_ ; 02651 # else 02652 CbcEventHandler *eventHandler_ ; 02653 # endif 02654 02656 int numberObjects_; 02657 02668 OsiObject ** object_; 02670 bool ownObjects_; 02671 02673 int * originalColumns_; 02675 int howOftenGlobalScan_; 02678 int numberGlobalViolations_; 02680 int numberExtraIterations_; 02682 int numberExtraNodes_; 02686 double continuousObjective_; 02689 double originalContinuousObjective_; 02691 int continuousInfeasibilities_; 02693 int maximumCutPassesAtRoot_; 02695 int maximumCutPasses_; 02697 int preferredWay_; 02699 int currentPassNumber_; 02701 int maximumWhich_; 02703 int maximumRows_; 02705 int randomSeed_; 02707 int multipleRootTries_; 02709 int currentDepth_; 02711 mutable CoinThreadRandom randomNumberGenerator_; 02713 CoinWarmStartBasis workingBasis_; 02715 int * whichGenerator_; 02717 int maximumStatistics_; 02719 CbcStatistics ** statistics_; 02721 int maximumDepthActual_; 02723 double numberDJFixed_; 02725 CglTreeProbingInfo * probingInfo_; 02727 int numberFixedAtRoot_; 02729 int numberFixedNow_; 02731 bool stoppedOnGap_; 02733 mutable bool eventHappened_; 02735 int numberLongStrong_; 02737 int numberOldActiveCuts_; 02739 int numberNewCuts_; 02741 int searchStrategy_; 02753 int strongStrategy_; 02755 int numberStrongIterations_; 02758 int strongInfo_[7]; 02765 OsiBabSolver * solverCharacteristics_; 02767 bool resolveAfterTakeOffCuts_; 02769 int maximumNumberIterations_; 02771 int continuousPriority_; 02773 int numberUpdateItems_; 02775 int maximumNumberUpdateItems_; 02777 CbcObjectUpdateData * updateItems_; 02779 CglStored * storedRowCuts_; 02787 int numberThreads_; 02795 int threadMode_; 02797 CbcBaseModel * master_; 02799 CbcThread * masterThread_; 02801 }; 02803 void getIntegerInformation(const OsiObject * object, double & originalLower, 02804 double & originalUpper) ; 02805 // So we can call from other programs 02806 // Real main program 02807 class OsiClpSolverInterface; 02808 int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver); 02809 int CbcMain (int argc, const char *argv[], CbcModel & babSolver); 02810 // four ways of calling 02811 int callCbc(const char * input2, OsiClpSolverInterface& solver1); 02812 int callCbc(const char * input2); 02813 int callCbc(const std::string input2, OsiClpSolverInterface& solver1); 02814 int callCbc(const std::string input2) ; 02815 // When we want to load up CbcModel with options first 02816 void CbcMain0 (CbcModel & babSolver); 02817 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver); 02818 // two ways of calling 02819 int callCbc(const char * input2, CbcModel & babSolver); 02820 int callCbc(const std::string input2, CbcModel & babSolver); 02821 // And when CbcMain0 already called to initialize 02822 int callCbc1(const char * input2, CbcModel & babSolver); 02823 int callCbc1(const std::string input2, CbcModel & babSolver); 02824 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom) 02825 int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 02826 int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 02827 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); 02828 // For uniform setting of cut and heuristic options 02829 void setCutAndHeuristicOptions(CbcModel & model); 02830 #endif 02831