CbcModel.hpp

Go to the documentation of this file.
00001 /* $Id: CbcModel.hpp 1724 2011-09-12 07:15:28Z forrest $ */
00002 // Copyright (C) 2002, International Business Machines
00003 // Corporation and others.  All Rights Reserved.
00004 // This code is licensed under the terms of the Eclipse Public License (EPL).
00005 
00006 #ifndef CbcModel_H
00007 #define CbcModel_H
00008 #include <string>
00009 #include <vector>
00010 #include "CoinMessageHandler.hpp"
00011 #include "OsiSolverInterface.hpp"
00012 #include "OsiBranchingObject.hpp"
00013 #include "OsiCuts.hpp"
00014 #include "CoinWarmStartBasis.hpp"
00015 #include "CbcCompareBase.hpp"
00016 #include "CbcMessage.hpp"
00017 #include "CbcEventHandler.hpp"
00018 #include "ClpDualRowPivot.hpp"
00019 
00020 
00021 class CbcCutGenerator;
00022 class CbcBaseModel;
00023 class OsiRowCut;
00024 class OsiBabSolver;
00025 class OsiRowCutDebugger;
00026 class CglCutGenerator;
00027 class CglStored;
00028 class CbcCutModifier;
00029 class CglTreeProbingInfo;
00030 class CbcHeuristic;
00031 class OsiObject;
00032 class CbcThread;
00033 class CbcTree;
00034 class CbcStrategy;
00035 class CbcFeasibilityBase;
00036 class CbcStatistics;
00037 class CbcEventHandler ;
00038 class CglPreProcess;
00039 # ifdef COIN_HAS_CLP
00040 class OsiClpSolverInterface;
00041 class ClpNodeStuff;
00042 #endif
00043 // #define CBC_CHECK_BASIS 1
00044 
00045 //#############################################################################
00046 
00099 class CbcModel  {
00100 
00101 public:
00102 
00103     enum CbcIntParam {
00105         CbcMaxNumNode = 0,
00107         CbcMaxNumSol,
00117         CbcFathomDiscipline,
00121         CbcPrinting,
00124         CbcNumberBranches,
00126         CbcLastIntParam
00127     };
00128 
00129     enum CbcDblParam {
00132         CbcIntegerTolerance = 0,
00135         CbcInfeasibilityWeight,
00138         CbcCutoffIncrement,
00145         CbcAllowableGap,
00152         CbcAllowableFractionGap,
00155         CbcMaximumSeconds,
00157         CbcCurrentCutoff,
00159         CbcOptimizationDirection,
00161         CbcCurrentObjectiveValue,
00163         CbcCurrentMinimizationObjectiveValue,
00166         CbcStartSeconds,
00174         CbcHeuristicGap,
00182         CbcHeuristicFractionGap,
00184         CbcSmallestChange,
00186         CbcSumChange,
00188         CbcLargestChange,
00190         CbcSmallChange,
00192         CbcLastDblParam
00193     };
00194 
00195     //---------------------------------------------------------------------------
00196 
00197 public:
00199 
00200 
00204     void initialSolve();
00205 
00216     void branchAndBound(int doStatistics = 0);
00217 private:
00218 
00226     bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node);
00234     int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
00242     int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts);
00249     CbcNode ** solveOneNode(int whichSolver, CbcNode * node,
00250                             int & numberNodesOutput, int & status) ;
00252     void resizeWhichGenerator(int numberNow, int numberAfter);
00253 public:
00254 #ifdef CBC_KEEP_DEPRECATED
00255     // See if anyone is using these any more!!
00260     CbcModel *  cleanModel(const double * lower, const double * upper);
00277     int subBranchAndBound(CbcModel * model2,
00278                           CbcModel * presolvedModel,
00279                           int maximumNodes);
00295     int subBranchAndBound(const double * lower, const double * upper,
00296                           int maximumNodes);
00297 
00304     OsiSolverInterface *  strengthenedModel();
00314     CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5,
00315                                 int tuning = 5);
00318     void postProcess(CglPreProcess * process);
00319 #endif
00321     void addUpdateInformation(const CbcObjectUpdateData & data);
00322 
00328     int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode);
00329 
00330 public:
00344     int resolve(CbcNodeInfo * parent, int whereFrom,
00345                 double * saveSolution = NULL,
00346                 double * saveLower = NULL,
00347                 double * saveUpper = NULL);
00349     void makeGlobalCuts(int numberRows, const int * which);
00351     void makeGlobalCut(const OsiRowCut * cut);
00353     void makeGlobalCut(const OsiRowCut & cut);
00355     void makeGlobalCut(const OsiColCut * cut);
00357     void makeGlobalCut(const OsiColCut & cut);
00359 
00362 
00374     CbcModel * findCliques(bool makeEquality, int atLeastThisMany,
00375                            int lessThanThis, int defaultValue = 1000);
00376 
00385     CbcModel * integerPresolve(bool weak = false);
00386 
00391     bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false);
00392 
00393 
00395     void originalModel(CbcModel * presolvedModel, bool weak);
00396 
00417     bool tightenVubs(int type, bool allowMultipleBinary = false,
00418                      double useCutoff = 1.0e50);
00419 
00425     bool tightenVubs(int numberVubs, const int * which,
00426                      double useCutoff = 1.0e50);
00430     void analyzeObjective();
00431 
00435     void AddIntegers();
00436 
00440     void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible);
00441 
00443 
00449 
00451     inline int numberObjects() const {
00452         return numberObjects_;
00453     }
00455     inline void setNumberObjects(int number) {
00456         numberObjects_ = number;
00457     }
00458 
00460     inline OsiObject ** objects() const {
00461         return object_;
00462     }
00463 
00465     const inline OsiObject * object(int which) const {
00466         return object_[which];
00467     }
00469     inline OsiObject * modifiableObject(int which) const {
00470         return object_[which];
00471     }
00472 
00473     void setOptionalInteger(int index);
00474 
00476     void deleteObjects(bool findIntegers = true);
00477 
00482     void addObjects(int numberObjects, OsiObject ** objects);
00483 
00488     void addObjects(int numberObjects, CbcObject ** objects);
00489 
00491     void synchronizeModel() ;
00492 
00502     void findIntegers(bool startAgain, int type = 0);
00503 
00505 
00506     //---------------------------------------------------------------------------
00507 
00517 
00518     inline bool setIntParam(CbcIntParam key, int value) {
00519         intParam_[key] = value;
00520         return true;
00521     }
00523     inline bool setDblParam(CbcDblParam key, double value) {
00524         dblParam_[key] = value;
00525         return true;
00526     }
00528     inline int getIntParam(CbcIntParam key) const {
00529         return intParam_[key];
00530     }
00532     inline double getDblParam(CbcDblParam key) const {
00533         return dblParam_[key];
00534     }
00540     void setCutoff(double value) ;
00541 
00543     inline double getCutoff() const { //double value ;
00544         //solver_->getDblParam(OsiDualObjectiveLimit,value) ;
00545         //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense());
00546         return dblParam_[CbcCurrentCutoff];
00547     }
00548 
00550     inline bool setMaximumNodes( int value) {
00551         return setIntParam(CbcMaxNumNode, value);
00552     }
00553 
00555     inline int getMaximumNodes() const {
00556         return getIntParam(CbcMaxNumNode);
00557     }
00558 
00563     inline bool setMaximumSolutions( int value) {
00564         return setIntParam(CbcMaxNumSol, value);
00565     }
00570     inline int getMaximumSolutions() const {
00571         return getIntParam(CbcMaxNumSol);
00572     }
00574     inline bool setPrintingMode( int value) {
00575         return setIntParam(CbcPrinting, value);
00576     }
00577 
00579     inline int getPrintingMode() const {
00580         return getIntParam(CbcPrinting);
00581     }
00582 
00587     inline bool setMaximumSeconds( double value) {
00588         return setDblParam(CbcMaximumSeconds, value);
00589     }
00594     inline double getMaximumSeconds() const {
00595         return getDblParam(CbcMaximumSeconds);
00596     }
00598     double getCurrentSeconds() const ;
00599 
00601     bool maximumSecondsReached() const ;
00602 
00606     inline bool setIntegerTolerance( double value) {
00607         return setDblParam(CbcIntegerTolerance, value);
00608     }
00612     inline double getIntegerTolerance() const {
00613         return getDblParam(CbcIntegerTolerance);
00614     }
00615 
00620     inline bool setInfeasibilityWeight( double value) {
00621         return setDblParam(CbcInfeasibilityWeight, value);
00622     }
00627     inline double getInfeasibilityWeight() const {
00628         return getDblParam(CbcInfeasibilityWeight);
00629     }
00630 
00634     inline bool setAllowableGap( double value) {
00635         return setDblParam(CbcAllowableGap, value);
00636     }
00640     inline double getAllowableGap() const {
00641         return getDblParam(CbcAllowableGap);
00642     }
00643 
00647     inline bool setAllowableFractionGap( double value) {
00648         return setDblParam(CbcAllowableFractionGap, value);
00649     }
00653     inline double getAllowableFractionGap() const {
00654         return getDblParam(CbcAllowableFractionGap);
00655     }
00659     inline bool setAllowablePercentageGap( double value) {
00660         return setDblParam(CbcAllowableFractionGap, value*0.01);
00661     }
00665     inline double getAllowablePercentageGap() const {
00666         return 100.0*getDblParam(CbcAllowableFractionGap);
00667     }
00671     inline bool setHeuristicGap( double value) {
00672         return setDblParam(CbcHeuristicGap, value);
00673     }
00677     inline double getHeuristicGap() const {
00678         return getDblParam(CbcHeuristicGap);
00679     }
00680 
00684     inline bool setHeuristicFractionGap( double value) {
00685         return setDblParam(CbcHeuristicFractionGap, value);
00686     }
00690     inline double getHeuristicFractionGap() const {
00691         return getDblParam(CbcHeuristicFractionGap);
00692     }
00697     inline bool setCutoffIncrement( double value) {
00698         return setDblParam(CbcCutoffIncrement, value);
00699     }
00704     inline double getCutoffIncrement() const {
00705         return getDblParam(CbcCutoffIncrement);
00706     }
00707 
00712     void setHotstartSolution(const double * solution, const int * priorities = NULL) ;
00713 
00715     inline void setMinimumDrop(double value) {
00716         minimumDrop_ = value;
00717     }
00719     inline double getMinimumDrop() const {
00720         return minimumDrop_;
00721     }
00722 
00725     inline void setMaximumCutPassesAtRoot(int value) {
00726         maximumCutPassesAtRoot_ = value;
00727     }
00729     inline int getMaximumCutPassesAtRoot() const {
00730         return maximumCutPassesAtRoot_;
00731     }
00732 
00735     inline void setMaximumCutPasses(int value) {
00736         maximumCutPasses_ = value;
00737     }
00739     inline int getMaximumCutPasses() const {
00740         return maximumCutPasses_;
00741     }
00744     inline int getCurrentPassNumber() const {
00745         return currentPassNumber_;
00746     }
00747 
00753     void setNumberStrong(int number);
00757     inline int numberStrong() const {
00758         return numberStrong_;
00759     }
00762     inline void setPreferredWay(int value) {
00763         preferredWay_ = value;
00764     }
00766     inline int getPreferredWay() const {
00767         return preferredWay_;
00768     }
00770     inline int whenCuts() const {
00771         return whenCuts_;
00772     }
00774     inline void setWhenCuts(int value) {
00775         whenCuts_ = value;
00776     }
00782     bool doCutsNow(int allowForTopOfTree) const;
00783 
00789     void setNumberBeforeTrust(int number);
00792     inline int numberBeforeTrust() const {
00793         return numberBeforeTrust_;
00794     }
00800     void setNumberPenalties(int number);
00803     inline int numberPenalties() const {
00804         return numberPenalties_;
00805     }
00807     inline void setNumberAnalyzeIterations(int number) {
00808         numberAnalyzeIterations_ = number;
00809     }
00810     inline int numberAnalyzeIterations() const {
00811         return numberAnalyzeIterations_;
00812     }
00815     inline double penaltyScaleFactor() const {
00816         return penaltyScaleFactor_;
00817     }
00820     void setPenaltyScaleFactor(double value);
00828     void inline setProblemType(int number) {
00829         problemType_ = number;
00830     }
00831     inline int problemType() const {
00832         return problemType_;
00833     }
00835     inline int currentDepth() const {
00836         return currentDepth_;
00837     }
00838 
00840     void setHowOftenGlobalScan(int number);
00842     inline int howOftenGlobalScan() const {
00843         return howOftenGlobalScan_;
00844     }
00846     inline int * originalColumns() const {
00847         return originalColumns_;
00848     }
00850     void setOriginalColumns(const int * originalColumns) ;
00851 
00859     inline void setPrintFrequency(int number) {
00860         printFrequency_ = number;
00861     }
00863     inline int printFrequency() const {
00864         return printFrequency_;
00865     }
00867 
00868     //---------------------------------------------------------------------------
00870 
00871 
00872     bool isAbandoned() const;
00874     bool isProvenOptimal() const;
00876     bool isProvenInfeasible() const;
00878     bool isContinuousUnbounded() const;
00880     bool isProvenDualInfeasible() const;
00882     bool isNodeLimitReached() const;
00884     bool isSecondsLimitReached() const;
00886     bool isSolutionLimitReached() const;
00888     inline int getIterationCount() const {
00889         return numberIterations_;
00890     }
00892     inline void incrementIterationCount(int value) {
00893         numberIterations_ += value;
00894     }
00896     inline int getNodeCount() const {
00897         return numberNodes_;
00898     }
00900     inline void incrementNodeCount(int value) {
00901         numberNodes_ += value;
00902     }
00912     inline int status() const {
00913         return status_;
00914     }
00915     inline void setProblemStatus(int value) {
00916         status_ = value;
00917     }
00929     inline int secondaryStatus() const {
00930         return secondaryStatus_;
00931     }
00932     inline void setSecondaryStatus(int value) {
00933         secondaryStatus_ = value;
00934     }
00936     bool isInitialSolveAbandoned() const ;
00938     bool isInitialSolveProvenOptimal() const ;
00940     bool isInitialSolveProvenPrimalInfeasible() const ;
00942     bool isInitialSolveProvenDualInfeasible() const ;
00943 
00945 
00946     //---------------------------------------------------------------------------
00959 
00960     inline int numberRowsAtContinuous() const {
00961         return numberRowsAtContinuous_;
00962     }
00963 
00965     inline int getNumCols() const {
00966         return solver_->getNumCols();
00967     }
00968 
00970     inline int getNumRows() const {
00971         return solver_->getNumRows();
00972     }
00973 
00975     inline CoinBigIndex getNumElements() const {
00976         return solver_->getNumElements();
00977     }
00978 
00980     inline int numberIntegers() const {
00981         return numberIntegers_;
00982     }
00983     // Integer variables
00984     inline const int * integerVariable() const {
00985         return integerVariable_;
00986     }
00988     inline char integerType(int i) const {
00989         assert (integerInfo_);
00990         assert (integerInfo_[i] == 0 || integerInfo_[i] == 1);
00991         return integerInfo_[i];
00992     }
00994     inline const char * integerType() const {
00995         return integerInfo_;
00996     }
00997 
00999     inline const double * getColLower() const {
01000         return solver_->getColLower();
01001     }
01002 
01004     inline const double * getColUpper() const {
01005         return solver_->getColUpper();
01006     }
01007 
01017     inline const char * getRowSense() const {
01018         return solver_->getRowSense();
01019     }
01020 
01029     inline const double * getRightHandSide() const {
01030         return solver_->getRightHandSide();
01031     }
01032 
01041     inline const double * getRowRange() const {
01042         return solver_->getRowRange();
01043     }
01044 
01046     inline const double * getRowLower() const {
01047         return solver_->getRowLower();
01048     }
01049 
01051     inline const double * getRowUpper() const {
01052         return solver_->getRowUpper();
01053     }
01054 
01056     inline const double * getObjCoefficients() const {
01057         return solver_->getObjCoefficients();
01058     }
01059 
01061     inline double getObjSense() const {
01062         //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense());
01063         return dblParam_[CbcOptimizationDirection];
01064     }
01065 
01067     inline bool isContinuous(int colIndex) const {
01068         return solver_->isContinuous(colIndex);
01069     }
01070 
01072     inline bool isBinary(int colIndex) const {
01073         return solver_->isBinary(colIndex);
01074     }
01075 
01080     inline bool isInteger(int colIndex) const {
01081         return solver_->isInteger(colIndex);
01082     }
01083 
01085     inline bool isIntegerNonBinary(int colIndex) const {
01086         return solver_->isIntegerNonBinary(colIndex);
01087     }
01088 
01090     inline bool isFreeBinary(int colIndex) const {
01091         return solver_->isFreeBinary(colIndex) ;
01092     }
01093 
01095     inline const CoinPackedMatrix * getMatrixByRow() const {
01096         return solver_->getMatrixByRow();
01097     }
01098 
01100     inline const CoinPackedMatrix * getMatrixByCol() const {
01101         return solver_->getMatrixByCol();
01102     }
01103 
01105     inline double getInfinity() const {
01106         return solver_->getInfinity();
01107     }
01109     inline const double * getCbcColLower() const {
01110         return cbcColLower_;
01111     }
01113     inline const double * getCbcColUpper() const {
01114         return cbcColUpper_;
01115     }
01117     inline const double * getCbcRowLower() const {
01118         return cbcRowLower_;
01119     }
01121     inline const double * getCbcRowUpper() const {
01122         return cbcRowUpper_;
01123     }
01125     inline const double * getCbcColSolution() const {
01126         return cbcColSolution_;
01127     }
01129     inline const double * getCbcRowPrice() const {
01130         return cbcRowPrice_;
01131     }
01133     inline const double * getCbcReducedCost() const {
01134         return cbcReducedCost_;
01135     }
01137     inline const double * getCbcRowActivity() const {
01138         return cbcRowActivity_;
01139     }
01141 
01142 
01145 
01146     inline double * continuousSolution() const {
01147         return continuousSolution_;
01148     }
01153     inline int * usedInSolution() const {
01154         return usedInSolution_;
01155     }
01157     void incrementUsed(const double * solution);
01159     void setBestSolution(CBC_Message how,
01160                          double & objectiveValue, const double *solution,
01161                          int fixVariables = 0);
01163     void setBestObjectiveValue( double objectiveValue);
01165     CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event,
01166             double objValue,
01167             const double * solution);
01168 
01175     double checkSolution(double cutoff, double * solution,
01176                          int fixVariables, double originalObjValue);
01183     bool feasibleSolution(int & numberIntegerInfeasibilities,
01184                           int & numberObjectInfeasibilities) const;
01185 
01191     inline double * currentSolution() const {
01192         return currentSolution_;
01193     }
01197     inline const double * testSolution() const {
01198         return testSolution_;
01199     }
01200     inline void setTestSolution(const double * solution) {
01201         testSolution_ = solution;
01202     }
01204     void reserveCurrentSolution(const double * solution = NULL);
01205 
01207     inline const double * getColSolution() const {
01208         return solver_->getColSolution();
01209     }
01210 
01212     inline const double * getRowPrice() const {
01213         return solver_->getRowPrice();
01214     }
01215 
01217     inline const double * getReducedCost() const {
01218         return solver_->getReducedCost();
01219     }
01220 
01222     inline const double * getRowActivity() const {
01223         return solver_->getRowActivity();
01224     }
01225 
01227     inline double getCurrentObjValue() const {
01228         return dblParam_[CbcCurrentObjectiveValue];
01229     }
01231     inline double getCurrentMinimizationObjValue() const {
01232         return dblParam_[CbcCurrentMinimizationObjectiveValue];
01233     }
01234 
01236     inline double getMinimizationObjValue() const {
01237         return bestObjective_;
01238     }
01240     inline void setMinimizationObjValue(double value) {
01241         bestObjective_ = value;
01242     }
01243 
01245     inline double getObjValue() const {
01246         return bestObjective_ * solver_->getObjSense() ;
01247     }
01253     double getBestPossibleObjValue() const;
01255     inline void setObjValue(double value) {
01256         bestObjective_ = value * solver_->getObjSense() ;
01257     }
01259     inline double getSolverObjValue() const {
01260         return solver_->getObjValue() * solver_->getObjSense() ;
01261     }
01262 
01269     inline double * bestSolution() const {
01270         return bestSolution_;
01271     }
01278     void setBestSolution(const double * solution, int numberColumns,
01279                          double objectiveValue, bool check = false);
01280 
01282     inline int getSolutionCount() const {
01283         return numberSolutions_;
01284     }
01285 
01287     inline void setSolutionCount(int value) {
01288         numberSolutions_ = value;
01289     }
01291     int numberSavedSolutions() const;
01293     inline int maximumSavedSolutions() const {
01294         return maximumSavedSolutions_;
01295     }
01297     void setMaximumSavedSolutions(int value);
01299     const double * savedSolution(int which) const;
01301     double savedSolutionObjective(int which) const;
01302 
01311     inline int phase() const {
01312         return phase_;
01313     }
01314 
01316     inline int getNumberHeuristicSolutions() const {
01317         return numberHeuristicSolutions_;
01318     }
01320     inline void setNumberHeuristicSolutions(int value) {
01321         numberHeuristicSolutions_ = value;
01322     }
01323 
01325     inline void setObjSense(double s) {
01326         dblParam_[CbcOptimizationDirection] = s;
01327         solver_->setObjSense(s);
01328     }
01329 
01331     inline double getContinuousObjective() const {
01332         return originalContinuousObjective_;
01333     }
01334     inline void setContinuousObjective(double value) {
01335         originalContinuousObjective_ = value;
01336     }
01338     inline int getContinuousInfeasibilities() const {
01339         return continuousInfeasibilities_;
01340     }
01341     inline void setContinuousInfeasibilities(int value) {
01342         continuousInfeasibilities_ = value;
01343     }
01345     inline double rootObjectiveAfterCuts() const {
01346         return continuousObjective_;
01347     }
01349     inline double sumChangeObjective() const {
01350         return sumChangeObjective1_;
01351     }
01354     inline int numberGlobalViolations() const {
01355         return numberGlobalViolations_;
01356     }
01357     inline void clearNumberGlobalViolations() {
01358         numberGlobalViolations_ = 0;
01359     }
01361     inline bool resolveAfterTakeOffCuts() const {
01362         return resolveAfterTakeOffCuts_;
01363     }
01364     inline void setResolveAfterTakeOffCuts(bool yesNo) {
01365         resolveAfterTakeOffCuts_ = yesNo;
01366     }
01368     inline int maximumRows() const {
01369         return maximumRows_;
01370     }
01372     inline CoinWarmStartBasis & workingBasis() {
01373         return workingBasis_;
01374     }
01376     inline int getStopNumberIterations() const {
01377         return stopNumberIterations_;
01378     }
01380     inline void setStopNumberIterations(int value) {
01381         stopNumberIterations_ = value;
01382     }
01384 
01387     // Comparison functions (which may be overridden by inheritance)
01388     inline CbcCompareBase * nodeComparison() const {
01389         return nodeCompare_;
01390     }
01391     void setNodeComparison(CbcCompareBase * compare);
01392     void setNodeComparison(CbcCompareBase & compare);
01394 
01397     // Feasibility functions (which may be overridden by inheritance)
01398     inline CbcFeasibilityBase * problemFeasibility() const {
01399         return problemFeasibility_;
01400     }
01401     void setProblemFeasibility(CbcFeasibilityBase * feasibility);
01402     void setProblemFeasibility(CbcFeasibilityBase & feasibility);
01404 
01407 
01408     inline CbcTree * tree() const {
01409         return tree_;
01410     }
01412     void passInTreeHandler(CbcTree & tree);
01416     void passInSubTreeModel(CbcModel & model);
01421     CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const;
01423     inline int numberStoppedSubTrees() const {
01424         return numberStoppedSubTrees_;
01425     }
01427     inline void incrementSubTreeStopped() {
01428         numberStoppedSubTrees_++;
01429     }
01435     inline int typePresolve() const {
01436         return presolve_;
01437     }
01438     inline void setTypePresolve(int value) {
01439         presolve_ = value;
01440     }
01441 
01443 
01449 
01451     inline CbcBranchDecision * branchingMethod() const {
01452         return branchingMethod_;
01453     }
01455     inline void setBranchingMethod(CbcBranchDecision * method) {
01456         delete branchingMethod_;
01457         branchingMethod_ = method->clone();
01458     }
01463     inline void setBranchingMethod(CbcBranchDecision & method) {
01464         delete branchingMethod_;
01465         branchingMethod_ = method.clone();
01466     }
01468     inline CbcCutModifier * cutModifier() const {
01469         return cutModifier_;
01470     }
01472     void setCutModifier(CbcCutModifier * modifier);
01477     void setCutModifier(CbcCutModifier & modifier);
01479 
01482 
01489     inline int stateOfSearch() const {
01490         return stateOfSearch_;
01491     }
01492     inline void setStateOfSearch(int state) {
01493         stateOfSearch_ = state;
01494     }
01496     inline int searchStrategy() const {
01497         return searchStrategy_;
01498     }
01500     inline void setSearchStrategy(int value) {
01501         searchStrategy_ = value;
01502     }
01503 
01505     inline int numberCutGenerators() const {
01506         return numberCutGenerators_;
01507     }
01509     inline CbcCutGenerator ** cutGenerators() const {
01510         return generator_;
01511     }
01513     inline CbcCutGenerator * cutGenerator(int i) const {
01514         return generator_[i];
01515     }
01517     inline CbcCutGenerator * virginCutGenerator(int i) const {
01518         return virginGenerator_[i];
01519     }
01528     void addCutGenerator(CglCutGenerator * generator,
01529                          int howOften = 1, const char * name = NULL,
01530                          bool normal = true, bool atSolution = false,
01531                          bool infeasible = false, int howOftenInSub = -100,
01532                          int whatDepth = -1, int whatDepthInSub = -1);
01534 
01539 
01541     inline CbcStrategy * strategy() const {
01542         return strategy_;
01543     }
01545     void setStrategy(CbcStrategy & strategy);
01547     inline void setStrategy(CbcStrategy * strategy) {
01548         strategy_ = strategy;
01549     }
01551     inline CbcModel * parentModel() const {
01552         return parentModel_;
01553     }
01555     inline void setParentModel(CbcModel & parentModel) {
01556         parentModel_ = &parentModel;
01557     }
01559 
01560 
01567     void addHeuristic(CbcHeuristic * generator, const char *name = NULL,
01568                       int before = -1);
01570     inline CbcHeuristic * heuristic(int i) const {
01571         return heuristic_[i];
01572     }
01574     inline int numberHeuristics() const {
01575         return numberHeuristics_;
01576     }
01578     inline CbcHeuristic * lastHeuristic() const {
01579         return lastHeuristic_;
01580     }
01582     inline void setLastHeuristic(CbcHeuristic * last) {
01583         lastHeuristic_ = last;
01584     }
01585 
01604     void passInPriorities(const int * priorities, bool ifNotSimpleIntegers);
01605 
01607     inline int priority(int sequence) const {
01608         return object_[sequence]->priority();
01609     }
01610 
01615     void passInEventHandler(const CbcEventHandler *eventHandler) ;
01616 
01618     inline CbcEventHandler* getEventHandler() const {
01619         return (eventHandler_) ;
01620     }
01621 
01623 
01633     void setApplicationData (void * appData);
01634 
01636     void * getApplicationData() const;
01649     void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics);
01651     inline const OsiBabSolver * solverCharacteristics() const {
01652         return solverCharacteristics_;
01653     }
01655 
01656     //---------------------------------------------------------------------------
01657 
01660 
01661     void passInMessageHandler(CoinMessageHandler * handler);
01663     void newLanguage(CoinMessages::Language language);
01664     inline void setLanguage(CoinMessages::Language language) {
01665         newLanguage(language);
01666     }
01668     inline CoinMessageHandler * messageHandler() const {
01669         return handler_;
01670     }
01672     inline CoinMessages & messages() {
01673         return messages_;
01674     }
01676     inline CoinMessages * messagesPointer() {
01677         return &messages_;
01678     }
01680     void setLogLevel(int value);
01682     inline int logLevel() const {
01683         return handler_->logLevel();
01684     }
01690     inline void setDefaultHandler(bool yesNo) {
01691         defaultHandler_ = yesNo;
01692     }
01694     //---------------------------------------------------------------------------
01696 
01697 
01722     inline void setSpecialOptions(int value) {
01723         specialOptions_ = value;
01724     }
01726     inline int specialOptions() const {
01727         return specialOptions_;
01728     }
01730     inline bool normalSolver() const {
01731         return (specialOptions_&16) == 0;
01732     }
01737     inline bool waitingForMiniBranchAndBound() const {
01738         return (specialOptions_&1048576) != 0;
01739     }
01754     inline void setMoreSpecialOptions(int value) {
01755         moreSpecialOptions_ = value;
01756     }
01758     inline int moreSpecialOptions() const {
01759         return moreSpecialOptions_;
01760     }
01762     inline void setUseElapsedTime(bool yesNo) {
01763         if (yesNo)
01764           moreSpecialOptions_ |= 131072;
01765         else
01766           moreSpecialOptions_ &= ~131072;
01767     }
01769     inline bool useElapsedTime() const {
01770         return (moreSpecialOptions_&131072)!=0;
01771     }
01773 #ifdef COIN_HAS_CLP
01774     void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod);
01775 #endif
01777     inline bool ownObjects() const {
01778         return ownObjects_;
01779     }
01781     void checkModel();
01783     //---------------------------------------------------------------------------
01784 
01786 
01787 
01788     CbcModel();
01789 
01791     CbcModel(const OsiSolverInterface &);
01792 
01801     void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true);
01802 
01814     inline void setModelOwnsSolver (bool ourSolver) {
01815         ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ;
01816     }
01817 
01823     inline bool modelOwnsSolver () {
01824         return ((ownership_&0x80000000) != 0) ;
01825     }
01826 
01830     CbcModel(const CbcModel & rhs, bool cloneHandler = false);
01831 
01833     CbcModel & operator=(const CbcModel& rhs);
01834 
01836     ~CbcModel ();
01837 
01839     inline OsiSolverInterface * solver() const {
01840         return solver_;
01841     }
01842 
01844     inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) {
01845         OsiSolverInterface * returnSolver = solver_;
01846         solver_ = solver;
01847         return returnSolver;
01848     }
01849 
01851     inline OsiSolverInterface * continuousSolver() const {
01852         return continuousSolver_;
01853     }
01854 
01856     inline void createContinuousSolver() {
01857         continuousSolver_ = solver_->clone();
01858     }
01860     inline void clearContinuousSolver() {
01861         delete continuousSolver_;
01862         continuousSolver_ = NULL;
01863     }
01864 
01866     inline OsiSolverInterface * referenceSolver() const {
01867         return referenceSolver_;
01868     }
01869 
01871     void saveReferenceSolver();
01872 
01878     void resetToReferenceSolver();
01879 
01881     void gutsOfDestructor();
01884     void gutsOfDestructor2();
01887     void resetModel();
01893     void gutsOfCopy(const CbcModel & rhs, int mode = 0);
01895     void moveInfo(const CbcModel & rhs);
01897 
01899 
01900 
01901     static bool haveMultiThreadSupport();
01903     CbcThread * masterThread() const {
01904         return masterThread_;
01905     }
01907     CbcNodeInfo ** walkback() const {
01908         return walkback_;
01909     }
01911     inline int getNumberThreads() const {
01912         return numberThreads_;
01913     }
01915     inline void setNumberThreads(int value) {
01916         numberThreads_ = value;
01917     }
01919     inline int getThreadMode() const {
01920         return threadMode_;
01921     }
01931     inline void setThreadMode(int value) {
01932         threadMode_ = value;
01933     }
01940     inline int parallelMode() const {
01941         if (!numberThreads_) {
01942             if ((threadMode_&1) == 0)
01943                 return 0;
01944             else
01945                 return -1;
01946             return 0;
01947         } else {
01948             if ((threadMode_&1) == 0)
01949                 return 1;
01950             else
01951                 return -2;
01952         }
01953     }
01956     bool isLocked() const;
01957 #ifdef CBC_THREAD
01958 
01962     void lockThread();
01966     void unlockThread();
01967 #else
01968     inline void lockThread() {}
01969     inline void unlockThread() {}
01970 #endif
01971 
01978     void setInfoInChild(int type, CbcThread * info);
01985     void moveToModel(CbcModel * baseModel, int mode);
01987     int splitModel(int numberModels, CbcModel ** model,
01988                    int numberNodes);
01990     void startSplitModel(int numberIterations);
01992     void mergeModels(int numberModel, CbcModel ** model,
01993                      int numberNodes);
01995 
01997 
01998 
01999     int getNodeCount2() const {
02000         return numberNodes2_;
02001     }
02003     void setPointers(const OsiSolverInterface * solver);
02009     int reducedCostFix() ;
02013     void synchronizeHandlers(int makeDefault);
02015     void saveExtraSolution(const double * solution, double objectiveValue);
02017     void saveBestSolution(const double * solution, double objectiveValue);
02019     void deleteSolutions();
02021     int resolve(OsiSolverInterface * solver);
02022 #ifdef CLP_RESOLVE
02024     int resolveClp(OsiClpSolverInterface * solver, int type);
02025 #endif
02026 
02030     int chooseBranch(CbcNode * & newNode, int numberPassesLeft,
02031                      CbcNode * oldNode, OsiCuts & cuts,
02032                      bool & resolved, CoinWarmStartBasis *lastws,
02033                      const double * lowerBefore, const double * upperBefore,
02034                      OsiSolverBranch * & branches);
02035     int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved);
02036 
02043     CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ;
02044 
02056     int takeOffCuts(OsiCuts &cuts,
02057                     bool allowResolve, OsiCuts * saveCuts,
02058                     int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ;
02059 
02073     int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws, bool canFix);
02074 
02091     bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws);
02095     void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn,
02096                          double & lower, double & upper, int force);
02101     void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const;
02102 
02106     void convertToDynamic();
02108     void synchronizeNumberBeforeTrust(int type = 0);
02110     void zapIntegerInformation(bool leaveObjects = true);
02112     int cliquePseudoCosts(int doStatistics);
02114     void pseudoShadow(int type);
02121     void fillPseudoCosts(double * downCosts, double * upCosts,
02122                          int * priority = NULL,
02123                          int * numberDown = NULL, int * numberUp = NULL,
02124                          int * numberDownInfeasible = NULL,
02125                          int * numberUpInfeasible = NULL) const;
02131     void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0);
02133     void adjustHeuristics();
02135     inline const double * hotstartSolution() const {
02136         return hotstartSolution_;
02137     }
02139     inline const int * hotstartPriorities() const {
02140         return hotstartPriorities_;
02141     }
02142 
02144     inline CbcCountRowCut ** addedCuts() const {
02145         return addedCuts_;
02146     }
02148     inline int currentNumberCuts() const {
02149         return currentNumberCuts_;
02150     }
02152     inline OsiCuts * globalCuts() {
02153         return &globalCuts_;
02154     }
02156     void setNextRowCut(const OsiRowCut & cut);
02158     inline CbcNode * currentNode() const {
02159         return currentNode_;
02160     }
02162     inline CglTreeProbingInfo * probingInfo() const {
02163         return probingInfo_;
02164     }
02166     inline CoinThreadRandom * randomNumberGenerator() {
02167         return &randomNumberGenerator_;
02168     }
02170     inline void setNumberStrongIterations(int number) {
02171         numberStrongIterations_ = number;
02172     }
02174     inline int numberStrongIterations() const {
02175         return numberStrongIterations_;
02176     }
02178     inline int maximumNumberIterations() const {
02179         return maximumNumberIterations_;
02180     }
02182     inline void setMaximumNumberIterations(int value) {
02183         maximumNumberIterations_ = value;
02184     }
02185 # ifdef COIN_HAS_CLP
02187     inline void setFastNodeDepth(int value) {
02188         fastNodeDepth_ = value;
02189     }
02191     inline int fastNodeDepth() const {
02192         return fastNodeDepth_;
02193     }
02195     inline int continuousPriority() const {
02196         return continuousPriority_;
02197     }
02199     inline void setContinuousPriority(int value) {
02200         continuousPriority_ = value;
02201     }
02202     inline void incrementExtra(int nodes, int iterations) {
02203         numberExtraNodes_ += nodes;
02204         numberExtraIterations_ += iterations;
02205     }
02206 #endif
02208     inline int numberExtraIterations() const {
02209         return numberExtraIterations_;
02210     }
02212     void incrementStrongInfo(int numberTimes, int numberIterations,
02213                              int numberFixed, bool ifInfeasible);
02215     inline const int * strongInfo() const {
02216         return strongInfo_;
02217     }
02218 
02220     inline int * mutableStrongInfo() {
02221         return strongInfo_;
02222     }
02224     CglStored * storedRowCuts() const {
02225         return storedRowCuts_;
02226     }
02228     void setStoredRowCuts(CglStored * cuts) {
02229         storedRowCuts_ = cuts;
02230     }
02232     inline bool allDynamic () const {
02233         return ((ownership_&0x40000000) != 0) ;
02234     }
02236     void generateCpp( FILE * fp, int options);
02238     OsiBranchingInformation usefulInformation() const;
02245     inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) {
02246         bestSolutionBasis_ = bestSolutionBasis;
02247     }
02249     void redoWalkBack();
02251 
02252 //---------------------------------------------------------------------------
02253 
02254 private:
02256 
02257 
02259     OsiSolverInterface * solver_;
02260 
02266     unsigned int ownership_ ;
02267 
02269     OsiSolverInterface * continuousSolver_;
02270 
02272     OsiSolverInterface * referenceSolver_;
02273 
02275     CoinMessageHandler * handler_;
02276 
02282     bool defaultHandler_;
02283 
02285     CoinMessages messages_;
02286 
02288     int intParam_[CbcLastIntParam];
02289 
02291     double dblParam_[CbcLastDblParam];
02292 
02301     mutable CoinWarmStart *emptyWarmStart_ ;
02302 
02304     double bestObjective_;
02306     double bestPossibleObjective_;
02308     double sumChangeObjective1_;
02310     double sumChangeObjective2_;
02311 
02313     double * bestSolution_;
02315     double ** savedSolutions_;
02316 
02321     double * currentSolution_;
02325     mutable const double * testSolution_;
02332     CoinWarmStartBasis bestSolutionBasis_ ;
02334     OsiCuts globalCuts_;
02335 
02337     double minimumDrop_;
02339     int numberSolutions_;
02341     int numberSavedSolutions_;
02343     int maximumSavedSolutions_;
02350     int stateOfSearch_;
02352     int whenCuts_;
02354     double * hotstartSolution_;
02356     int * hotstartPriorities_;
02358     int numberHeuristicSolutions_;
02360     int numberNodes_;
02364     int numberNodes2_;
02366     int numberIterations_;
02368     int numberSolves_;
02370     int status_;
02381     int secondaryStatus_;
02383     int numberIntegers_;
02385     int numberRowsAtContinuous_;
02387     int maximumNumberCuts_;
02396     int phase_;
02397 
02399     int currentNumberCuts_;
02400 
02405     int maximumDepth_;
02411     CbcNodeInfo ** walkback_;
02412     CbcNodeInfo ** lastNodeInfo_;
02413     const OsiRowCut ** lastCut_;
02414     int lastDepth_;
02415     int lastNumberCuts2_;
02416     int maximumCuts_;
02417     int * lastNumberCuts_;
02418 
02426     CbcCountRowCut ** addedCuts_;
02427 
02431     OsiRowCut * nextRowCut_;
02432 
02434     CbcNode * currentNode_;
02435 
02437     int * integerVariable_;
02439     char * integerInfo_;
02441     double * continuousSolution_;
02443     int * usedInSolution_;
02467     int specialOptions_;
02482     int moreSpecialOptions_;
02484     CbcCompareBase * nodeCompare_;
02486     CbcFeasibilityBase * problemFeasibility_;
02488     CbcTree * tree_;
02490     CbcModel * subTreeModel_;
02492     int numberStoppedSubTrees_;
02494     CbcBranchDecision * branchingMethod_;
02496     CbcCutModifier * cutModifier_;
02498     CbcStrategy * strategy_;
02500     CbcModel * parentModel_;
02506 
02507     const double * cbcColLower_;
02509     const double * cbcColUpper_;
02511     const double * cbcRowLower_;
02513     const double * cbcRowUpper_;
02515     const double * cbcColSolution_;
02517     const double * cbcRowPrice_;
02519     const double * cbcReducedCost_;
02521     const double * cbcRowActivity_;
02523     void * appData_;
02525     int presolve_;
02529     int numberStrong_;
02535     int numberBeforeTrust_;
02539     int numberPenalties_;
02541     int stopNumberIterations_;
02544     double penaltyScaleFactor_;
02546     int numberAnalyzeIterations_;
02548     double * analyzeResults_;
02550     int numberInfeasibleNodes_;
02557     int problemType_;
02559     int printFrequency_;
02561     int numberCutGenerators_;
02562     // Cut generators
02563     CbcCutGenerator ** generator_;
02564     // Cut generators before any changes
02565     CbcCutGenerator ** virginGenerator_;
02567     int numberHeuristics_;
02569     CbcHeuristic ** heuristic_;
02571     CbcHeuristic * lastHeuristic_;
02573     int fastNodeDepth_;
02575 # ifdef CBC_ONLY_CLP
02576     ClpEventHandler *eventHandler_ ;
02577 # else
02578     CbcEventHandler *eventHandler_ ;
02579 # endif
02580 
02582     int numberObjects_;
02583 
02594     OsiObject ** object_;
02596     bool ownObjects_;
02597 
02599     int * originalColumns_;
02601     int howOftenGlobalScan_;
02604     int numberGlobalViolations_;
02606     int numberExtraIterations_;
02608     int numberExtraNodes_;
02612     double continuousObjective_;
02615     double originalContinuousObjective_;
02617     int continuousInfeasibilities_;
02619     int maximumCutPassesAtRoot_;
02621     int maximumCutPasses_;
02623     int preferredWay_;
02625     int currentPassNumber_;
02627     int maximumWhich_;
02629     int maximumRows_;
02631     int currentDepth_;
02633     mutable CoinThreadRandom randomNumberGenerator_;
02635     CoinWarmStartBasis workingBasis_;
02637     int * whichGenerator_;
02639     int maximumStatistics_;
02641     CbcStatistics ** statistics_;
02643     int maximumDepthActual_;
02645     double numberDJFixed_;
02647     CglTreeProbingInfo * probingInfo_;
02649     int numberFixedAtRoot_;
02651     int numberFixedNow_;
02653     bool stoppedOnGap_;
02655     mutable bool eventHappened_;
02657     int numberLongStrong_;
02659     int numberOldActiveCuts_;
02661     int numberNewCuts_;
02663     int searchStrategy_;
02665     int numberStrongIterations_;
02668     int strongInfo_[7];
02675     OsiBabSolver * solverCharacteristics_;
02677     bool resolveAfterTakeOffCuts_;
02679     int maximumNumberIterations_;
02681     int continuousPriority_;
02683     int numberUpdateItems_;
02685     int maximumNumberUpdateItems_;
02687     CbcObjectUpdateData * updateItems_;
02689     CglStored * storedRowCuts_;
02697     int numberThreads_;
02705     int threadMode_;
02707     CbcBaseModel * master_;
02709     CbcThread * masterThread_;
02711 };
02713 void getIntegerInformation(const OsiObject * object, double & originalLower,
02714                            double & originalUpper) ;
02715 // So we can call from other programs
02716 // Real main program
02717 class OsiClpSolverInterface;
02718 int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver);
02719 int CbcMain (int argc, const char *argv[], CbcModel & babSolver);
02720 // four ways of calling
02721 int callCbc(const char * input2, OsiClpSolverInterface& solver1);
02722 int callCbc(const char * input2);
02723 int callCbc(const std::string input2, OsiClpSolverInterface& solver1);
02724 int callCbc(const std::string input2) ;
02725 // When we want to load up CbcModel with options first
02726 void CbcMain0 (CbcModel & babSolver);
02727 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver);
02728 // two ways of calling
02729 int callCbc(const char * input2, CbcModel & babSolver);
02730 int callCbc(const std::string input2, CbcModel & babSolver);
02731 // And when CbcMain0 already called to initialize
02732 int callCbc1(const char * input2, CbcModel & babSolver);
02733 int callCbc1(const std::string input2, CbcModel & babSolver);
02734 // And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom)
02735 int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
02736 int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
02737 int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom));
02738 // For uniform setting of cut and heuristic options
02739 void setCutAndHeuristicOptions(CbcModel & model);
02740 #endif
02741 

Generated on Wed Sep 21 04:10:22 2011 for Cbc by  doxygen 1.4.7