diff options
Diffstat (limited to 'thirdparty/linux/include/coin/BonBabSetupBase.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin/BonBabSetupBase.hpp | 386 |
1 files changed, 386 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin/BonBabSetupBase.hpp b/thirdparty/linux/include/coin/BonBabSetupBase.hpp new file mode 100644 index 0000000..c51c67c --- /dev/null +++ b/thirdparty/linux/include/coin/BonBabSetupBase.hpp @@ -0,0 +1,386 @@ +// (C) Copyright International Business Machines Corporation 2007 +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// Authors : +// Pierre Bonami, International Business Machines Corporation +// +// Date : 04/12/2007 + +#ifndef BabSetupBase_H +#define BabSetupBase_H + +#include <string> +#include <list> +#include "CglCutGenerator.hpp" +#include "CbcHeuristic.hpp" +#include "OsiChooseVariable.hpp" +#include "BonOsiTMINLPInterface.hpp" +#include "IpSmartPtr.hpp" +#include "BonTMINLP2OsiLP.hpp" + +namespace Bonmin +{ + /** A class to have all elements necessary to setup a branch-and-bound.*/ + class BabSetupBase + { + public: + /** Type for cut generation method with its frequency and string identification. */ + struct CuttingMethod + { + int frequency; + std::string id; + CglCutGenerator * cgl; + bool atSolution; + bool normal; + bool always; + CuttingMethod(): + atSolution(false), + normal(true), + always(false) + {} + + CuttingMethod(const CuttingMethod & other): + frequency(other.frequency), + id(other.id), + cgl(other.cgl), + atSolution(other.atSolution), + normal(other.normal), + always(other.always) + {} + }; + /** Type for heuristic method with its string identification. */ + struct HeuristicMethod + { + std::string id; + CbcHeuristic* heuristic; + HeuristicMethod() + {} + + HeuristicMethod(const HeuristicMethod & other): + id(other.id), + heuristic(other.heuristic) + {} + }; + typedef std::list<CuttingMethod> CuttingMethods; + typedef std::list<HeuristicMethod > HeuristicMethods; + + /** Strategies for comparing the nodes on the heap. */ + enum NodeComparison { + bestBound = 0 /** Best bound*/, + DFS /** Depth First Search*/, + BFS /** Best First Search */, + dynamic /** Dynamic strategy, see <a href="http://www.coin-or.org/Doxygen/Cbc/class_cbc_branch_dynamic_decision.html"> + CbcBranchActual.hpp </a> for explanations.*/, + bestGuess /** Best guessed integer solution is subtree below, based on pseudo costs */ + }; + + /** Strategies for traversing the tree.*/ + enum TreeTraversal { + HeapOnly=0 /** Only using the heap, uses CbcTree.*/, + DiveFromBest /** dive from top node of the heap untill it gets to a leaf of the tree. Uses Bonmin::CbcDiver.*/, + ProbedDive /** Eplore two kids before following on dive.*/, + DfsDiveFromBest /** dive from top node of the heap with more elaborate strategy (see options doc). Uses Bonmin::CbcDfsDiver.*/, + DfsDiveDynamic /** Same as DfsDiveFromBest, but after a prescribed number of integer solution are found switch to best-bound and if too many node switches to depth-first. Uses Bonmin::CbcDfsDiver.*/ + }; + + + /** @name Enums for optionslist parameters */ + enum VarSelectStra_Enum { + MOST_FRACTIONAL=0, + STRONG_BRANCHING, + RELIABILITY_BRANCHING, +#ifdef BONMIN_CURVATURE_BRANCHING + CURVATURE_ESTIMATOR, +#endif + QP_STRONG_BRANCHING, + LP_STRONG_BRANCHING, + NLP_STRONG_BRANCHING, + OSI_SIMPLE, + OSI_STRONG, + RANDOM + }; + + /** Parameters represented by an integer. */ + enum IntParameter{ + BabLogLevel = 0 /** Log level of main branch-and-bound*/, + BabLogInterval/** Display information every logIntervval nodes.*/, + MaxFailures /** Max number of failures in a branch.*/, + FailureBehavior /** Behavior of the algorithm in the case of a failure.*/, + MaxInfeasible /** Max number of consecutive infeasible problem in a branch + before fathoming.*/, + NumberStrong /** Number of candidates for strong branching.*/, + MinReliability /** Minimum reliability before trust pseudo-costs.*/, + MaxNodes /** Global node limit.*/, + MaxSolutions /** limit on number of integer feasible solution.*/, + MaxIterations /** Global iteration limit. */, + SpecialOption /** Spetial option in particular for Cbc. */, + DisableSos /** Consider or not SOS constraints.*/, + NumCutPasses/** Number of cut passes at nodes.*/, + NumCutPassesAtRoot/** Number of cut passes at nodes.*/, + RootLogLevel/** Log level for root relaxation.*/, + NumberIntParam /** Dummy end to size table*/ + }; + + + /** Parameters represented by a double.*/ + enum DoubleParameter{ + CutoffDecr = 0 /** Amount by which cutoff is incremented */, + Cutoff /** cutoff value */, + AllowableGap /** Stop if absolute gap is less than this. */, + AllowableFractionGap /** Stop if relative gap is less than this.*/, + IntTol /** Integer tolerance.*/, + MaxTime /** Global time limit. */, + NumberDoubleParam /** Dummy end to size table*/ + }; + + /** Default constructor. */ + BabSetupBase(const CoinMessageHandler * handler = NULL); + + /** Construct from existing tminlp. */ + BabSetupBase(Ipopt::SmartPtr<TMINLP> tminlp, const CoinMessageHandler * handler = NULL); + /** Construct from existing application.*/ + BabSetupBase(Ipopt::SmartPtr<TNLPSolver> app); + /** Construct from existing TMINLP interface.*/ + BabSetupBase(const OsiTMINLPInterface& nlp); + /** Copy but uses an other nlp.*/ + BabSetupBase(const BabSetupBase &setup, + OsiTMINLPInterface &nlp); + + /** Copy but uses an other nlp.*/ + BabSetupBase(const BabSetupBase &setup, + OsiTMINLPInterface &nlp, + const std::string &prefix); + + /** Copy constructor. */ + BabSetupBase(const BabSetupBase & other); + + /** virtual copy constructor. */ + virtual BabSetupBase * clone() const = 0; + + /** Make a copy with solver replace by one passed .*/ + virtual BabSetupBase *clone(OsiTMINLPInterface&nlp)const; + /** Virtual destructor. */ + virtual ~BabSetupBase(); + + /** @name Methods to initialize algorithm with various inputs. */ + /** @{ */ + /** use existing TMINLP interface (containing the options).*/ + void use(const OsiTMINLPInterface& nlp); + /** Read options (if not done before) and create interface using tminlp.*/ + void use(Ipopt::SmartPtr<TMINLP> tminlp ); + /** use specific instanciation of a TMINLP2TNLP.*/ + void use(Ipopt::SmartPtr<TMINLP2TNLP> prob); + /** Set the non-linear solver used */ + void setNonlinearSolver(OsiTMINLPInterface * s) + { + nonlinearSolver_ = s; + } + /** @} */ + + /** @name Methods to manipulate options. */ + /** @{ */ + /** Register all the options for this algorithm instance.*/ + virtual void registerOptions(); + /** Setup the defaults options for this algorithm. */ + virtual void setBabDefaultOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions) + {} + /** Register all the options for this algorithm instance.*/ + static void registerAllOptions(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions); + + /** Get the options from default text file (bonmin.opt) if don't already have them.*/ + virtual void readOptionsFile() + { + if (readOptions_) return; + readOptionsFile("bonmin.opt"); + } + + /** Get the options from given fileName */ + void readOptionsFile(std::string fileName); + + /** Get the options from long string containing all.*/ + void readOptionsString(std::string opt_string); + + /** Get the options from stream.*/ + void readOptionsStream(std::istream& is); + + /** May print documentation of options if options print_options_documentation is set to yes.*/ + void mayPrintDoc(); + + + /** Get prefix to use for options.*/ + const char * prefix() const { + return prefix_.c_str(); + } + + /** Set the value for options, output...*/ + void setOptionsAndJournalist(Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions, + Ipopt::SmartPtr<Ipopt::OptionsList> options, + Ipopt::SmartPtr<Ipopt::Journalist> journalist) + { + options_ = options; + roptions_ = roptions; + journalist_ = journalist; + } + + /** Initialize the options and the journalist.*/ + void initializeOptionsAndJournalist(); + /** @} */ + + /** @name Elements of the branch-and-bound setup.*/ + /** @{ */ + /** Pointer to the non-linear solver used.*/ + OsiTMINLPInterface * nonlinearSolver() + { + return nonlinearSolver_; + } + /** Pointer to the continuous solver to use for relaxations. */ + OsiSolverInterface * continuousSolver() + { + return continuousSolver_; + } + /** list of cutting planes methods to apply with their frequencies. */ + CuttingMethods& cutGenerators() + { + return cutGenerators_; + } + /** list of Heuristic methods to use. */ + HeuristicMethods& heuristics() + { + return heuristics_; + } + /** branching method to use. */ + OsiChooseVariable * branchingMethod() + { + return branchingMethod_; + } + /** Method used to compare nodes. */ + NodeComparison& nodeComparisonMethod() + { + return nodeComparisonMethod_; + } + /** Method used to traverse tree.*/ + TreeTraversal treeTraversalMethod() + { + return treeTraversalMethod_; + } + /** Return value of integer parameter. */ + int getIntParameter(const IntParameter &p) const + { + return intParam_[p]; + } + /** Return value of double parameter.*/ + double getDoubleParameter(const DoubleParameter &p) const + { + return doubleParam_[p]; + } + /** Return value of integer parameter. */ + void setIntParameter(const IntParameter &p, const int v) + { + intParam_[p] = v; + } + /** Return value of double parameter.*/ + void setDoubleParameter(const DoubleParameter &p, const double v) + { + doubleParam_[p] = v; + } + /** @} */ + + /** Get the values of base parameters from the options stored.*/ + void gatherParametersValues() + { + gatherParametersValues(options_); + } + /** Get the values of the base parameters from the passed options.*/ + void gatherParametersValues(Ipopt::SmartPtr<Ipopt::OptionsList> options); + /** Acces storage of Journalist for output */ + Ipopt::SmartPtr<Ipopt::Journalist> journalist() + { + return journalist_; + } + + /** Acces list of Options */ + Ipopt::SmartPtr<Ipopt::OptionsList> options() + { + return options_; + } + + /** Access registered Options */ + Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions() + { + return roptions_; + } + + /** Access to extra objects.*/ + const vector<OsiObject *>& objects() const + { + return objects_; + } + + /** Access to extra objects.*/ + vector<OsiObject *>& objects() + { + return objects_; + } + + void addCutGenerator(CuttingMethod & cg){ + cutGenerators_.push_back(cg); + } + + void set_linearizer(TMINLP2OsiLP * linearizer){ + linearizer_ = linearizer; + } + + protected: + /** Set the priorities into OsiTMINLPInterface when needed.*/ + void setPriorities(); + /** Add SOS constraints to OsiTMINLPInterface when needed.*/ + void addSos(); + + /** storage of integer parameters.*/ + int intParam_[NumberIntParam]; + /** default values for int parameters.*/ + static int defaultIntParam_[NumberIntParam]; + /** storage of double parameters. */ + double doubleParam_[NumberDoubleParam]; + /** default values for double parameters. */ + static double defaultDoubleParam_[NumberDoubleParam]; + /** Storage of the non-linear solver used.*/ + OsiTMINLPInterface * nonlinearSolver_; + /** Storage of continuous solver.*/ + OsiSolverInterface * continuousSolver_; + /** Method to linearize MINLPs */ + Ipopt::SmartPtr<TMINLP2OsiLP> linearizer_; + /** Cut generation methods. */ + CuttingMethods cutGenerators_; + /** Heuristic methods. */ + HeuristicMethods heuristics_; + /** Branching method.*/ + OsiChooseVariable * branchingMethod_; + /** Node comparison method.*/ + NodeComparison nodeComparisonMethod_; + /** Tree traversal method.*/ + TreeTraversal treeTraversalMethod_; + /** Extra object to add to Cbc (not OsiObjects).*/ + vector<OsiObject *> objects_; + + + /** Storage of Journalist for output */ + Ipopt::SmartPtr<Ipopt::Journalist> journalist_; + + /** List of Options */ + Ipopt::SmartPtr<Ipopt::OptionsList> options_; + + /** Registered Options */ + Ipopt::SmartPtr<Bonmin::RegisteredOptions> roptions_; + + /** flag to say if option file was read.*/ + bool readOptions_; + /** separate message handler.*/ + CoinMessageHandler * messageHandler_; + /** Prefix to use when reading options.*/ + std::string prefix_; + }; +}/* End namespace Bonmin. */ +#endif + |