CbcSolver.hpp

Go to the documentation of this file.

/* $Id$ */
// 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).
 
#ifndef CbcSolver_H
#define CbcSolver_H
 
#include <string>
#include <vector>
#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;
 
//#############################################################################
 
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_;
  std::vector< CbcOrClpParam > parameters_;
  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_;
} CbcSolverUsefulData2;
 
//#############################################################################
 
class CbcSolverUsefulData {
 
public:
 
  CbcSolverUsefulData();
 
  CbcSolverUsefulData(const CbcSolverUsefulData &rhs);
 
  CbcSolverUsefulData &operator=(const CbcSolverUsefulData &rhs);
 
  ~CbcSolverUsefulData();
 
 
  // For time
  double totalTime_;
  // Parameters
  std::vector<CbcOrClpParam> parameters_;
  // Printing
  bool noPrinting_;
  // Whether to use signal handler
  bool useSignalHandler_;
  // Default pump tuning
  int initialPumpTune_;
};
// 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);
 
//#############################################################################
 
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
 
/* vi: softtabstop=2 shiftwidth=2 expandtab tabstop=2
*/