diff options
Diffstat (limited to 'newstructure/thirdparty/linux/include/coin/CbcModel.hpp')
| -rw-r--r-- | newstructure/thirdparty/linux/include/coin/CbcModel.hpp | 2952 |
1 files changed, 0 insertions, 2952 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/CbcModel.hpp b/newstructure/thirdparty/linux/include/coin/CbcModel.hpp deleted file mode 100644 index ceef661..0000000 --- a/newstructure/thirdparty/linux/include/coin/CbcModel.hpp +++ /dev/null @@ -1,2952 +0,0 @@ -/* $Id: CbcModel.hpp 2206 2015-07-07 20:44:40Z stefan $ */ -// Copyright (C) 2002, International Business Machines -// Corporation and others. All Rights Reserved. -// This code is licensed under the terms of the Eclipse Public License (EPL). - -#ifndef CbcModel_H -#define CbcModel_H -#include <string> -#include <vector> -#include "CoinMessageHandler.hpp" -#include "OsiSolverInterface.hpp" -#include "OsiBranchingObject.hpp" -#include "OsiCuts.hpp" -#include "CoinWarmStartBasis.hpp" -#include "CbcCompareBase.hpp" -#include "CbcCountRowCut.hpp" -#include "CbcMessage.hpp" -#include "CbcEventHandler.hpp" -#include "ClpDualRowPivot.hpp" - - -class CbcCutGenerator; -class CbcBaseModel; -class OsiRowCut; -class OsiBabSolver; -class OsiRowCutDebugger; -class CglCutGenerator; -class CglStored; -class CbcCutModifier; -class CglTreeProbingInfo; -class CbcHeuristic; -class OsiObject; -class CbcThread; -class CbcTree; -class CbcStrategy; -class CbcSymmetry; -class CbcFeasibilityBase; -class CbcStatistics; -class CbcFullNodeInfo; -class CbcEventHandler ; -class CglPreProcess; -class OsiClpSolverInterface; -class ClpNodeStuff; - -// #define CBC_CHECK_BASIS 1 - -//############################################################################# - -/** Simple Branch and bound class - - The initialSolve() method solves the initial LP relaxation of the MIP - problem. The branchAndBound() method can then be called to finish using - a branch and cut algorithm. - - <h3>Search Tree Traversal</h3> - - Subproblems (aka nodes) requiring additional evaluation are stored using - the CbcNode and CbcNodeInfo objects. Ancestry linkage is maintained in the - CbcNodeInfo object. Evaluation of a subproblem within branchAndBound() - proceeds as follows: - <ul> - <li> The node representing the most promising parent subproblem is popped - from the heap which holds the set of subproblems requiring further - evaluation. - <li> Using branching instructions stored in the node, and information in - its ancestors, the model and solver are adjusted to create the - active subproblem. - <li> If the parent subproblem will require further evaluation - (<i>i.e.</i>, there are branches remaining) its node is pushed back - on the heap. Otherwise, the node is deleted. This may trigger - recursive deletion of ancestors. - <li> The newly created subproblem is evaluated. - <li> If the subproblem requires further evaluation, a node is created. - All information needed to recreate the subproblem (branching - information, row and column cuts) is placed in the node and the node - is added to the set of subproblems awaiting further evaluation. - </ul> - Note that there is never a node representing the active subproblem; the model - and solver represent the active subproblem. - - <h3>Row (Constraint) Cut Handling</h3> - - For a typical subproblem, the sequence of events is as follows: - <ul> - <li> The subproblem is rebuilt for further evaluation: One result of a - call to addCuts() is a traversal of ancestors, leaving a list of all - cuts used in the ancestors in #addedCuts_. This list is then scanned - to construct a basis that includes only tight cuts. Entries for - loose cuts are set to NULL. - <li> The subproblem is evaluated: One result of a call to solveWithCuts() - is the return of a set of newly generated cuts for the subproblem. - #addedCuts_ is also kept up-to-date as old cuts become loose. - <li> The subproblem is stored for further processing: A call to - CbcNodeInfo::addCuts() adds the newly generated cuts to the - CbcNodeInfo object associated with this node. - </ul> - See CbcCountRowCut for details of the bookkeeping associated with cut - management. -*/ - -class CbcModel { - -public: - - enum CbcIntParam { - /** The maximum number of nodes before terminating */ - CbcMaxNumNode = 0, - /** The maximum number of solutions before terminating */ - CbcMaxNumSol, - /** Fathoming discipline - - Controls objective function comparisons for purposes of fathoming by bound - or determining monotonic variables. - - If 1, action is taken only when the current objective is strictly worse - than the target. Implementation is handled by adding a small tolerance to - the target. - */ - CbcFathomDiscipline, - /** Adjusts printout - 1 does different node message with number unsatisfied on last branch - */ - CbcPrinting, - /** Number of branches (may be more than number of nodes as may - include strong branching) */ - CbcNumberBranches, - /** Just a marker, so that a static sized array can store parameters. */ - CbcLastIntParam - }; - - enum CbcDblParam { - /** The maximum amount the value of an integer variable can vary from - integer and still be considered feasible. */ - CbcIntegerTolerance = 0, - /** The objective is assumed to worsen by this amount for each - integer infeasibility. */ - CbcInfeasibilityWeight, - /** The amount by which to tighten the objective function cutoff when - a new solution is discovered. */ - CbcCutoffIncrement, - /** Stop when the gap between the objective value of the best known solution - and the best bound on the objective of any solution is less than this. - - This is an absolute value. Conversion from a percentage is left to the - client. - */ - CbcAllowableGap, - /** Stop when the gap between the objective value of the best known solution - and the best bound on the objective of any solution is less than this - fraction of of the absolute value of best known solution. - - Code stops if either this test or CbcAllowableGap test succeeds - */ - CbcAllowableFractionGap, - /** \brief The maximum number of seconds before terminating. - A double should be adequate! */ - CbcMaximumSeconds, - /// Cutoff - stored for speed - CbcCurrentCutoff, - /// Optimization direction - stored for speed - CbcOptimizationDirection, - /// Current objective value - CbcCurrentObjectiveValue, - /// Current minimization objective value - CbcCurrentMinimizationObjectiveValue, - /** \brief The time at start of model. - So that other pieces of code can access */ - CbcStartSeconds, - /** Stop doing heuristics when the gap between the objective value of the - best known solution and the best bound on the objective of any solution - is less than this. - - This is an absolute value. Conversion from a percentage is left to the - client. - */ - CbcHeuristicGap, - /** Stop doing heuristics when the gap between the objective value of the - best known solution and the best bound on the objective of any solution - is less than this fraction of of the absolute value of best known - solution. - - Code stops if either this test or CbcAllowableGap test succeeds - */ - CbcHeuristicFractionGap, - /// Smallest non-zero change on a branch - CbcSmallestChange, - /// Sum of non-zero changes on a branch - CbcSumChange, - /// Largest non-zero change on a branch - CbcLargestChange, - /// Small non-zero change on a branch to be used as guess - CbcSmallChange, - /** Just a marker, so that a static sized array can store parameters. */ - CbcLastDblParam - }; - - //--------------------------------------------------------------------------- - -public: - ///@name Solve methods - //@{ - /** \brief Solve the initial LP relaxation - - Invoke the solver's %initialSolve() method. - */ - void initialSolve(); - - /** \brief Invoke the branch \& cut algorithm - - The method assumes that initialSolve() has been called to solve the - LP relaxation. It processes the root node, then proceeds to explore the - branch & cut search tree. The search ends when the tree is exhausted or - one of several execution limits is reached. - If doStatistics is 1 summary statistics are printed - if 2 then also the path to best solution (if found by branching) - if 3 then also one line per node - */ - void branchAndBound(int doStatistics = 0); -private: - - /** \brief Evaluate a subproblem using cutting planes and heuristics - - The method invokes a main loop which generates cuts, applies heuristics, - and reoptimises using the solver's native %resolve() method. - It returns true if the subproblem remains feasible at the end of the - evaluation. - */ - bool solveWithCuts(OsiCuts & cuts, int numberTries, CbcNode * node); - /** Generate one round of cuts - serial mode - returns - - 0 - normal - 1 - must keep going - 2 - set numberTries to zero - -1 - infeasible - */ - int serialCuts(OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts); - /** Generate one round of cuts - parallel mode - returns - - 0 - normal - 1 - must keep going - 2 - set numberTries to zero - -1 - infeasible - */ - int parallelCuts(CbcBaseModel * master, OsiCuts & cuts, CbcNode * node, OsiCuts & slackCuts, int lastNumberCuts); - /** Input one node output N nodes to put on tree and optional solution update - This should be able to operate in parallel so is given a solver and is const(ish) - However we will need to keep an array of solver_ and bases and more - status is 0 for normal, 1 if solution - Calling code should always push nodes back on tree - */ - CbcNode ** solveOneNode(int whichSolver, CbcNode * node, - int & numberNodesOutput, int & status) ; - /// Update size of whichGenerator - void resizeWhichGenerator(int numberNow, int numberAfter); -public: -#ifdef CBC_KEEP_DEPRECATED - // See if anyone is using these any more!! - /** \brief create a clean model from partially fixed problem - - The method creates a new model with given bounds and with no tree. - */ - CbcModel * cleanModel(const double * lower, const double * upper); - /** \brief Invoke the branch \& cut algorithm on partially fixed problem - - The method presolves the given model and does branch and cut. The search - ends when the tree is exhausted or maximum nodes is reached. - - If better solution found then it is saved. - - Returns 0 if search completed and solution, 1 if not completed and solution, - 2 if completed and no solution, 3 if not completed and no solution. - - Normally okay to do cleanModel immediately followed by subBranchandBound - (== other form of subBranchAndBound) - but may need to get at model for advanced features. - - Deletes model2 - */ - int subBranchAndBound(CbcModel * model2, - CbcModel * presolvedModel, - int maximumNodes); - /** \brief Invoke the branch \& cut algorithm on partially fixed problem - - The method creates a new model with given bounds, presolves it - then proceeds to explore the branch & cut search tree. The search - ends when the tree is exhausted or maximum nodes is reached. - - If better solution found then it is saved. - - Returns 0 if search completed and solution, 1 if not completed and solution, - 2 if completed and no solution, 3 if not completed and no solution. - - This is just subModel immediately followed by other version of - subBranchandBound. - - */ - int subBranchAndBound(const double * lower, const double * upper, - int maximumNodes); - - /** \brief Process root node and return a strengthened model - - The method assumes that initialSolve() has been called to solve the - LP relaxation. It processes the root node and then returns a pointer - to the strengthened model (or NULL if infeasible) - */ - OsiSolverInterface * strengthenedModel(); - /** preProcess problem - replacing solver - If makeEquality true then <= cliques converted to ==. - Presolve will be done numberPasses times. - - Returns NULL if infeasible - - If makeEquality is 1 add slacks to get cliques, - if 2 add slacks to get sos (but only if looks plausible) and keep sos info - */ - CglPreProcess * preProcess( int makeEquality = 0, int numberPasses = 5, - int tuning = 5); - /** Does postprocessing - original solver back. - User has to delete process */ - void postProcess(CglPreProcess * process); -#endif - /// Adds an update information object - void addUpdateInformation(const CbcObjectUpdateData & data); - /** Do one node - broken out for clarity? - also for parallel (when baseModel!=this) - Returns 1 if solution found - node NULL on return if no branches left - newNode NULL if no new node created - */ - int doOneNode(CbcModel * baseModel, CbcNode * & node, CbcNode * & newNode); - -public: - /** \brief Reoptimise an LP relaxation - - Invoke the solver's %resolve() method. - whereFrom - - 0 - initial continuous - 1 - resolve on branch (before new cuts) - 2 - after new cuts - 3 - obsolete code or something modified problem in unexpected way - 10 - after strong branching has fixed variables at root - 11 - after strong branching has fixed variables in tree - - returns 1 feasible, 0 infeasible, -1 feasible but skip cuts - */ - int resolve(CbcNodeInfo * parent, int whereFrom, - double * saveSolution = NULL, - double * saveLower = NULL, - double * saveUpper = NULL); - /// Make given rows (L or G) into global cuts and remove from lp - void makeGlobalCuts(int numberRows, const int * which); - /// Make given cut into a global cut - int makeGlobalCut(const OsiRowCut * cut); - /// Make given cut into a global cut - int makeGlobalCut(const OsiRowCut & cut); - /// Make given column cut into a global cut - void makeGlobalCut(const OsiColCut * cut); - /// Make given column cut into a global cut - void makeGlobalCut(const OsiColCut & cut); - /// Make partial cut into a global cut and save - void makePartialCut(const OsiRowCut * cut, const OsiSolverInterface * solver=NULL); - /// Make partial cuts into global cuts - void makeGlobalCuts(); - /// Which cut generator generated this cut - inline const int * whichGenerator() const - { return whichGenerator_;} - //@} - - /** \name Presolve methods */ - //@{ - - /** Identify cliques and construct corresponding objects. - - Find cliques with size in the range - [\p atLeastThisMany, \p lessThanThis] and construct corresponding - CbcClique objects. - If \p makeEquality is true then a new model may be returned if - modifications had to be made, otherwise \c this is returned. - If the problem is infeasible #numberObjects_ is set to -1. - A client must use deleteObjects() before a second call to findCliques(). - If priorities exist, clique priority is set to the default. - */ - CbcModel * findCliques(bool makeEquality, int atLeastThisMany, - int lessThanThis, int defaultValue = 1000); - - /** Do integer presolve, creating a new (presolved) model. - - Returns the new model, or NULL if feasibility is lost. - If weak is true then just does a normal presolve - - \todo It remains to work out the cleanest way of getting a solution to - the original problem at the end. So this is very preliminary. - */ - CbcModel * integerPresolve(bool weak = false); - - /** Do integer presolve, modifying the current model. - - Returns true if the model remains feasible after presolve. - */ - bool integerPresolveThisModel(OsiSolverInterface * originalSolver, bool weak = false); - - - /// Put back information into the original model after integer presolve. - void originalModel(CbcModel * presolvedModel, bool weak); - - /** \brief For variables involved in VUB constraints, see if we can tighten - bounds by solving lp's - - Returns false if feasibility is lost. - If CglProbing is available, it will be tried as well to see if it can - tighten bounds. - This routine is just a front end for tightenVubs(int,const int*,double). - - If <tt>type = -1</tt> all variables are processed (could be very slow). - If <tt>type = 0</tt> only variables involved in VUBs are processed. - If <tt>type = n > 0</tt>, only the n most expensive VUB variables - are processed, where it is assumed that x is at its maximum so delta - would have to go to 1 (if x not at bound). - - If \p allowMultipleBinary is true, then a VUB constraint is a row with - one continuous variable and any number of binary variables. - - If <tt>useCutoff < 1.0e30</tt>, the original objective is installed as a - constraint with \p useCutoff as a bound. - */ - bool tightenVubs(int type, bool allowMultipleBinary = false, - double useCutoff = 1.0e50); - - /** \brief For variables involved in VUB constraints, see if we can tighten - bounds by solving lp's - - This version is just handed a list of variables to be processed. - */ - bool tightenVubs(int numberVubs, const int * which, - double useCutoff = 1.0e50); - /** - Analyze problem to find a minimum change in the objective function. - */ - void analyzeObjective(); - - /** - Add additional integers. - */ - void AddIntegers(); - /** - Save copy of the model. - */ - void saveModel(OsiSolverInterface * saveSolver, double * checkCutoffForRestart, bool * feasible); - /** - Flip direction of optimization on all models - */ - void flipModel(); - - //@} - - /** \name Object manipulation routines - - See OsiObject for an explanation of `object' in the context of CbcModel. - */ - //@{ - - /// Get the number of objects - inline int numberObjects() const { - return numberObjects_; - } - /// Set the number of objects - inline void setNumberObjects(int number) { - numberObjects_ = number; - } - - /// Get the array of objects - inline OsiObject ** objects() const { - return object_; - } - - /// Get the specified object - const inline OsiObject * object(int which) const { - return object_[which]; - } - /// Get the specified object - inline OsiObject * modifiableObject(int which) const { - return object_[which]; - } - - void setOptionalInteger(int index); - - /// Delete all object information (and just back to integers if true) - void deleteObjects(bool findIntegers = true); - - /** Add in object information. - - Objects are cloned; the owner can delete the originals. - */ - void addObjects(int numberObjects, OsiObject ** objects); - - /** Add in object information. - - Objects are cloned; the owner can delete the originals. - */ - void addObjects(int numberObjects, CbcObject ** objects); - - /// Ensure attached objects point to this model. - void synchronizeModel() ; - - /** \brief Identify integer variables and create corresponding objects. - - Record integer variables and create an CbcSimpleInteger object for each - one. - If \p startAgain is true, a new scan is forced, overwriting any existing - integer variable information. - If type > 0 then 1==PseudoCost, 2 new ones low priority - */ - - void findIntegers(bool startAgain, int type = 0); - -#ifdef SWITCH_VARIABLES - /// Convert Dynamic to Switching - int findSwitching(); - /// Fix associated variables - int fixAssociated(OsiSolverInterface * solver,int cleanBasis); - /// Debug associated variables - int checkAssociated(const OsiSolverInterface * solver, - const double * solution, int printLevel); -#endif - //@} - - //--------------------------------------------------------------------------- - - /**@name Parameter set/get methods - - The set methods return true if the parameter was set to the given value, - false if the value of the parameter is out of range. - - The get methods return the value of the parameter. - - */ - //@{ - /// Set an integer parameter - inline bool setIntParam(CbcIntParam key, int value) { - intParam_[key] = value; - return true; - } - /// Set a double parameter - inline bool setDblParam(CbcDblParam key, double value) { - dblParam_[key] = value; - return true; - } - /// Get an integer parameter - inline int getIntParam(CbcIntParam key) const { - return intParam_[key]; - } - /// Get a double parameter - inline double getDblParam(CbcDblParam key) const { - return dblParam_[key]; - } - /*! \brief Set cutoff bound on the objective function. - - When using strict comparison, the bound is adjusted by a tolerance to - avoid accidentally cutting off the optimal solution. - */ - void setCutoff(double value) ; - - /// Get the cutoff bound on the objective function - always as minimize - inline double getCutoff() const { //double value ; - //solver_->getDblParam(OsiDualObjectiveLimit,value) ; - //assert( dblParam_[CbcCurrentCutoff]== value * solver_->getObjSense()); - return dblParam_[CbcCurrentCutoff]; - } - - /// Set the \link CbcModel::CbcMaxNumNode maximum node limit \endlink - inline bool setMaximumNodes( int value) { - return setIntParam(CbcMaxNumNode, value); - } - - /// Get the \link CbcModel::CbcMaxNumNode maximum node limit \endlink - inline int getMaximumNodes() const { - return getIntParam(CbcMaxNumNode); - } - - /** Set the - \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink - desired. - */ - inline bool setMaximumSolutions( int value) { - return setIntParam(CbcMaxNumSol, value); - } - /** Get the - \link CbcModel::CbcMaxNumSol maximum number of solutions \endlink - desired. - */ - inline int getMaximumSolutions() const { - return getIntParam(CbcMaxNumSol); - } - /// Set the printing mode - inline bool setPrintingMode( int value) { - return setIntParam(CbcPrinting, value); - } - - /// Get the printing mode - inline int getPrintingMode() const { - return getIntParam(CbcPrinting); - } - - /** Set the - \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink - desired. - */ - inline bool setMaximumSeconds( double value) { - return setDblParam(CbcMaximumSeconds, value); - } - /** Get the - \link CbcModel::CbcMaximumSeconds maximum number of seconds \endlink - desired. - */ - inline double getMaximumSeconds() const { - return getDblParam(CbcMaximumSeconds); - } - /// Current time since start of branchAndbound - double getCurrentSeconds() const ; - - /// Return true if maximum time reached - bool maximumSecondsReached() const ; - - /** Set the - \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink - */ - inline bool setIntegerTolerance( double value) { - return setDblParam(CbcIntegerTolerance, value); - } - /** Get the - \link CbcModel::CbcIntegerTolerance integrality tolerance \endlink - */ - inline double getIntegerTolerance() const { - return getDblParam(CbcIntegerTolerance); - } - - /** Set the - \link CbcModel::CbcInfeasibilityWeight - weight per integer infeasibility \endlink - */ - inline bool setInfeasibilityWeight( double value) { - return setDblParam(CbcInfeasibilityWeight, value); - } - /** Get the - \link CbcModel::CbcInfeasibilityWeight - weight per integer infeasibility \endlink - */ - inline double getInfeasibilityWeight() const { - return getDblParam(CbcInfeasibilityWeight); - } - - /** Set the \link CbcModel::CbcAllowableGap allowable gap \endlink - between the best known solution and the best possible solution. - */ - inline bool setAllowableGap( double value) { - return setDblParam(CbcAllowableGap, value); - } - /** Get the \link CbcModel::CbcAllowableGap allowable gap \endlink - between the best known solution and the best possible solution. - */ - inline double getAllowableGap() const { - return getDblParam(CbcAllowableGap); - } - - /** Set the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink - between the best known solution and the best possible solution. - */ - inline bool setAllowableFractionGap( double value) { - return setDblParam(CbcAllowableFractionGap, value); - } - /** Get the \link CbcModel::CbcAllowableFractionGap fraction allowable gap \endlink - between the best known solution and the best possible solution. - */ - inline double getAllowableFractionGap() const { - return getDblParam(CbcAllowableFractionGap); - } - /** Set the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink - between the best known solution and the best possible solution. - */ - inline bool setAllowablePercentageGap( double value) { - return setDblParam(CbcAllowableFractionGap, value*0.01); - } - /** Get the \link CbcModel::CbcAllowableFractionGap percentage allowable gap \endlink - between the best known solution and the best possible solution. - */ - inline double getAllowablePercentageGap() const { - return 100.0*getDblParam(CbcAllowableFractionGap); - } - /** Set the \link CbcModel::CbcHeuristicGap heuristic gap \endlink - between the best known solution and the best possible solution. - */ - inline bool setHeuristicGap( double value) { - return setDblParam(CbcHeuristicGap, value); - } - /** Get the \link CbcModel::CbcHeuristicGap heuristic gap \endlink - between the best known solution and the best possible solution. - */ - inline double getHeuristicGap() const { - return getDblParam(CbcHeuristicGap); - } - - /** Set the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink - between the best known solution and the best possible solution. - */ - inline bool setHeuristicFractionGap( double value) { - return setDblParam(CbcHeuristicFractionGap, value); - } - /** Get the \link CbcModel::CbcHeuristicFractionGap fraction heuristic gap \endlink - between the best known solution and the best possible solution. - */ - inline double getHeuristicFractionGap() const { - return getDblParam(CbcHeuristicFractionGap); - } - /** Set the - \link CbcModel::CbcCutoffIncrement \endlink - desired. - */ - inline bool setCutoffIncrement( double value) { - return setDblParam(CbcCutoffIncrement, value); - } - /** Get the - \link CbcModel::CbcCutoffIncrement \endlink - desired. - */ - inline double getCutoffIncrement() const { - return getDblParam(CbcCutoffIncrement); - } - /// See if can stop on gap - bool canStopOnGap() const; - - /** Pass in target solution and optional priorities. - If priorities then >0 means only branch if incorrect - while <0 means branch even if correct. +1 or -1 are - highest priority */ - void setHotstartSolution(const double * solution, const int * priorities = NULL) ; - - /// Set the minimum drop to continue cuts - inline void setMinimumDrop(double value) { - minimumDrop_ = value; - } - /// Get the minimum drop to continue cuts - inline double getMinimumDrop() const { - return minimumDrop_; - } - - /** Set the maximum number of cut passes at root node (default 20) - Minimum drop can also be used for fine tuning */ - inline void setMaximumCutPassesAtRoot(int value) { - maximumCutPassesAtRoot_ = value; - } - /** Get the maximum number of cut passes at root node */ - inline int getMaximumCutPassesAtRoot() const { - return maximumCutPassesAtRoot_; - } - - /** Set the maximum number of cut passes at other nodes (default 10) - Minimum drop can also be used for fine tuning */ - inline void setMaximumCutPasses(int value) { - maximumCutPasses_ = value; - } - /** Get the maximum number of cut passes at other nodes (default 10) */ - inline int getMaximumCutPasses() const { - return maximumCutPasses_; - } - /** Get current cut pass number in this round of cuts. - (1 is first pass) */ - inline int getCurrentPassNumber() const { - return currentPassNumber_; - } - /** Set current cut pass number in this round of cuts. - (1 is first pass) */ - inline void setCurrentPassNumber(int value) { - currentPassNumber_ = value; - } - - /** Set the maximum number of candidates to be evaluated for strong - branching. - - A value of 0 disables strong branching. - */ - void setNumberStrong(int number); - /** Get the maximum number of candidates to be evaluated for strong - branching. - */ - inline int numberStrong() const { - return numberStrong_; - } - /** Set global preferred way to branch - -1 down, +1 up, 0 no preference */ - inline void setPreferredWay(int value) { - preferredWay_ = value; - } - /** Get the preferred way to branch (default 0) */ - inline int getPreferredWay() const { - return preferredWay_; - } - /// Get at which depths to do cuts - inline int whenCuts() const { - return whenCuts_; - } - /// Set at which depths to do cuts - inline void setWhenCuts(int value) { - whenCuts_ = value; - } - /** Return true if we want to do cuts - If allowForTopOfTree zero then just does on multiples of depth - if 1 then allows for doing at top of tree - if 2 then says if cuts allowed anywhere apart from root - */ - bool doCutsNow(int allowForTopOfTree) const; - - /** Set the number of branches before pseudo costs believed - in dynamic strong branching. - - A value of 0 disables dynamic strong branching. - */ - void setNumberBeforeTrust(int number); - /** get the number of branches before pseudo costs believed - in dynamic strong branching. */ - inline int numberBeforeTrust() const { - return numberBeforeTrust_; - } - /** Set the number of variables for which to compute penalties - in dynamic strong branching. - - A value of 0 disables penalties. - */ - void setNumberPenalties(int number); - /** get the number of variables for which to compute penalties - in dynamic strong branching. */ - inline int numberPenalties() const { - return numberPenalties_; - } - /// Pointer to top of tree - inline const CbcFullNodeInfo * topOfTree() const - { return topOfTree_;} - /// Number of analyze iterations to do - inline void setNumberAnalyzeIterations(int number) { - numberAnalyzeIterations_ = number; - } - inline int numberAnalyzeIterations() const { - return numberAnalyzeIterations_; - } - /** Get scale factor to make penalties match strong. - Should/will be computed */ - inline double penaltyScaleFactor() const { - return penaltyScaleFactor_; - } - /** Set scale factor to make penalties match strong. - Should/will be computed */ - void setPenaltyScaleFactor(double value); - /** Problem type as set by user or found by analysis. This will be extended - 0 - not known - 1 - Set partitioning <= - 2 - Set partitioning == - 3 - Set covering - 4 - all +- 1 or all +1 and odd - */ - void inline setProblemType(int number) { - problemType_ = number; - } - inline int problemType() const { - return problemType_; - } - /// Current depth - inline int currentDepth() const { - return currentDepth_; - } - - /// Set how often to scan global cuts - void setHowOftenGlobalScan(int number); - /// Get how often to scan global cuts - inline int howOftenGlobalScan() const { - return howOftenGlobalScan_; - } - /// Original columns as created by integerPresolve or preprocessing - inline int * originalColumns() const { - return originalColumns_; - } - /// Set original columns as created by preprocessing - void setOriginalColumns(const int * originalColumns, - int numberGood=COIN_INT_MAX) ; - /// Create conflict cut (well - most of) - OsiRowCut * conflictCut(const OsiSolverInterface * solver, bool & localCuts); - - /** Set the print frequency. - - Controls the number of nodes evaluated between status prints. - If <tt>number <=0</tt> the print frequency is set to 100 nodes for large - problems, 1000 for small problems. - Print frequency has very slight overhead if small. - */ - inline void setPrintFrequency(int number) { - printFrequency_ = number; - } - /// Get the print frequency - inline int printFrequency() const { - return printFrequency_; - } - //@} - - //--------------------------------------------------------------------------- - ///@name Methods returning info on how the solution process terminated - //@{ - /// Are there a numerical difficulties? - bool isAbandoned() const; - /// Is optimality proven? - bool isProvenOptimal() const; - /// Is infeasiblity proven (or none better than cutoff)? - bool isProvenInfeasible() const; - /// Was continuous solution unbounded - bool isContinuousUnbounded() const; - /// Was continuous solution unbounded - bool isProvenDualInfeasible() const; - /// Node limit reached? - bool isNodeLimitReached() const; - /// Time limit reached? - bool isSecondsLimitReached() const; - /// Solution limit reached? - bool isSolutionLimitReached() const; - /// Get how many iterations it took to solve the problem. - inline int getIterationCount() const { - return numberIterations_; - } - /// Increment how many iterations it took to solve the problem. - inline void incrementIterationCount(int value) { - numberIterations_ += value; - } - /// Get how many Nodes it took to solve the problem (including those in complete fathoming B&B inside CLP). - inline int getNodeCount() const { - return numberNodes_; - } - /// Increment how many nodes it took to solve the problem. - inline void incrementNodeCount(int value) { - numberNodes_ += value; - } - /// Get how many Nodes were enumerated in complete fathoming B&B inside CLP - inline int getExtraNodeCount() const { - return numberExtraNodes_; - } - /// Get how many times complete fathoming B&B was done - inline int getFathomCount() const { - return numberFathoms_; - } - /** Final status of problem - Some of these can be found out by is...... functions - -1 before branchAndBound - 0 finished - check isProvenOptimal or isProvenInfeasible to see if solution found - (or check value of best solution) - 1 stopped - on maxnodes, maxsols, maxtime - 2 difficulties so run was abandoned - (5 event user programmed event occurred) - */ - inline int status() const { - return status_; - } - inline void setProblemStatus(int value) { - status_ = value; - } - /** Secondary status of problem - -1 unset (status_ will also be -1) - 0 search completed with solution - 1 linear relaxation not feasible (or worse than cutoff) - 2 stopped on gap - 3 stopped on nodes - 4 stopped on time - 5 stopped on user event - 6 stopped on solutions - 7 linear relaxation unbounded - 8 stopped on iteration limit - */ - inline int secondaryStatus() const { - return secondaryStatus_; - } - inline void setSecondaryStatus(int value) { - secondaryStatus_ = value; - } - /// Are there numerical difficulties (for initialSolve) ? - bool isInitialSolveAbandoned() const ; - /// Is optimality proven (for initialSolve) ? - bool isInitialSolveProvenOptimal() const ; - /// Is primal infeasiblity proven (for initialSolve) ? - bool isInitialSolveProvenPrimalInfeasible() const ; - /// Is dual infeasiblity proven (for initialSolve) ? - bool isInitialSolveProvenDualInfeasible() const ; - - //@} - - //--------------------------------------------------------------------------- - /**@name Problem information methods - - These methods call the solver's query routines to return - information about the problem referred to by the current object. - Querying a problem that has no data associated with it result in - zeros for the number of rows and columns, and NULL pointers from - the methods that return vectors. - - Const pointers returned from any data-query method are valid as - long as the data is unchanged and the solver is not called. - */ - //@{ - /// Number of rows in continuous (root) problem. - inline int numberRowsAtContinuous() const { - return numberRowsAtContinuous_; - } - - /// Get number of columns - inline int getNumCols() const { - return solver_->getNumCols(); - } - - /// Get number of rows - inline int getNumRows() const { - return solver_->getNumRows(); - } - - /// Get number of nonzero elements - inline CoinBigIndex getNumElements() const { - return solver_->getNumElements(); - } - - /// Number of integers in problem - inline int numberIntegers() const { - return numberIntegers_; - } - // Integer variables - inline const int * integerVariable() const { - return integerVariable_; - } - /// Whether or not integer - inline char integerType(int i) const { - assert (integerInfo_); - assert (integerInfo_[i] == 0 || integerInfo_[i] == 1); - return integerInfo_[i]; - } - /// Whether or not integer - inline const char * integerType() const { - return integerInfo_; - } - - /// Get pointer to array[getNumCols()] of column lower bounds - inline const double * getColLower() const { - return solver_->getColLower(); - } - - /// Get pointer to array[getNumCols()] of column upper bounds - inline const double * getColUpper() const { - return solver_->getColUpper(); - } - - /** Get pointer to array[getNumRows()] of row constraint senses. - <ul> - <li>'L': <= constraint - <li>'E': = constraint - <li>'G': >= constraint - <li>'R': ranged constraint - <li>'N': free constraint - </ul> - */ - inline const char * getRowSense() const { - return solver_->getRowSense(); - } - - /** Get pointer to array[getNumRows()] of rows right-hand sides - <ul> - <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] - <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] - <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] - <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0 - </ul> - */ - inline const double * getRightHandSide() const { - return solver_->getRightHandSide(); - } - - /** Get pointer to array[getNumRows()] of row ranges. - <ul> - <li> if rowsense()[i] == 'R' then - rowrange()[i] == rowupper()[i] - rowlower()[i] - <li> if rowsense()[i] != 'R' then - rowrange()[i] is 0.0 - </ul> - */ - inline const double * getRowRange() const { - return solver_->getRowRange(); - } - - /// Get pointer to array[getNumRows()] of row lower bounds - inline const double * getRowLower() const { - return solver_->getRowLower(); - } - - /// Get pointer to array[getNumRows()] of row upper bounds - inline const double * getRowUpper() const { - return solver_->getRowUpper(); - } - - /// Get pointer to array[getNumCols()] of objective function coefficients - inline const double * getObjCoefficients() const { - return solver_->getObjCoefficients(); - } - - /// Get objective function sense (1 for min (default), -1 for max) - inline double getObjSense() const { - //assert (dblParam_[CbcOptimizationDirection]== solver_->getObjSense()); - return dblParam_[CbcOptimizationDirection]; - } - - /// Return true if variable is continuous - inline bool isContinuous(int colIndex) const { - return solver_->isContinuous(colIndex); - } - - /// Return true if variable is binary - inline bool isBinary(int colIndex) const { - return solver_->isBinary(colIndex); - } - - /** Return true if column is integer. - Note: This function returns true if the the column - is binary or a general integer. - */ - inline bool isInteger(int colIndex) const { - return solver_->isInteger(colIndex); - } - - /// Return true if variable is general integer - inline bool isIntegerNonBinary(int colIndex) const { - return solver_->isIntegerNonBinary(colIndex); - } - - /// Return true if variable is binary and not fixed at either bound - inline bool isFreeBinary(int colIndex) const { - return solver_->isFreeBinary(colIndex) ; - } - - /// Get pointer to row-wise copy of matrix - inline const CoinPackedMatrix * getMatrixByRow() const { - return solver_->getMatrixByRow(); - } - - /// Get pointer to column-wise copy of matrix - inline const CoinPackedMatrix * getMatrixByCol() const { - return solver_->getMatrixByCol(); - } - - /// Get solver's value for infinity - inline double getInfinity() const { - return solver_->getInfinity(); - } - /// Get pointer to array[getNumCols()] (for speed) of column lower bounds - inline const double * getCbcColLower() const { - return cbcColLower_; - } - /// Get pointer to array[getNumCols()] (for speed) of column upper bounds - inline const double * getCbcColUpper() const { - return cbcColUpper_; - } - /// Get pointer to array[getNumRows()] (for speed) of row lower bounds - inline const double * getCbcRowLower() const { - return cbcRowLower_; - } - /// Get pointer to array[getNumRows()] (for speed) of row upper bounds - inline const double * getCbcRowUpper() const { - return cbcRowUpper_; - } - /// Get pointer to array[getNumCols()] (for speed) of primal solution vector - inline const double * getCbcColSolution() const { - return cbcColSolution_; - } - /// Get pointer to array[getNumRows()] (for speed) of dual prices - inline const double * getCbcRowPrice() const { - return cbcRowPrice_; - } - /// Get a pointer to array[getNumCols()] (for speed) of reduced costs - inline const double * getCbcReducedCost() const { - return cbcReducedCost_; - } - /// Get pointer to array[getNumRows()] (for speed) of row activity levels. - inline const double * getCbcRowActivity() const { - return cbcRowActivity_; - } - //@} - - - /**@name Methods related to querying the solution */ - //@{ - /// Holds solution at continuous (after cuts if branchAndBound called) - inline double * continuousSolution() const { - return continuousSolution_; - } - /** Array marked whenever a solution is found if non-zero. - Code marks if heuristic returns better so heuristic - need only mark if it wants to on solutions which - are worse than current */ - inline int * usedInSolution() const { - return usedInSolution_; - } - /// Increases usedInSolution for nonzeros - void incrementUsed(const double * solution); - /// Record a new incumbent solution and update objectiveValue - void setBestSolution(CBC_Message how, - double & objectiveValue, const double *solution, - int fixVariables = 0); - /// Just update objectiveValue - void setBestObjectiveValue( double objectiveValue); - /// Deals with event handler and solution - CbcEventHandler::CbcAction dealWithEventHandler(CbcEventHandler::CbcEvent event, - double objValue, - const double * solution); - - /** Call this to really test if a valid solution can be feasible - Solution is number columns in size. - If fixVariables true then bounds of continuous solver updated. - Returns objective value (worse than cutoff if not feasible) - Previously computed objective value is now passed in (in case user does not do solve) - virtual so user can override - */ - virtual double checkSolution(double cutoff, double * solution, - int fixVariables, double originalObjValue); - /** Test the current solution for feasiblility. - - Scan all objects for indications of infeasibility. This is broken down - into simple integer infeasibility (\p numberIntegerInfeasibilities) - and all other reports of infeasibility (\p numberObjectInfeasibilities). - */ - bool feasibleSolution(int & numberIntegerInfeasibilities, - int & numberObjectInfeasibilities) const; - - /** Solution to the most recent lp relaxation. - - The solver's solution to the most recent lp relaxation. - */ - - inline double * currentSolution() const { - return currentSolution_; - } - /** For testing infeasibilities - will point to - currentSolution_ or solver-->getColSolution() - */ - inline const double * testSolution() const { - return testSolution_; - } - inline void setTestSolution(const double * solution) { - testSolution_ = solution; - } - /// Make sure region there and optionally copy solution - void reserveCurrentSolution(const double * solution = NULL); - - /// Get pointer to array[getNumCols()] of primal solution vector - inline const double * getColSolution() const { - return solver_->getColSolution(); - } - - /// Get pointer to array[getNumRows()] of dual prices - inline const double * getRowPrice() const { - return solver_->getRowPrice(); - } - - /// Get a pointer to array[getNumCols()] of reduced costs - inline const double * getReducedCost() const { - return solver_->getReducedCost(); - } - - /// Get pointer to array[getNumRows()] of row activity levels. - inline const double * getRowActivity() const { - return solver_->getRowActivity(); - } - - /// Get current objective function value - inline double getCurrentObjValue() const { - return dblParam_[CbcCurrentObjectiveValue]; - } - /// Get current minimization objective function value - inline double getCurrentMinimizationObjValue() const { - return dblParam_[CbcCurrentMinimizationObjectiveValue]; - } - - /// Get best objective function value as minimization - inline double getMinimizationObjValue() const { - return bestObjective_; - } - /// Set best objective function value as minimization - inline void setMinimizationObjValue(double value) { - bestObjective_ = value; - } - - /// Get best objective function value - inline double getObjValue() const { - return bestObjective_ * solver_->getObjSense() ; - } - /** Get best possible objective function value. - This is better of best possible left on tree - and best solution found. - If called from within branch and cut may be optimistic. - */ - double getBestPossibleObjValue() const; - /// Set best objective function value - inline void setObjValue(double value) { - bestObjective_ = value * solver_->getObjSense() ; - } - /// Get solver objective function value (as minimization) - inline double getSolverObjValue() const { - return solver_->getObjValue() * solver_->getObjSense() ; - } - - /** The best solution to the integer programming problem. - - The best solution to the integer programming problem found during - the search. If no solution is found, the method returns null. - */ - - inline double * bestSolution() const { - return bestSolution_; - } - /** User callable setBestSolution. - If check false does not check valid - If true then sees if feasible and warns if objective value - worse than given (so just set to COIN_DBL_MAX if you don't care). - If check true then does not save solution if not feasible - */ - void setBestSolution(const double * solution, int numberColumns, - double objectiveValue, bool check = false); - - /// Get number of solutions - inline int getSolutionCount() const { - return numberSolutions_; - } - - /// Set number of solutions (so heuristics will be different) - inline void setSolutionCount(int value) { - numberSolutions_ = value; - } - /// Number of saved solutions (including best) - int numberSavedSolutions() const; - /// Maximum number of extra saved solutions - inline int maximumSavedSolutions() const { - return maximumSavedSolutions_; - } - /// Set maximum number of extra saved solutions - void setMaximumSavedSolutions(int value); - /// Return a saved solution (0==best) - NULL if off end - const double * savedSolution(int which) const; - /// Return a saved solution objective (0==best) - COIN_DBL_MAX if off end - double savedSolutionObjective(int which) const; - /// Delete a saved solution and move others up - void deleteSavedSolution(int which); - - /** Current phase (so heuristics etc etc can find out). - 0 - initial solve - 1 - solve with cuts at root - 2 - solve with cuts - 3 - other e.g. strong branching - 4 - trying to validate a solution - 5 - at end of search - */ - inline int phase() const { - return phase_; - } - - /// Get number of heuristic solutions - inline int getNumberHeuristicSolutions() const { - return numberHeuristicSolutions_; - } - /// Set number of heuristic solutions - inline void setNumberHeuristicSolutions(int value) { - numberHeuristicSolutions_ = value; - } - - /// Set objective function sense (1 for min (default), -1 for max,) - inline void setObjSense(double s) { - dblParam_[CbcOptimizationDirection] = s; - solver_->setObjSense(s); - } - - /// Value of objective at continuous - inline double getContinuousObjective() const { - return originalContinuousObjective_; - } - inline void setContinuousObjective(double value) { - originalContinuousObjective_ = value; - } - /// Number of infeasibilities at continuous - inline int getContinuousInfeasibilities() const { - return continuousInfeasibilities_; - } - inline void setContinuousInfeasibilities(int value) { - continuousInfeasibilities_ = value; - } - /// Value of objective after root node cuts added - inline double rootObjectiveAfterCuts() const { - return continuousObjective_; - } - /// Sum of Changes to objective by first solve - inline double sumChangeObjective() const { - return sumChangeObjective1_; - } - /** Number of times global cuts violated. When global cut pool then this - should be kept for each cut and type of cut */ - inline int numberGlobalViolations() const { - return numberGlobalViolations_; - } - inline void clearNumberGlobalViolations() { - numberGlobalViolations_ = 0; - } - /// Whether to force a resolve after takeOffCuts - inline bool resolveAfterTakeOffCuts() const { - return resolveAfterTakeOffCuts_; - } - inline void setResolveAfterTakeOffCuts(bool yesNo) { - resolveAfterTakeOffCuts_ = yesNo; - } - /// Maximum number of rows - inline int maximumRows() const { - return maximumRows_; - } - /// Work basis for temporary use - inline CoinWarmStartBasis & workingBasis() { - return workingBasis_; - } - /// Get number of "iterations" to stop after - inline int getStopNumberIterations() const { - return stopNumberIterations_; - } - /// Set number of "iterations" to stop after - inline void setStopNumberIterations(int value) { - stopNumberIterations_ = value; - } - /// A pointer to model from CbcHeuristic - inline CbcModel * heuristicModel() const - { return heuristicModel_;} - /// Set a pointer to model from CbcHeuristic - inline void setHeuristicModel(CbcModel * model) - { heuristicModel_ = model;} - //@} - - /** \name Node selection */ - //@{ - // Comparison functions (which may be overridden by inheritance) - inline CbcCompareBase * nodeComparison() const { - return nodeCompare_; - } - void setNodeComparison(CbcCompareBase * compare); - void setNodeComparison(CbcCompareBase & compare); - //@} - - /** \name Problem feasibility checking */ - //@{ - // Feasibility functions (which may be overridden by inheritance) - inline CbcFeasibilityBase * problemFeasibility() const { - return problemFeasibility_; - } - void setProblemFeasibility(CbcFeasibilityBase * feasibility); - void setProblemFeasibility(CbcFeasibilityBase & feasibility); - //@} - - /** \name Tree methods and subtree methods */ - //@{ - /// Tree method e.g. heap (which may be overridden by inheritance) - inline CbcTree * tree() const { - return tree_; - } - /// For modifying tree handling (original is cloned) - void passInTreeHandler(CbcTree & tree); - /** For passing in an CbcModel to do a sub Tree (with derived tree handlers). - Passed in model must exist for duration of branch and bound - */ - void passInSubTreeModel(CbcModel & model); - /** For retrieving a copy of subtree model with given OsiSolver. - If no subtree model will use self (up to user to reset cutoff etc). - If solver NULL uses current - */ - CbcModel * subTreeModel(OsiSolverInterface * solver = NULL) const; - /// Returns number of times any subtree stopped on nodes, time etc - inline int numberStoppedSubTrees() const { - return numberStoppedSubTrees_; - } - /// Says a sub tree was stopped - inline void incrementSubTreeStopped() { - numberStoppedSubTrees_++; - } - /** Whether to automatically do presolve before branch and bound (subTrees). - 0 - no - 1 - ordinary presolve - 2 - integer presolve (dodgy) - */ - inline int typePresolve() const { - return presolve_; - } - inline void setTypePresolve(int value) { - presolve_ = value; - } - - //@} - - /** \name Branching Decisions - - See the CbcBranchDecision class for additional information. - */ - //@{ - - /// Get the current branching decision method. - inline CbcBranchDecision * branchingMethod() const { - return branchingMethod_; - } - /// Set the branching decision method. - inline void setBranchingMethod(CbcBranchDecision * method) { - delete branchingMethod_; - branchingMethod_ = method->clone(); - } - /** Set the branching method - - \overload - */ - inline void setBranchingMethod(CbcBranchDecision & method) { - delete branchingMethod_; - branchingMethod_ = method.clone(); - } - /// Get the current cut modifier method - inline CbcCutModifier * cutModifier() const { - return cutModifier_; - } - /// Set the cut modifier method - void setCutModifier(CbcCutModifier * modifier); - /** Set the cut modifier method - - \overload - */ - void setCutModifier(CbcCutModifier & modifier); - //@} - - /** \name Row (constraint) and Column (variable) cut generation */ - //@{ - - /** State of search - 0 - no solution - 1 - only heuristic solutions - 2 - branched to a solution - 3 - no solution but many nodes - */ - inline int stateOfSearch() const { - return stateOfSearch_; - } - inline void setStateOfSearch(int state) { - stateOfSearch_ = state; - } - /// Strategy worked out - mainly at root node for use by CbcNode - inline int searchStrategy() const { - return searchStrategy_; - } - /// Set strategy worked out - mainly at root node for use by CbcNode - inline void setSearchStrategy(int value) { - searchStrategy_ = value; - } - /// Stong branching strategy - inline int strongStrategy() const { - return strongStrategy_; - } - /// Set strong branching strategy - inline void setStrongStrategy(int value) { - strongStrategy_ = value; - } - - /// Get the number of cut generators - inline int numberCutGenerators() const { - return numberCutGenerators_; - } - /// Get the list of cut generators - inline CbcCutGenerator ** cutGenerators() const { - return generator_; - } - ///Get the specified cut generator - inline CbcCutGenerator * cutGenerator(int i) const { - return generator_[i]; - } - ///Get the specified cut generator before any changes - inline CbcCutGenerator * virginCutGenerator(int i) const { - return virginGenerator_[i]; - } - /** Add one generator - up to user to delete generators. - howoften affects how generator is used. 0 or 1 means always, - >1 means every that number of nodes. Negative values have same - meaning as positive but they may be switched off (-> -100) by code if - not many cuts generated at continuous. -99 is just done at root. - Name is just for printout. - If depth >0 overrides how often generator is called (if howOften==-1 or >0). - */ - void addCutGenerator(CglCutGenerator * generator, - int howOften = 1, const char * name = NULL, - bool normal = true, bool atSolution = false, - bool infeasible = false, int howOftenInSub = -100, - int whatDepth = -1, int whatDepthInSub = -1); -//@} - /** \name Strategy and sub models - - See the CbcStrategy class for additional information. - */ - //@{ - - /// Get the current strategy - inline CbcStrategy * strategy() const { - return strategy_; - } - /// Set the strategy. Clones - void setStrategy(CbcStrategy & strategy); - /// Set the strategy. assigns - inline void setStrategy(CbcStrategy * strategy) { - strategy_ = strategy; - } - /// Get the current parent model - inline CbcModel * parentModel() const { - return parentModel_; - } - /// Set the parent model - inline void setParentModel(CbcModel & parentModel) { - parentModel_ = &parentModel; - } - //@} - - - /** \name Heuristics and priorities */ - //@{ - /*! \brief Add one heuristic - up to user to delete - - The name is just used for print messages. - */ - void addHeuristic(CbcHeuristic * generator, const char *name = NULL, - int before = -1); - ///Get the specified heuristic - inline CbcHeuristic * heuristic(int i) const { - return heuristic_[i]; - } - /// Get the number of heuristics - inline int numberHeuristics() const { - return numberHeuristics_; - } - /// Set the number of heuristics - inline void setNumberHeuristics(int value) { - numberHeuristics_ = value; - } - /// Pointer to heuristic solver which found last solution (or NULL) - inline CbcHeuristic * lastHeuristic() const { - return lastHeuristic_; - } - /// set last heuristic which found a solution - inline void setLastHeuristic(CbcHeuristic * last) { - lastHeuristic_ = last; - } - - /** Pass in branching priorities. - - If ifClique then priorities are on cliques otherwise priorities are - on integer variables. - Other type (if exists set to default) - 1 is highest priority. (well actually -INT_MAX is but that's ugly) - If hotstart > 0 then branches are created to force - the variable to the value given by best solution. This enables a - sort of hot start. The node choice should be greatest depth - and hotstart should normally be switched off after a solution. - - If ifNotSimpleIntegers true then appended to normal integers - - This is now deprecated except for simple usage. If user - creates Cbcobjects then set priority in them - - \internal Added for Kurt Spielberg. - */ - void passInPriorities(const int * priorities, bool ifNotSimpleIntegers); - - /// Returns priority level for an object (or 1000 if no priorities exist) - inline int priority(int sequence) const { - return object_[sequence]->priority(); - } - - /*! \brief Set an event handler - - A clone of the handler passed as a parameter is stored in CbcModel. - */ - void passInEventHandler(const CbcEventHandler *eventHandler) ; - - /*! \brief Retrieve a pointer to the event handler */ - inline CbcEventHandler* getEventHandler() const { - return (eventHandler_) ; - } - - //@} - - /**@name Setting/Accessing application data */ - //@{ - /** Set application data. - - This is a pointer that the application can store into and - retrieve from the solver interface. - This field is available for the application to optionally - define and use. - */ - void setApplicationData (void * appData); - - /// Get application data - void * getApplicationData() const; - /** - For advanced applications you may wish to modify the behavior of Cbc - e.g. if the solver is a NLP solver then you may not have an exact - optimum solution at each step. Information could be built into - OsiSolverInterface but this is an alternative so that that interface - does not have to be changed. If something similar is useful to - enough solvers then it could be migrated - You can also pass in by using solver->setAuxiliaryInfo. - You should do that if solver is odd - if solver is normal simplex - then use this. - NOTE - characteristics are not cloned - */ - void passInSolverCharacteristics(OsiBabSolver * solverCharacteristics); - /// Get solver characteristics - inline const OsiBabSolver * solverCharacteristics() const { - return solverCharacteristics_; - } - //@} - - //--------------------------------------------------------------------------- - - /**@name Message handling etc */ - //@{ - /// Pass in Message handler (not deleted at end) - void passInMessageHandler(CoinMessageHandler * handler); - /// Set language - void newLanguage(CoinMessages::Language language); - inline void setLanguage(CoinMessages::Language language) { - newLanguage(language); - } - /// Return handler - inline CoinMessageHandler * messageHandler() const { - return handler_; - } - /// Return messages - inline CoinMessages & messages() { - return messages_; - } - /// Return pointer to messages - inline CoinMessages * messagesPointer() { - return &messages_; - } - /// Set log level - void setLogLevel(int value); - /// Get log level - inline int logLevel() const { - return handler_->logLevel(); - } - /** Set flag to say if handler_ is the default handler. - - The default handler is deleted when the model is deleted. Other - handlers (supplied by the client) will not be deleted. - */ - inline void setDefaultHandler(bool yesNo) { - defaultHandler_ = yesNo; - } - /// Check default handler - inline bool defaultHandler() const { - return defaultHandler_; - } - //@} - //--------------------------------------------------------------------------- - ///@name Specialized - //@{ - - /** - Set special options - 0 bit (1) - check if cuts valid (if on debugger list) - 1 bit (2) - use current basis to check integer solution (rather than all slack) - 2 bit (4) - don't check integer solution (by solving LP) - 3 bit (8) - fast analyze - 4 bit (16) - non-linear model - so no well defined CoinPackedMatrix - 5 bit (32) - keep names - 6 bit (64) - try for dominated columns - 7 bit (128) - SOS type 1 but all declared integer - 8 bit (256) - Set to say solution just found, unset by doing cuts - 9 bit (512) - Try reduced model after 100 nodes - 10 bit (1024) - Switch on some heuristics even if seems unlikely - 11 bit (2048) - Mark as in small branch and bound - 12 bit (4096) - Funny cuts so do slow way (in some places) - 13 bit (8192) - Funny cuts so do slow way (in other places) - 14 bit (16384) - Use Cplex! for fathoming - 15 bit (32768) - Try reduced model after 0 nodes - 16 bit (65536) - Original model had integer bounds - 17 bit (131072) - Perturbation switched off - 18 bit (262144) - donor CbcModel - 19 bit (524288) - recipient CbcModel - 20 bit (1048576) - waiting for sub model to return - 22 bit (4194304) - do not initialize random seed in solver (user has) - 23 bit (8388608) - leave solver_ with cuts - 24 bit (16777216) - just get feasible if no cutoff - */ - inline void setSpecialOptions(int value) { - specialOptions_ = value; - } - /// Get special options - inline int specialOptions() const { - return specialOptions_; - } - /// Set random seed - inline void setRandomSeed(int value) { - randomSeed_ = value; - } - /// Get random seed - inline int getRandomSeed() const { - return randomSeed_; - } - /// Set multiple root tries - inline void setMultipleRootTries(int value) { - multipleRootTries_ = value; - } - /// Get multiple root tries - inline int getMultipleRootTries() const { - return multipleRootTries_; - } - /// Tell model to stop on event - inline void sayEventHappened() - { eventHappened_=true;} - /// Says if normal solver i.e. has well defined CoinPackedMatrix - inline bool normalSolver() const { - return (specialOptions_&16) == 0; - } - /** Says if model is sitting there waiting for mini branch and bound to finish - This is because an event handler may only have access to parent model in - mini branch and bound - */ - inline bool waitingForMiniBranchAndBound() const { - return (specialOptions_&1048576) != 0; - } - /** Set more special options - at present bottom 6 bits used for shadow price mode - 1024 for experimental hotstart - 2048,4096 breaking out of cuts - 8192 slowly increase minimum drop - 16384 gomory - 32768 more heuristics in sub trees - 65536 no cuts in preprocessing - 131072 Time limits elapsed - 18 bit (262144) - Perturb fathom nodes - 19 bit (524288) - No limit on fathom nodes - 20 bit (1048576) - Reduce sum of infeasibilities before cuts - 21 bit (2097152) - Reduce sum of infeasibilities after cuts - 22 bit (4194304) - Conflict analysis - 23 bit (8388608) - Conflict analysis - temporary bit - 24 bit (16777216) - Add cutoff as LP constraint (out) - 25 bit (33554432) - diving/reordering - 26 bit (67108864) - load global cuts from file - 27 bit (134217728) - append binding global cuts to file - 28 bit (268435456) - idiot branching - 29 bit (536870912) - don't make fake objective - 30 bit (1073741824) - Funny SOS or similar - be careful - */ - inline void setMoreSpecialOptions(int value) { - moreSpecialOptions_ = value; - } - /// Get more special options - inline int moreSpecialOptions() const { - return moreSpecialOptions_; - } - /** Set more more special options - 0 bit (1) - find switching variables - 1 bit (2) - using fake objective until solution - 2 bit (4) - switching variables exist - 3 bit (8) - skip most of setBestSolution checks - 4 bit (16) - very lightweight preprocessing in smallB&B - 5 bit (32) - event handler needs to be cloned when parallel - 6 bit (64) - testing - use probing to make cliques - 7/8 bit (128) - try orbital branching (if nauty) - 9 bit (512) - branching on objective (later) - 10 bit (1024) - branching on constraints (later) - 11/12 bit 2048 - intermittent cuts - 13/14 bit 8192 - go to bitter end in strong branching (first time) - */ - inline void setMoreSpecialOptions2(int value) { - moreSpecialOptions2_ = value; - } - /// Get more special options2 - inline int moreSpecialOptions2() const { - return moreSpecialOptions2_; - } - /// Set cutoff as constraint - inline void setCutoffAsConstraint(bool yesNo) { - cutoffRowNumber_ = (yesNo) ? -2 : -1; - } - /// Set time method - inline void setUseElapsedTime(bool yesNo) { - if (yesNo) - moreSpecialOptions_ |= 131072; - else - moreSpecialOptions_ &= ~131072; - } - /// Get time method - inline bool useElapsedTime() const { - return (moreSpecialOptions_&131072)!=0; - } - /// Get useful temporary pointer - inline void * temporaryPointer() const - { return temporaryPointer_;} - /// Set useful temporary pointer - inline void setTemporaryPointer(void * pointer) - { temporaryPointer_=pointer;} - /// Go to dantzig pivot selection if easy problem (clp only) - void goToDantzig(int numberNodes, ClpDualRowPivot *& savePivotMethod); - /// Now we may not own objects - just point to solver's objects - inline bool ownObjects() const { - return ownObjects_; - } - /// Check original model before it gets messed up - void checkModel(); - //@} - //--------------------------------------------------------------------------- - - ///@name Constructors and destructors etc - //@{ - /// Default Constructor - CbcModel(); - - /// Constructor from solver - CbcModel(const OsiSolverInterface &); - - /** Assign a solver to the model (model assumes ownership) - - On return, \p solver will be NULL. - If deleteSolver then current solver deleted (if model owned) - - \note Parameter settings in the outgoing solver are not inherited by - the incoming solver. - */ - void assignSolver(OsiSolverInterface *&solver, bool deleteSolver = true); - - /** \brief Set ownership of solver - - A parameter of false tells CbcModel it does not own the solver and - should not delete it. Once you claim ownership of the solver, you're - responsible for eventually deleting it. Note that CbcModel clones - solvers with abandon. Unless you have a deep understanding of the - workings of CbcModel, the only time you want to claim ownership is when - you're about to delete the CbcModel object but want the solver to - continue to exist (as, for example, when branchAndBound has finished - and you want to hang on to the answer). - */ - inline void setModelOwnsSolver (bool ourSolver) { - ownership_ = ourSolver ? (ownership_ | 0x80000000) : (ownership_ & (~0x80000000)) ; - } - - /*! \brief Get ownership of solver - - A return value of true means that CbcModel owns the solver and will - take responsibility for deleting it when that becomes necessary. - */ - inline bool modelOwnsSolver () { - return ((ownership_&0x80000000) != 0) ; - } - - /** Copy constructor . - If cloneHandler is true then message handler is cloned - */ - CbcModel(const CbcModel & rhs, bool cloneHandler = false); - - /** Clone */ - virtual CbcModel *clone (bool cloneHandler); - - /// Assignment operator - CbcModel & operator=(const CbcModel& rhs); - - /// Destructor - virtual ~CbcModel (); - - /// Returns solver - has current state - inline OsiSolverInterface * solver() const { - return solver_; - } - - /// Returns current solver - sets new one - inline OsiSolverInterface * swapSolver(OsiSolverInterface * solver) { - OsiSolverInterface * returnSolver = solver_; - solver_ = solver; - return returnSolver; - } - - /// Returns solver with continuous state - inline OsiSolverInterface * continuousSolver() const { - return continuousSolver_; - } - - /// Create solver with continuous state - inline void createContinuousSolver() { - continuousSolver_ = solver_->clone(); - } - /// Clear solver with continuous state - inline void clearContinuousSolver() { - delete continuousSolver_; - continuousSolver_ = NULL; - } - - /// A copy of the solver, taken at constructor or by saveReferenceSolver - inline OsiSolverInterface * referenceSolver() const { - return referenceSolver_; - } - - /// Save a copy of the current solver so can be reset to - void saveReferenceSolver(); - - /** Uses a copy of reference solver to be current solver. - Because of possible mismatches all exotic integer information is loat - (apart from normal information in OsiSolverInterface) - so SOS etc and priorities will have to be redone - */ - void resetToReferenceSolver(); - - /// Clears out as much as possible (except solver) - void gutsOfDestructor(); - /** Clears out enough to reset CbcModel as if no branch and bound done - */ - void gutsOfDestructor2(); - /** Clears out enough to reset CbcModel cutoff etc - */ - void resetModel(); - /** Most of copy constructor - mode - 0 copy but don't delete before - 1 copy and delete before - 2 copy and delete before (but use virgin generators) - */ - void gutsOfCopy(const CbcModel & rhs, int mode = 0); - /// Move status, nodes etc etc across - void moveInfo(const CbcModel & rhs); - //@} - - ///@name Multithreading - //@{ - /// Indicates whether Cbc library has been compiled with multithreading support - static bool haveMultiThreadSupport(); - /// Get pointer to masterthread - CbcThread * masterThread() const { - return masterThread_; - } - /// Get pointer to walkback - CbcNodeInfo ** walkback() const { - return walkback_; - } - /// Get number of threads - inline int getNumberThreads() const { - return numberThreads_; - } - /// Set number of threads - inline void setNumberThreads(int value) { - numberThreads_ = value; - } - /// Get thread mode - inline int getThreadMode() const { - return threadMode_; - } - /** Set thread mode - always use numberThreads for branching - 1 set then deterministic - 2 set then use numberThreads for root cuts - 4 set then use numberThreads in root mini branch and bound - 8 set and numberThreads - do heuristics numberThreads at a time - 8 set and numberThreads==0 do all heuristics at once - default is 0 - */ - inline void setThreadMode(int value) { - threadMode_ = value; - } - /** Return - -2 if deterministic threaded and main thread - -1 if deterministic threaded and serial thread - 0 if serial - 1 if opportunistic threaded - */ - inline int parallelMode() const { - if (!numberThreads_) { - if ((threadMode_&1) == 0) - return 0; - else - return -1; - return 0; - } else { - if ((threadMode_&1) == 0) - return 1; - else - return -2; - } - } - /// Thread stuff for master - inline CbcBaseModel * master() const - { return master_;} - /// From here to end of section - code in CbcThread.cpp until class changed - /// Returns true if locked - bool isLocked() const; -#ifdef CBC_THREAD - /** - Locks a thread if parallel so that stuff like cut pool - can be updated and/or used. - */ - void lockThread(); - /** - Unlocks a thread if parallel to say cut pool stuff not needed - */ - void unlockThread(); -#else - inline void lockThread() {} - inline void unlockThread() {} -#endif - /** Set information in a child - -3 pass pointer to child thread info - -2 just stop - -1 delete simple child stuff - 0 delete opportunistic child stuff - 1 delete deterministic child stuff - */ - void setInfoInChild(int type, CbcThread * info); - /** Move/copy information from one model to another - -1 - initialization - 0 - from base model - 1 - to base model (and reset) - 2 - add in final statistics etc (and reset so can do clean destruction) - */ - void moveToModel(CbcModel * baseModel, int mode); - /// Split up nodes - int splitModel(int numberModels, CbcModel ** model, - int numberNodes); - /// Start threads - void startSplitModel(int numberIterations); - /// Merge models - void mergeModels(int numberModel, CbcModel ** model, - int numberNodes); - //@} - - ///@name semi-private i.e. users should not use - //@{ - /// Get how many Nodes it took to solve the problem. - int getNodeCount2() const { - return numberNodes2_; - } - /// Set pointers for speed - void setPointers(const OsiSolverInterface * solver); - /** Perform reduced cost fixing - - Fixes integer variables at their current value based on reduced cost - penalties. Returns number fixed - */ - int reducedCostFix() ; - /** Makes all handlers same. If makeDefault 1 then makes top level - default and rest point to that. If 2 then each is copy - */ - void synchronizeHandlers(int makeDefault); - /// Save a solution to saved list - void saveExtraSolution(const double * solution, double objectiveValue); - /// Save a solution to best and move current to saved - void saveBestSolution(const double * solution, double objectiveValue); - /// Delete best and saved solutions - void deleteSolutions(); - /// Encapsulates solver resolve - int resolve(OsiSolverInterface * solver); -#ifdef CLP_RESOLVE - /// Special purpose resolve - int resolveClp(OsiClpSolverInterface * solver, int type); -#endif - - /** Encapsulates choosing a variable - - anyAction -2, infeasible (-1 round again), 0 done - */ - int chooseBranch(CbcNode * & newNode, int numberPassesLeft, - CbcNode * oldNode, OsiCuts & cuts, - bool & resolved, CoinWarmStartBasis *lastws, - const double * lowerBefore, const double * upperBefore, - OsiSolverBranch * & branches); - int chooseBranch(CbcNode * newNode, int numberPassesLeft, bool & resolved); - - /** Return an empty basis object of the specified size - - A useful utility when constructing a basis for a subproblem from scratch. - The object returned will be of the requested capacity and appropriate for - the solver attached to the model. - */ - CoinWarmStartBasis *getEmptyBasis(int ns = 0, int na = 0) const ; - - /** Remove inactive cuts from the model - - An OsiSolverInterface is expected to maintain a valid basis, but not a - valid solution, when loose cuts are deleted. Restoring a valid solution - requires calling the solver to reoptimise. If it's certain the solution - will not be required, set allowResolve to false to suppress - reoptimisation. - If saveCuts then slack cuts will be saved - On input current cuts are cuts and newCuts - on exit current cuts will be correct. Returns number dropped - */ - int takeOffCuts(OsiCuts &cuts, - bool allowResolve, OsiCuts * saveCuts, - int numberNewCuts = 0, const OsiRowCut ** newCuts = NULL) ; - - /** Determine and install the active cuts that need to be added for - the current subproblem - - The whole truth is a bit more complicated. The first action is a call to - addCuts1(). addCuts() then sorts through the list, installs the tight - cuts in the model, and does bookkeeping (adjusts reference counts). - The basis returned from addCuts1() is adjusted accordingly. - - If it turns out that the node should really be fathomed by bound, - addCuts() simply treats all the cuts as loose as it does the bookkeeping. - - */ - int addCuts(CbcNode * node, CoinWarmStartBasis *&lastws); - - /** Traverse the tree from node to root and prep the model - - addCuts1() begins the job of prepping the model to match the current - subproblem. The model is stripped of all cuts, and the search tree is - traversed from node to root to determine the changes required. Appropriate - bounds changes are installed, a list of cuts is collected but not - installed, and an appropriate basis (minus the cuts, but big enough to - accommodate them) is constructed. - - Returns true if new problem similar to old - - \todo addCuts1() is called in contexts where it's known in advance that - all that's desired is to determine a list of cuts and do the - bookkeeping (adjust the reference counts). The work of installing - bounds and building a basis goes to waste. - */ - bool addCuts1(CbcNode * node, CoinWarmStartBasis *&lastws); - /** Returns bounds just before where - initially original bounds. - Also sets downstream nodes (lower if force 1, upper if 2) - */ - void previousBounds (CbcNode * node, CbcNodeInfo * where, int iColumn, - double & lower, double & upper, int force); - /** Set objective value in a node. This is separated out so that - odd solvers can use. It may look at extra information in - solverCharacteriscs_ and will also use bound from parent node - */ - void setObjectiveValue(CbcNode * thisNode, const CbcNode * parentNode) const; - - /** If numberBeforeTrust >0 then we are going to use CbcBranchDynamic. - Scan and convert CbcSimpleInteger objects - */ - void convertToDynamic(); - /// Set numberBeforeTrust in all objects - void synchronizeNumberBeforeTrust(int type = 0); - /// Zap integer information in problem (may leave object info) - void zapIntegerInformation(bool leaveObjects = true); - /// Use cliques for pseudocost information - return nonzero if infeasible - int cliquePseudoCosts(int doStatistics); - /// Fill in useful estimates - void pseudoShadow(int type); - /** Return pseudo costs - If not all integers or not pseudo costs - returns all zero - Length of arrays are numberIntegers() and entries - correspond to integerVariable()[i] - User must allocate arrays before call - */ - void fillPseudoCosts(double * downCosts, double * upCosts, - int * priority = NULL, - int * numberDown = NULL, int * numberUp = NULL, - int * numberDownInfeasible = NULL, - int * numberUpInfeasible = NULL) const; - /** Do heuristics at root. - 0 - don't delete - 1 - delete - 2 - just delete - don't even use - */ - void doHeuristicsAtRoot(int deleteHeuristicsAfterwards = 0); - /// Adjust heuristics based on model - void adjustHeuristics(); - /// Get the hotstart solution - inline const double * hotstartSolution() const { - return hotstartSolution_; - } - /// Get the hotstart priorities - inline const int * hotstartPriorities() const { - return hotstartPriorities_; - } - - /// Return the list of cuts initially collected for this subproblem - inline CbcCountRowCut ** addedCuts() const { - return addedCuts_; - } - /// Number of entries in the list returned by #addedCuts() - inline int currentNumberCuts() const { - return currentNumberCuts_; - } - /// Global cuts - inline CbcRowCuts * globalCuts() { - return &globalCuts_; - } - /// Get rid of global cuts - inline void zapGlobalCuts() { - globalCuts_ = CbcRowCuts(); - } - /// Copy and set a pointer to a row cut which will be added instead of normal branching. - void setNextRowCut(const OsiRowCut & cut); - /// Get a pointer to current node (be careful) - inline CbcNode * currentNode() const { - return currentNode_; - } - /// Get a pointer to probing info - inline CglTreeProbingInfo * probingInfo() const { - return probingInfo_; - } - /// Thread specific random number generator - inline CoinThreadRandom * randomNumberGenerator() { - return &randomNumberGenerator_; - } - /// Set the number of iterations done in strong branching. - inline void setNumberStrongIterations(int number) { - numberStrongIterations_ = number; - } - /// Get the number of iterations done in strong branching. - inline int numberStrongIterations() const { - return numberStrongIterations_; - } - /// Get maximum number of iterations (designed to be used in heuristics) - inline int maximumNumberIterations() const { - return maximumNumberIterations_; - } - /// Set maximum number of iterations (designed to be used in heuristics) - inline void setMaximumNumberIterations(int value) { - maximumNumberIterations_ = value; - } - /// Symmetry information - inline CbcSymmetry * symmetryInfo() const - { return symmetryInfo_;} - /// Set depth for fast nodes - inline void setFastNodeDepth(int value) { - fastNodeDepth_ = value; - } - /// Get depth for fast nodes - inline int fastNodeDepth() const { - return fastNodeDepth_; - } - /// Get anything with priority >= this can be treated as continuous - inline int continuousPriority() const { - return continuousPriority_; - } - /// Set anything with priority >= this can be treated as continuous - inline void setContinuousPriority(int value) { - continuousPriority_ = value; - } - inline void incrementExtra(int nodes, int iterations, int fathoms=1) { - numberExtraNodes_ += nodes; - numberExtraIterations_ += iterations; - numberFathoms_ += fathoms; - } - /// Zero extra - inline void zeroExtra() { - numberExtraNodes_ = 0; - numberExtraIterations_ = 0; - numberFathoms_ = 0; - } - /// Number of extra iterations - inline int numberExtraIterations() const { - return numberExtraIterations_; - } - /// Increment strong info - void incrementStrongInfo(int numberTimes, int numberIterations, - int numberFixed, bool ifInfeasible); - /// Return strong info - inline const int * strongInfo() const { - return strongInfo_; - } - - /// Return mutable strong info - inline int * mutableStrongInfo() { - return strongInfo_; - } - /// Get stored row cuts for donor/recipient CbcModel - CglStored * storedRowCuts() const { - return storedRowCuts_; - } - /// Set stored row cuts for donor/recipient CbcModel - void setStoredRowCuts(CglStored * cuts) { - storedRowCuts_ = cuts; - } - /// Says whether all dynamic integers - inline bool allDynamic () const { - return ((ownership_&0x40000000) != 0) ; - } - /// Create C++ lines to get to current state - void generateCpp( FILE * fp, int options); - /// Generate an OsiBranchingInformation object - OsiBranchingInformation usefulInformation() const; - /** Warm start object produced by heuristic or strong branching - - If get a valid integer solution outside branch and bound then it can take - a reasonable time to solve LP which produces clean solution. If this object has - any size then it will be used in solve. - */ - inline void setBestSolutionBasis(const CoinWarmStartBasis & bestSolutionBasis) { - bestSolutionBasis_ = bestSolutionBasis; - } - /// Redo walkback arrays - void redoWalkBack(); - //@} - - void setMIPStart( const std::vector< std::pair< std::string, double > > &mips ) { - this->mipStart_ = mips; - } - - const std::vector< std::pair< std::string, double > > &getMIPStart() { - return this->mipStart_; - } - - -//--------------------------------------------------------------------------- - -private: - ///@name Private member data - //@{ - - /// The solver associated with this model. - OsiSolverInterface * solver_; - - /** Ownership of objects and other stuff - - 0x80000000 model owns solver - 0x40000000 all variables CbcDynamicPseudoCost - */ - unsigned int ownership_ ; - - /// A copy of the solver, taken at the continuous (root) node. - OsiSolverInterface * continuousSolver_; - - /// A copy of the solver, taken at constructor or by saveReferenceSolver - OsiSolverInterface * referenceSolver_; - - /// Message handler - CoinMessageHandler * handler_; - - /** Flag to say if handler_ is the default handler. - - The default handler is deleted when the model is deleted. Other - handlers (supplied by the client) will not be deleted. - */ - bool defaultHandler_; - - /// Cbc messages - CoinMessages messages_; - - /// Array for integer parameters - int intParam_[CbcLastIntParam]; - - /// Array for double parameters - double dblParam_[CbcLastDblParam]; - - /** Pointer to an empty warm start object - - It turns out to be useful to have this available as a base from - which to build custom warm start objects. This is typed as CoinWarmStart - rather than CoinWarmStartBasis to allow for the possibility that a - client might want to apply a solver that doesn't use a basis-based warm - start. See getEmptyBasis for an example of how this field can be used. - */ - mutable CoinWarmStart *emptyWarmStart_ ; - - /// Best objective - double bestObjective_; - /// Best possible objective - double bestPossibleObjective_; - /// Sum of Changes to objective by first solve - double sumChangeObjective1_; - /// Sum of Changes to objective by subsequent solves - double sumChangeObjective2_; - - /// Array holding the incumbent (best) solution. - double * bestSolution_; - /// Arrays holding other solutions. - double ** savedSolutions_; - - /** Array holding the current solution. - - This array is used more as a temporary. - */ - double * currentSolution_; - /** For testing infeasibilities - will point to - currentSolution_ or solver-->getColSolution() - */ - mutable const double * testSolution_; - /** MIPstart values - values for integer variables which will be converted to a complete integer initial feasible solution - */ - std::vector< std::pair< std::string, double > > mipStart_; - /** Warm start object produced by heuristic or strong branching - - If get a valid integer solution outside branch and bound then it can take - a reasonable time to solve LP which produces clean solution. If this object has - any size then it will be used in solve. - */ - CoinWarmStartBasis bestSolutionBasis_ ; - /// Global cuts - CbcRowCuts globalCuts_; - /// Global conflict cuts - CbcRowCuts * globalConflictCuts_; - - /// Minimum degradation in objective value to continue cut generation - double minimumDrop_; - /// Number of solutions - int numberSolutions_; - /// Number of saved solutions - int numberSavedSolutions_; - /// Maximum number of saved solutions - int maximumSavedSolutions_; - /** State of search - 0 - no solution - 1 - only heuristic solutions - 2 - branched to a solution - 3 - no solution but many nodes - */ - int stateOfSearch_; - /// At which depths to do cuts - int whenCuts_; - /// Hotstart solution - double * hotstartSolution_; - /// Hotstart priorities - int * hotstartPriorities_; - /// Number of heuristic solutions - int numberHeuristicSolutions_; - /// Cumulative number of nodes - int numberNodes_; - /** Cumulative number of nodes for statistics. - Must fix to match up - */ - int numberNodes2_; - /// Cumulative number of iterations - int numberIterations_; - /// Cumulative number of solves - int numberSolves_; - /// Status of problem - 0 finished, 1 stopped, 2 difficulties - int status_; - /** Secondary status of problem - -1 unset (status_ will also be -1) - 0 search completed with solution - 1 linear relaxation not feasible (or worse than cutoff) - 2 stopped on gap - 3 stopped on nodes - 4 stopped on time - 5 stopped on user event - 6 stopped on solutions - */ - int secondaryStatus_; - /// Number of integers in problem - int numberIntegers_; - /// Number of rows at continuous - int numberRowsAtContinuous_; - /** - -1 - cutoff as constraint not activated - -2 - waiting to activate - >=0 - activated - */ - int cutoffRowNumber_; - /// Maximum number of cuts - int maximumNumberCuts_; - /** Current phase (so heuristics etc etc can find out). - 0 - initial solve - 1 - solve with cuts at root - 2 - solve with cuts - 3 - other e.g. strong branching - 4 - trying to validate a solution - 5 - at end of search - */ - int phase_; - - /// Number of entries in #addedCuts_ - int currentNumberCuts_; - - /** Current limit on search tree depth - - The allocated size of #walkback_. Increased as needed. - */ - int maximumDepth_; - /** Array used to assemble the path between a node and the search tree root - - The array is resized when necessary. #maximumDepth_ is the current - allocated size. - */ - CbcNodeInfo ** walkback_; - CbcNodeInfo ** lastNodeInfo_; - const OsiRowCut ** lastCut_; - int lastDepth_; - int lastNumberCuts2_; - int maximumCuts_; - int * lastNumberCuts_; - - /** The list of cuts initially collected for this subproblem - - When the subproblem at this node is rebuilt, a set of cuts is collected - for inclusion in the constraint system. If any of these cuts are - subsequently removed because they have become loose, the corresponding - entry is set to NULL. - */ - CbcCountRowCut ** addedCuts_; - - /** A pointer to a row cut which will be added instead of normal branching. - After use it should be set to NULL. - */ - OsiRowCut * nextRowCut_; - - /// Current node so can be used elsewhere - CbcNode * currentNode_; - - /// Indices of integer variables - int * integerVariable_; - /// Whether of not integer - char * integerInfo_; - /// Holds solution at continuous (after cuts) - double * continuousSolution_; - /// Array marked whenever a solution is found if non-zero - int * usedInSolution_; - /** - Special options - 0 bit (1) - check if cuts valid (if on debugger list) - 1 bit (2) - use current basis to check integer solution (rather than all slack) - 2 bit (4) - don't check integer solution (by solving LP) - 3 bit (8) - fast analyze - 4 bit (16) - non-linear model - so no well defined CoinPackedMatrix - 5 bit (32) - keep names - 6 bit (64) - try for dominated columns - 7 bit (128) - SOS type 1 but all declared integer - 8 bit (256) - Set to say solution just found, unset by doing cuts - 9 bit (512) - Try reduced model after 100 nodes - 10 bit (1024) - Switch on some heuristics even if seems unlikely - 11 bit (2048) - Mark as in small branch and bound - 12 bit (4096) - Funny cuts so do slow way (in some places) - 13 bit (8192) - Funny cuts so do slow way (in other places) - 14 bit (16384) - Use Cplex! for fathoming - 15 bit (32768) - Try reduced model after 0 nodes - 16 bit (65536) - Original model had integer bounds - 17 bit (131072) - Perturbation switched off - 18 bit (262144) - donor CbcModel - 19 bit (524288) - recipient CbcModel - 20 bit (1048576) - waiting for sub model to return - 22 bit (4194304) - do not initialize random seed in solver (user has) - 23 bit (8388608) - leave solver_ with cuts - 24 bit (16777216) - just get feasible if no cutoff - */ - int specialOptions_; - /** More special options - at present bottom 6 bits used for shadow price mode - 1024 for experimental hotstart - 2048,4096 breaking out of cuts - 8192 slowly increase minimum drop - 16384 gomory - 32768 more heuristics in sub trees - 65536 no cuts in preprocessing - 131072 Time limits elapsed - 18 bit (262144) - Perturb fathom nodes - 19 bit (524288) - No limit on fathom nodes - 20 bit (1048576) - Reduce sum of infeasibilities before cuts - 21 bit (2097152) - Reduce sum of infeasibilities after cuts - */ - int moreSpecialOptions_; - /** More more special options - 0 bit (1) - find switching variables - 1 bit (2) - using fake objective until solution - 2 bit (4) - switching variables exist - 3 bit (8) - skip most of setBestSolution checks - 4 bit (16) - very lightweight preprocessing in smallB&B - 5 bit (32) - event handler needs to be cloned when parallel - 6 bit (64) - testing - use probing to make cliques - 7/8 bit (128) - try orbital branching (if nauty) - 9 bit (512) - branching on objective (later) - 10 bit (1024) - branching on constraints (later) - 11/12 bit 2048 - intermittent cuts - */ - int moreSpecialOptions2_; - /// User node comparison function - CbcCompareBase * nodeCompare_; - /// User feasibility function (see CbcFeasibleBase.hpp) - CbcFeasibilityBase * problemFeasibility_; - /// Tree - CbcTree * tree_; - /// Pointer to top of tree - CbcFullNodeInfo * topOfTree_; - /// A pointer to model to be used for subtrees - CbcModel * subTreeModel_; - /// A pointer to model from CbcHeuristic - CbcModel * heuristicModel_; - /// Number of times any subtree stopped on nodes, time etc - int numberStoppedSubTrees_; - /// Variable selection function - CbcBranchDecision * branchingMethod_; - /// Cut modifier function - CbcCutModifier * cutModifier_; - /// Strategy - CbcStrategy * strategy_; - /// Parent model - CbcModel * parentModel_; - /** Whether to automatically do presolve before branch and bound. - 0 - no - 1 - ordinary presolve - 2 - integer presolve (dodgy) - */ - /// Pointer to array[getNumCols()] (for speed) of column lower bounds - const double * cbcColLower_; - /// Pointer to array[getNumCols()] (for speed) of column upper bounds - const double * cbcColUpper_; - /// Pointer to array[getNumRows()] (for speed) of row lower bounds - const double * cbcRowLower_; - /// Pointer to array[getNumRows()] (for speed) of row upper bounds - const double * cbcRowUpper_; - /// Pointer to array[getNumCols()] (for speed) of primal solution vector - const double * cbcColSolution_; - /// Pointer to array[getNumRows()] (for speed) of dual prices - const double * cbcRowPrice_; - /// Get a pointer to array[getNumCols()] (for speed) of reduced costs - const double * cbcReducedCost_; - /// Pointer to array[getNumRows()] (for speed) of row activity levels. - const double * cbcRowActivity_; - /// Pointer to user-defined data structure - void * appData_; - /// Presolve for CbcTreeLocal - int presolve_; - /** Maximum number of candidates to consider for strong branching. - To disable strong branching, set this to 0. - */ - int numberStrong_; - /** \brief The number of branches before pseudo costs believed - in dynamic strong branching. - - A value of 0 is off. - */ - int numberBeforeTrust_; - /** \brief The number of variables for which to compute penalties - in dynamic strong branching. - */ - int numberPenalties_; - /// For threads - stop after this many "iterations" - int stopNumberIterations_; - /** Scale factor to make penalties match strong. - Should/will be computed */ - double penaltyScaleFactor_; - /// Number of analyze iterations to do - int numberAnalyzeIterations_; - /// Arrays with analysis results - double * analyzeResults_; - /// Useful temporary pointer - void * temporaryPointer_; - /// Number of nodes infeasible by normal branching (before cuts) - int numberInfeasibleNodes_; - /** Problem type as set by user or found by analysis. This will be extended - 0 - not known - 1 - Set partitioning <= - 2 - Set partitioning == - 3 - Set covering - */ - int problemType_; - /// Print frequency - int printFrequency_; - /// Number of cut generators - int numberCutGenerators_; - // Cut generators - CbcCutGenerator ** generator_; - // Cut generators before any changes - CbcCutGenerator ** virginGenerator_; - /// Number of heuristics - int numberHeuristics_; - /// Heuristic solvers - CbcHeuristic ** heuristic_; - /// Pointer to heuristic solver which found last solution (or NULL) - CbcHeuristic * lastHeuristic_; - /// Depth for fast nodes - int fastNodeDepth_; - /*! Pointer to the event handler */ -# ifdef CBC_ONLY_CLP - ClpEventHandler *eventHandler_ ; -# else - CbcEventHandler *eventHandler_ ; -# endif - /// Symmetry information - CbcSymmetry * symmetryInfo_; - /// Total number of objects - int numberObjects_; - - /** \brief Integer and Clique and ... information - - \note The code assumes that the first objects on the list will be - SimpleInteger objects for each integer variable, followed by - Clique objects. Portions of the code that understand Clique objects - will fail if they do not immediately follow the SimpleIntegers. - Large chunks of the code will fail if the first objects are not - SimpleInteger. As of 2003.08, SimpleIntegers and Cliques are the only - objects. - */ - OsiObject ** object_; - /// Now we may not own objects - just point to solver's objects - bool ownObjects_; - - /// Original columns as created by integerPresolve or preprocessing - int * originalColumns_; - /// How often to scan global cuts - int howOftenGlobalScan_; - /** Number of times global cuts violated. When global cut pool then this - should be kept for each cut and type of cut */ - int numberGlobalViolations_; - /// Number of extra iterations in fast lp - int numberExtraIterations_; - /// Number of extra nodes in fast lp - int numberExtraNodes_; - /// Number of times fast lp entered - int numberFathoms_; - /** Value of objective at continuous - (Well actually after initial round of cuts) - */ - double continuousObjective_; - /** Value of objective before root node cuts added - */ - double originalContinuousObjective_; - /// Number of infeasibilities at continuous - int continuousInfeasibilities_; - /// Maximum number of cut passes at root - int maximumCutPassesAtRoot_; - /// Maximum number of cut passes - int maximumCutPasses_; - /// Preferred way of branching - int preferredWay_; - /// Current cut pass number - int currentPassNumber_; - /// Maximum number of cuts (for whichGenerator_) - int maximumWhich_; - /// Maximum number of rows - int maximumRows_; - /// Random seed - int randomSeed_; - /// Multiple root tries - int multipleRootTries_; - /// Current depth - int currentDepth_; - /// Thread specific random number generator - mutable CoinThreadRandom randomNumberGenerator_; - /// Work basis for temporary use - CoinWarmStartBasis workingBasis_; - /// Which cut generator generated this cut - int * whichGenerator_; - /// Maximum number of statistics - int maximumStatistics_; - /// statistics - CbcStatistics ** statistics_; - /// Maximum depth reached - int maximumDepthActual_; - /// Number of reduced cost fixings - double numberDJFixed_; - /// Probing info - CglTreeProbingInfo * probingInfo_; - /// Number of fixed by analyze at root - int numberFixedAtRoot_; - /// Number fixed by analyze so far - int numberFixedNow_; - /// Whether stopping on gap - bool stoppedOnGap_; - /// Whether event happened - mutable bool eventHappened_; - /// Number of long strong goes - int numberLongStrong_; - /// Number of old active cuts - int numberOldActiveCuts_; - /// Number of new cuts - int numberNewCuts_; - /// Strategy worked out - mainly at root node - int searchStrategy_; - /** Strategy for strong branching - 0 - normal - when to do all fractional - 1 - root node - 2 - depth less than modifier - 4 - if objective == best possible - 6 - as 2+4 - when to do all including satisfied - 10 - root node etc. - If >=100 then do when depth <= strategy/100 (otherwise 5) - */ - int strongStrategy_; - /// Number of iterations in strong branching - int numberStrongIterations_; - /** 0 - number times strong branching done, 1 - number fixed, 2 - number infeasible - Second group of three is a snapshot at node [6] */ - int strongInfo_[7]; - /** - For advanced applications you may wish to modify the behavior of Cbc - e.g. if the solver is a NLP solver then you may not have an exact - optimum solution at each step. This gives characteristics - just for one BAB. - For actually saving/restoring a solution you need the actual solver one. - */ - OsiBabSolver * solverCharacteristics_; - /// Whether to force a resolve after takeOffCuts - bool resolveAfterTakeOffCuts_; - /// Maximum number of iterations (designed to be used in heuristics) - int maximumNumberIterations_; - /// Anything with priority >= this can be treated as continuous - int continuousPriority_; - /// Number of outstanding update information items - int numberUpdateItems_; - /// Maximum number of outstanding update information items - int maximumNumberUpdateItems_; - /// Update items - CbcObjectUpdateData * updateItems_; - /// Stored row cuts for donor/recipient CbcModel - CglStored * storedRowCuts_; - /** - Parallel - 0 - off - 1 - testing - 2-99 threads - other special meanings - */ - int numberThreads_; - /** thread mode - always use numberThreads for branching - 1 set then deterministic - 2 set then use numberThreads for root cuts - 4 set then use numberThreads in root mini branch and bound - default is 0 - */ - int threadMode_; - /// Number of global cuts on entry to a node - int numberGlobalCutsIn_; - /// Thread stuff for master - CbcBaseModel * master_; - /// Pointer to masterthread - CbcThread * masterThread_; -//@} -}; -/// So we can use osiObject or CbcObject during transition -void getIntegerInformation(const OsiObject * object, double & originalLower, - double & originalUpper) ; -// So we can call from other programs -// Real main program -class OsiClpSolverInterface; -int CbcMain (int argc, const char *argv[], OsiClpSolverInterface & solver, CbcModel ** babSolver); -int CbcMain (int argc, const char *argv[], CbcModel & babSolver); -// four ways of calling -int callCbc(const char * input2, OsiClpSolverInterface& solver1); -int callCbc(const char * input2); -int callCbc(const std::string input2, OsiClpSolverInterface& solver1); -int callCbc(const std::string input2) ; -// When we want to load up CbcModel with options first -void CbcMain0 (CbcModel & babSolver); -int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver); -// two ways of calling -int callCbc(const char * input2, CbcModel & babSolver); -int callCbc(const std::string input2, CbcModel & babSolver); -// And when CbcMain0 already called to initialize -int callCbc1(const char * input2, CbcModel & babSolver); -int callCbc1(const std::string input2, CbcModel & babSolver); -// And when CbcMain0 already called to initialize (with call back) (see CbcMain1 for whereFrom) -int callCbc1(const char * input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); -int callCbc1(const std::string input2, CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); -int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom)); -// For uniform setting of cut and heuristic options -void setCutAndHeuristicOptions(CbcModel & model); -#endif - |