/home/coin/SVN-release/CoinAll-1.1.0/Cbc/src/CbcSolver.hpp

Go to the documentation of this file.

// Copyright (C) 2007, International Business Machines
// Corporation and others.  All Rights Reserved.
#ifndef CbcSolver_H
#define CbcSolver_H
#include <string>
#include <vector>
#include "CoinFinite.hpp"
#include "CoinMessageHandler.hpp"
#include "OsiClpSolverInterface.hpp"
#include "CbcModel.hpp"
#include "CbcOrClpParam.hpp"
class CbcUser;
class CbcStopNow;
class CglCutGenerator;

//#############################################################################

class CbcSolver  {
  
public:


  int solve(int argc, const char * argv[], int returnMode); 
  int solve(const char * input, int returnMode); 



  CbcSolver(); 
  
  CbcSolver(const OsiClpSolverInterface &);
  
  CbcSolver(const CbcModel &);
  
  CbcSolver(const CbcSolver & rhs);
  
  CbcSolver & operator=(const CbcSolver& rhs);
  
  ~CbcSolver ();
  void fillParameters();
  void fillValuesInSolver();
  void addUserFunction(CbcUser * function);
  void setUserCallBack(CbcStopNow * function);
  void addCutGenerator(CglCutGenerator * generator);


  // analyze model
  int * analyze(OsiClpSolverInterface * solverMod, int & numberChanged, double & increment,
                bool changeInt,  CoinMessageHandler * generalMessageHandler);
  int doHeuristics(CbcModel * model, int type);
  void updateModel(ClpSimplex * model2, int returnMode);



  int intValue(CbcOrClpParameterType type) const;
  void setIntValue(CbcOrClpParameterType type,int value);
  double doubleValue(CbcOrClpParameterType type) const;
  void setDoubleValue(CbcOrClpParameterType type,double value);
  CbcUser * userFunction(const char * name) const;
  inline CbcModel * model() 
  { return &model_;}
  inline CbcModel * babModel() 
  { return babModel_;}
  inline int numberUserFunctions() const
  { return numberUserFunctions_;}
  inline CbcUser ** userFunctionArray() const
  { return userFunction_;}
  inline OsiClpSolverInterface * originalSolver() const
  { return originalSolver_;}
  inline CoinModel * originalCoinModel() const
  { return originalCoinModel_;}
  void setOriginalSolver(OsiClpSolverInterface * originalSolver);
  void setOriginalCoinModel(CoinModel * originalCoinModel);
  inline int numberCutGenerators() const
  { return numberCutGenerators_;}
  inline CglCutGenerator ** cutGeneratorArray() const
  { return cutGenerator_;}
  inline double startTime() const
  { return startTime_;}
  inline void setPrinting(bool onOff)
  { noPrinting_= !onOff;}
  inline void setReadMode(int value)
  { readMode_ = value;}
private:

  
  CbcModel model_;
  
  CbcModel * babModel_;
  
  CbcUser ** userFunction_;
  int * statusUserFunction_;
  OsiClpSolverInterface * originalSolver_;
  CoinModel * originalCoinModel_;
  CglCutGenerator ** cutGenerator_;
  int numberUserFunctions_;
  int numberCutGenerators_;
  CbcStopNow * callBack_;
  double startTime_;
  CbcOrClpParam * parameters_;
  int numberParameters_ ;
  bool doMiplib_;
  bool noPrinting_;
  int readMode_;
};
//#############################################################################
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_; 
} CbcSolverUsefulData;
class CbcUser  {
  
public:


  virtual int importData(CbcSolver * model, int & argc, char * argv[]) {return -1;}
  virtual void exportSolution(CbcSolver * model, int mode,const char * message=NULL) {}
  virtual void exportData(CbcSolver * model) {}
  virtual void fillInformation(CbcSolver * model,
                               CbcSolverUsefulData & info) {}




  inline CoinModel * coinModel() const
  { return coinModel_;}
  virtual void * stuff() {return NULL;}
  inline std::string name() const
  { return userName_;}
  virtual void solve(CbcSolver * model, const char * options) = 0;
  virtual bool canDo(const char * options) = 0;



  CbcUser(); 
  
  CbcUser(const CbcUser & rhs);
  
  CbcUser & operator=(const CbcUser& rhs);

  virtual CbcUser * clone() const = 0;
  
  virtual ~CbcUser ();
  
protected:

  
  CoinModel * coinModel_;
  
  std::string userName_;

};
//#############################################################################

class CbcStopNow  {
  
public:



  virtual int callBack(CbcModel * currentSolver, int whereFrom) {return 0;}



  CbcStopNow(); 
  
  CbcStopNow(const CbcStopNow & rhs);
  
  CbcStopNow & operator=(const CbcStopNow& rhs);

  virtual CbcStopNow * clone() const;
  
  virtual ~CbcStopNow ();
  
private:


};
#endif

---