CbcSolver.hpp

Go to the documentation of this file.

/* $Id: CbcSolver.hpp 2479 2019-02-07 19:50:37Z unxusr $ */
// 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
*/