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, 2952 insertions, 0 deletions
diff --git a/newstructure/thirdparty/linux/include/coin/CbcModel.hpp b/newstructure/thirdparty/linux/include/coin/CbcModel.hpp new file mode 100644 index 0000000..ceef661 --- /dev/null +++ b/newstructure/thirdparty/linux/include/coin/CbcModel.hpp @@ -0,0 +1,2952 @@ +/* $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 + |