Engine.h

Go to the documentation of this file.

// 
//   Minotaur -- It's only 1/2 bull
// 
//   (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURENGINE_H
#define MINOTAURENGINE_H
 
#include "Types.h"
 
namespace Minotaur {
 
  class   Solution;
  class   WarmStart;
  class   Engine;
  typedef Engine* EnginePtr;
  typedef const Engine* ConstEnginePtr;  
  typedef const Solution* ConstSolutionPtr;
  typedef WarmStart* WarmStartPtr;
  typedef const WarmStart* ConstWarmStartPtr;
 
  class Engine {
 
  public:
    Engine();
 
    virtual ~Engine();
 
    virtual void addConstraint(ConstraintPtr) = 0;
 
    virtual void changeBound(ConstraintPtr cons, BoundType lu, 
                             double new_val) = 0;
 
    virtual void changeBound(VariablePtr var, BoundType lu, double new_val) 
      = 0;
 
    virtual void changeBound(VariablePtr var, double new_lb, double new_ub) 
      = 0;
 
    virtual void changeConstraint(ConstraintPtr c, LinearFunctionPtr lf, 
                                  double lb, double ub) = 0;
 
    virtual void changeConstraint(ConstraintPtr c, NonlinearFunctionPtr nlf) = 0;
 
    virtual void changeObj(FunctionPtr f, double cb) = 0;
 
    virtual void clear() = 0;
 
    virtual void disableStrBrSetup() = 0;
 
    virtual EnginePtr emptyCopy() {return EnginePtr();} // NULL by default.
 
    virtual void enableStrBrSetup() = 0;
 
    virtual ConstSolutionPtr getSolution() = 0;
 
    virtual double getSolutionValue() = 0;
 
    virtual EngineStatus solve() = 0;
 
    virtual std::string getName() const = 0;
 
    virtual EngineStatus getStatus() = 0;
 
    virtual std::string getStatusString();
 
    virtual ConstWarmStartPtr getWarmStart() = 0;
 
    virtual WarmStartPtr getWarmStartCopy() = 0;
 
    virtual void load(ProblemPtr problem) = 0;
 
    virtual void loadFromWarmStart(const WarmStartPtr ws) = 0;
 
    virtual void negateObj() = 0;
 
    virtual LoggerPtr  getLogger() { return logger_; }
 
    virtual void removeCons(std::vector<ConstraintPtr> &delcons) = 0;
 
    virtual void resetIterationLimit() = 0;
 
    virtual int setDualObjLimit(double) = 0;
 
    virtual void setIterationLimit(int limit) = 0;
 
    virtual void setLogger(LoggerPtr logger) { logger_ = logger; }
 
    virtual void setOptionsForSingleSolve() {};
 
    virtual void setOptionsForRepeatedSolve() {};
 
    virtual void writeStats(std::ostream &) const {};
 
    //structure for parallel algorithms
    virtual void fillStats(std::vector<double> &) {};
 
  protected:
    EngineStatus status_;
 
    LoggerPtr logger_;
 
};
 
}
 
#endif