From a0d9443af147e949c1e6a01ac24749d12593ec5b Mon Sep 17 00:00:00 2001 From: Harpreet Date: Sat, 3 Sep 2016 00:36:51 +0530 Subject: cbcintlinprog added --- thirdparty/linux/include/coin/CbcSolver.hpp | 447 ++++++++++++++++++++++++++++ 1 file changed, 447 insertions(+) create mode 100644 thirdparty/linux/include/coin/CbcSolver.hpp (limited to 'thirdparty/linux/include/coin/CbcSolver.hpp') diff --git a/thirdparty/linux/include/coin/CbcSolver.hpp b/thirdparty/linux/include/coin/CbcSolver.hpp new file mode 100644 index 0000000..34052e1 --- /dev/null +++ b/thirdparty/linux/include/coin/CbcSolver.hpp @@ -0,0 +1,447 @@ +/* $Id: CbcSolver.hpp 1998 2013-12-19 18:11:05Z forrest $ */ +// Copyright (C) 2007, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + + +/*! \file CbcSolver.hpp + \brief Defines CbcSolver, the proposed top-level class for the new-style + cbc solver. + + This class is currently an orphan. With the removal of all code flagged + with the NEW_STYLE_SOLVER, this class is never instantiated (and cannot + be instantiated). It is available to be coopted as a top-level object + wrapping the current CbcMain0 and CbcMain1, should that appear to be a + desireable path forward. -- lh, 091211 -- +*/ + +#ifndef CbcSolver_H +#define CbcSolver_H + +#include +#include +#include "CoinMessageHandler.hpp" +#include "OsiClpSolverInterface.hpp" + +#if CBC_OTHER_SOLVER==1 +#include "OsiCpxSolverInterface.hpp" +#endif + +#include "CbcModel.hpp" +#include "CbcOrClpParam.hpp" + +class CbcUser; +class CbcStopNow; +class CglCutGenerator; + +//############################################################################# + +/*! \brief This allows the use of the standalone solver in a flexible manner. + + It has an original OsiClpSolverInterface and CbcModel which it can use + repeatedly, e.g., to get a heuristic solution and then start again. + + So I [jjf] will need a primitive scripting language which can then call + solve and manipulate solution value and solution arrays. + + Also provides for user callback functions. Currently two ideas in + gestation, CbcUser and CbcStopNow. The latter seems limited to deciding + whether or not to stop. The former seems completely general, with a notion + of importing and exporting, and a `solve', which should be interpreted as + `do whatever this user function does'. + + Parameter initialisation is at last centralised in fillParameters(). +*/ + +class CbcSolver { + +public: + ///@name Solve method + //@{ + /** This takes a list of commands, does "stuff" and returns + returnMode - + 0 model and solver untouched - babModel updated + 1 model updated - just with solution basis etc + 2 model updated i.e. as babModel (babModel NULL) (only use without preprocessing) + */ + int solve(int argc, const char * argv[], int returnMode); + /** This takes a list of commands, does "stuff" and returns + returnMode - + 0 model and solver untouched - babModel updated + 1 model updated - just with solution basis etc + 2 model updated i.e. as babModel (babModel NULL) (only use without preprocessing) + */ + int solve(const char * input, int returnMode); + //@} + ///@name Constructors and destructors etc + //@{ + /// Default Constructor + CbcSolver(); + + /// Constructor from solver + CbcSolver(const OsiClpSolverInterface &); + + /// Constructor from model + CbcSolver(const CbcModel &); + + /** Copy constructor . + */ + CbcSolver(const CbcSolver & rhs); + + /// Assignment operator + CbcSolver & operator=(const CbcSolver& rhs); + + /// Destructor + ~CbcSolver (); + /// Fill with standard parameters + void fillParameters(); + /*! \brief Set default values in solvers from parameters + + Misleading. The current code actually reads default values from + the underlying solvers and installs them as default values for a subset of + parameters in #parameters_. + */ + void fillValuesInSolver(); + /// Add user function + void addUserFunction(CbcUser * function); + /// Set user call back + void setUserCallBack(CbcStopNow * function); + /// Add cut generator + void addCutGenerator(CglCutGenerator * generator); + //@} + ///@name miscellaneous methods to line up with old + //@{ + // analyze model + int * analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment, + bool changeInt, CoinMessageHandler * generalMessageHandler); + /** 1 - add heuristics to model + 2 - do heuristics (and set cutoff and best solution) + 3 - for miplib test so skip some + (out model later) + */ + //int doHeuristics(CbcModel * model, int type); + /** Updates model_ from babModel_ according to returnMode + returnMode - + 0 model and solver untouched - babModel updated + 1 model updated - just with solution basis etc + 2 model updated i.e. as babModel (babModel NULL) (only use without preprocessing) + */ + void updateModel(ClpSimplex * model2, int returnMode); + //@} + ///@name useful stuff + //@{ + /// Get int value + int intValue(CbcOrClpParameterType type) const; + /// Set int value + void setIntValue(CbcOrClpParameterType type, int value); + /// Get double value + double doubleValue(CbcOrClpParameterType type) const; + /// Set double value + void setDoubleValue(CbcOrClpParameterType type, double value); + /// User function (NULL if no match) + CbcUser * userFunction(const char * name) const; + /// Return original Cbc model + inline CbcModel * model() { + return &model_; + } + /// Return updated Cbc model + inline CbcModel * babModel() { + return babModel_; + } + /// Number of userFunctions + inline int numberUserFunctions() const { + return numberUserFunctions_; + } + /// User function array + inline CbcUser ** userFunctionArray() const { + return userFunction_; + } + /// Copy of model on initial load (will contain output solutions) + inline OsiClpSolverInterface * originalSolver() const { + return originalSolver_; + } + /// Copy of model on initial load + inline CoinModel * originalCoinModel() const { + return originalCoinModel_; + } + /// Copy of model on initial load (will contain output solutions) + void setOriginalSolver(OsiClpSolverInterface * originalSolver); + /// Copy of model on initial load + void setOriginalCoinModel(CoinModel * originalCoinModel); + /// Number of cutgenerators + inline int numberCutGenerators() const { + return numberCutGenerators_; + } + /// Cut generator array + inline CglCutGenerator ** cutGeneratorArray() const { + return cutGenerator_; + } + /// Start time + inline double startTime() const { + return startTime_; + } + /// Whether to print to std::cout + inline void setPrinting(bool onOff) { + noPrinting_ = !onOff; + } + /// Where to start reading commands + inline void setReadMode(int value) { + readMode_ = value; + } + //@} +private: + ///@name Private member data + //@{ + + /// Reference model + CbcModel model_; + + /// Updated model + CbcModel * babModel_; + + /// User functions + CbcUser ** userFunction_; + /** Status of user functions + 0 - not used + 1 - needs cbc_load + 2 - available - data in coinModel + 3 - data loaded - can do cbc_save + */ + int * statusUserFunction_; + /// Copy of model on initial load (will contain output solutions) + OsiClpSolverInterface * originalSolver_; + /// Copy of model on initial load + CoinModel * originalCoinModel_; + /// Cut generators + CglCutGenerator ** cutGenerator_; + /// Number of user functions + int numberUserFunctions_; + /// Number of cut generators + int numberCutGenerators_; + /// Stop now stuff + CbcStopNow * callBack_; + /// Cpu time at instantiation + double startTime_; + /// Parameters and values + CbcOrClpParam * parameters_; + /// Number of parameters + int numberParameters_ ; + /// Whether to do miplib test + bool doMiplib_; + /// Whether to print to std::cout + bool noPrinting_; + /// Where to start reading commands + int readMode_; + //@} +}; +//############################################################################# + +/// Structure to hold useful arrays +typedef struct { + // Priorities + int * priorities_; + // SOS priorities + int * sosPriority_; + // Direction to branch first + int * branchDirection_; + // Input solution + double * primalSolution_; + // Down pseudo costs + double * pseudoDown_; + // Up pseudo costs + double * pseudoUp_; +} CbcSolverUsefulData2; + +//############################################################################# + +/** + The CbcSolver class was taken out at a 9/12/09 meeting + This is a feeble replacement. + At present everything is public +*/ +class CbcSolverUsefulData { + +public: + ///@name Constructors and destructors etc + //@{ + /// Default Constructor + CbcSolverUsefulData(); + + /** Copy constructor . + */ + CbcSolverUsefulData(const CbcSolverUsefulData & rhs); + + /// Assignment operator + CbcSolverUsefulData & operator=(const CbcSolverUsefulData& rhs); + + /// Destructor + ~CbcSolverUsefulData (); + //@} + + ///@name Member data + //@{ + // For time + double totalTime_; + // Parameters + CbcOrClpParam parameters_[CBCMAXPARAMETERS]; + // Printing + bool noPrinting_; + // Whether to use signal handler + bool useSignalHandler_; + // Number of Parameters + int numberParameters_; + // Default pump tuning + int initialPumpTune_; + //@} +}; +/// And this uses it +// When we want to load up CbcModel with options first +void CbcMain0 (CbcModel & babSolver,CbcSolverUsefulData & solverData); +int CbcMain1 (int argc, const char *argv[], CbcModel & babSolver, int (CbcModel * currentSolver, int whereFrom),CbcSolverUsefulData & solverData); + +//############################################################################# + +/*! \brief A class to allow the use of unknown user functionality + + For example, access to a modelling language (CbcAmpl). +*/ +class CbcUser { + +public: + ///@name import/export methods + //@{ + /*! \brief Import - gets full command arguments + + \return + - -1 - no action + - 0 - data read in without error + - 1 - errors + */ + virtual int importData(CbcSolver * /*model*/, int & /*argc*/, char ** /*argv[]*/) { + return -1; + } + + /*! \brief Export + + Values for mode: + - 1 OsiClpSolver + - 2 CbcModel + - add 10 if infeasible from odd situation + */ + virtual void exportSolution(CbcSolver * /*model*/, + int /*mode*/, const char * /*message*/ = NULL) {} + + /// Export Data (i.e. at very end) + virtual void exportData(CbcSolver * /*model*/) {} + + /// Get useful stuff + virtual void fillInformation(CbcSolver * /*model*/, + CbcSolverUsefulData & /*info*/) {} + //@} + + ///@name usage methods + //@{ + /// CoinModel if valid + inline CoinModel *coinModel() const { + return coinModel_; + } + /// Other info - needs expanding + virtual void * stuff() { + return NULL; + } + /// Name + inline std::string name() const { + return userName_; + } + /// Solve (whatever that means) + virtual void solve(CbcSolver * model, const char * options) = 0; + /// Returns true if function knows about option + virtual bool canDo(const char * options) = 0; + //@} + + ///@name Constructors and destructors etc + //@{ + /// Default Constructor + CbcUser(); + + /// Copy constructor + CbcUser(const CbcUser & rhs); + + /// Assignment operator + CbcUser & operator=(const CbcUser& rhs); + + /// Clone + virtual CbcUser * clone() const = 0; + + /// Destructor + virtual ~CbcUser (); + //@} + +protected: + ///@name Private member data + //@{ + + /// CoinModel + CoinModel * coinModel_; + + /// Name of user function + std::string userName_; + +//@} +}; +//############################################################################# + +/*! \brief Support the use of a call back class to decide whether to stop + + Definitely under construction. +*/ + +class CbcStopNow { + +public: + ///@name Decision methods + //@{ + /*! \brief Import + + Values for whereFrom: + - 1 after initial solve by dualsimplex etc + - 2 after preprocessing + - 3 just before branchAndBound (so user can override) + - 4 just after branchAndBound (before postprocessing) + - 5 after postprocessing + - 6 after a user called heuristic phase + + \return 0 if good + nonzero return code to stop + */ + virtual int callBack(CbcModel * /*currentSolver*/, int /*whereFrom*/) { + return 0; + } + //@} + + ///@name Constructors and destructors etc + //@{ + /// Default Constructor + CbcStopNow(); + + /** Copy constructor . + */ + CbcStopNow(const CbcStopNow & rhs); + + /// Assignment operator + CbcStopNow & operator=(const CbcStopNow& rhs); + + /// Clone + virtual CbcStopNow * clone() const; + + /// Destructor + virtual ~CbcStopNow (); + //@} + +private: + ///@name Private member data + //@{ +//@} +}; +#endif + -- cgit