summaryrefslogtreecommitdiff
path: root/thirdparty/linux/include/coin/CbcModel.hpp
diff options
context:
space:
mode:
authorGeorgey2017-07-05 11:40:43 +0530
committerGeorgey2017-07-05 11:40:43 +0530
commit938fef4a37a7b7c61b4b6ff74cb4cfd2f100c427 (patch)
treeb343c0ee5609433c80e0de1db8b6886c9126dc2d /thirdparty/linux/include/coin/CbcModel.hpp
parent5b72577efe080c5294b32d804e4d26351fef30bc (diff)
downloadFOSSEE-Optimization-toolbox-938fef4a37a7b7c61b4b6ff74cb4cfd2f100c427.tar.gz
FOSSEE-Optimization-toolbox-938fef4a37a7b7c61b4b6ff74cb4cfd2f100c427.tar.bz2
FOSSEE-Optimization-toolbox-938fef4a37a7b7c61b4b6ff74cb4cfd2f100c427.zip
Added linux shared libraries and header files for int and ecos functions
Diffstat (limited to 'thirdparty/linux/include/coin/CbcModel.hpp')
-rw-r--r--thirdparty/linux/include/coin/CbcModel.hpp2952
1 files changed, 2952 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/CbcModel.hpp b/thirdparty/linux/include/coin/CbcModel.hpp
new file mode 100644
index 0000000..ceef661
--- /dev/null
+++ b/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
+
generated by cgit (git 2.34.1) at 2024-12-22 09:45:31 +0000