CbcEngine.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURCBCENGINE_H
#define MINOTAURCBCENGINE_H
 
#include "MILPEngine.h"
 
class OsiSolverInterface;
 
namespace Minotaur {
 
  class   Timer;
  class   Environment;
  class   Problem;
  class   Solution;
  class   WarmStart;
  typedef Environment* EnvPtr;
  typedef Problem* ProblemPtr;
  typedef Solution* SolutionPtr;
  typedef WarmStart* WarmStartPtr;
 
  struct CbcStats {
    UInt calls;     
    double time;    
  };
 
  class CbcEngine : public MILPEngine {
  public:
    CbcEngine(EnvPtr env);
 
    ~CbcEngine();
 
    // Implement Engine::addConstraint().
    void addConstraint(ConstraintPtr);
 
    // Change bounds on a constraint.
    void changeBound(ConstraintPtr cons, BoundType lu, double new_val);
 
    // Implement Engine::changeBound(VariablePtr, BoundType, double).
    void changeBound(VariablePtr var, BoundType lu, double new_val);
 
    // Implement Engine::changeBound(VariablePtr, double, double).
    void changeBound(VariablePtr var, double new_lb, double new_ub);
 
    // Implement Engine::changeConstraint().
    void changeConstraint(ConstraintPtr con, LinearFunctionPtr lf, 
                          double lb, double ub);
 
    // Implement Engine::changeConstraint().
    void changeConstraint(ConstraintPtr c, NonlinearFunctionPtr nlf);
 
    // change the objective function.
    void changeObj(FunctionPtr f, double cb);
 
    void clear();
 
    void disableStrBrSetup() {};
 
    EnginePtr emptyCopy();
 
    void enableStrBrSetup() {};
 
    UInt getNumSols() {};
 
    double getSolutionValue();
 
    // Implement Engine::getSolution().
    ConstSolutionPtr getSolution();
 
    // Get a particular solution from solution pool.
    ConstSolutionPtr getSolutionFromPool(int ) {};
 
    // Implement Engine::getStatus().
    EngineStatus getStatus();
 
    // get name.
    std::string getName() const;
 
    ConstWarmStartPtr getWarmStart() {return WarmStartPtr();};
 
    WarmStartPtr getWarmStartCopy()  {return WarmStartPtr();};
 
    void load(ProblemPtr problem);
 
    void loadFromWarmStart(const WarmStartPtr ) {};
 
    // Convert 'min f' to 'min -f'.
    void negateObj();
 
    // base class method.
    void removeCons(std::vector<ConstraintPtr> &delcons);
 
    // Implement Engine::resetIterationLimit().
    void resetIterationLimit();
 
    // Implement Engine::setIterationLimit().
    void setIterationLimit(int limit);
 
    // Implement Engine::setDualObjLimit().
    int setDualObjLimit(double) {return 1;};
 
    // base class method
    void setTimeLimit(double);
 
    // base class method
    void setUpperCutoff(double);
 
    EngineStatus solve();
 
    void writeLP(const char *filename) const;
 
    void writeStats(std::ostream &out) const;
 
  private:
    bool bndChanged_;
 
    bool consChanged_;
 
    EnvPtr env_;
 
    int maxIterLimit_;
 
    static const std::string me_;
 
    bool objChanged_;
 
    OsiSolverInterface *osilp_;
 
    ProblemPtr problem_;
 
    SolutionPtr sol_;
 
    CbcStats *stats_;
 
    Timer *timer_;
 
    void load_();
  };
  
  typedef CbcEngine* CbcEnginePtr;
}
 
#endif