IpoptEngine.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2008 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURIPOPTENGINE_H
#define MINOTAURIPOPTENGINE_H
 
#include "NLPEngine.h"
#include "Solution.h"
#include "WarmStart.h"
 
 
namespace Ipopt {
  class IpoptApplication;
  class IpoptFunInterface;
  class TNLP;
}
 
 
namespace Minotaur {
 
  class   Environment;
  class   IpoptEngine;
  class   Problem;
  class   Timer;
  typedef Environment* EnvPtr;
  typedef IpoptEngine* IpoptEnginePtr;
  typedef Problem* ProblemPtr;
 
  // thread based statistics
  struct IpoptStats {
    UInt calls;     
    UInt opt;       
    UInt reopt;     
    UInt iters;     
    double ptime;   
    UInt strCalls;  
    UInt strIters;  
    double strTime; 
    double time;    
    double walltime;
  };
 
 
  class   IpoptSolution;
  typedef IpoptSolution* IpoptSolPtr;
  typedef const IpoptSolution* ConstIpoptSolPtr;
 
  class IpoptSolution : public Solution {
  public:
 
    IpoptSolution();
 
    IpoptSolution(const double *x, ProblemPtr problem); 
 
    IpoptSolution(const double *x, double objval, ProblemPtr problem);
 
    IpoptSolution(ConstIpoptSolPtr);
 
    ~IpoptSolution();
 
    const double * getLowerDualOfVars() const {return dualXLow_;};
 
    const double * getUpperDualOfVars() const {return dualXUp_;};
 
    // base class
    void setDualOfVars(const double *) { assert(!"implement me!"); };
 
    void setDualOfVars(const double *lower, const double *upper);
 
    void write(std::ostream &out) const;
 
  private:
    double *dualXLow_;
 
    double *dualXUp_;
  };
 
 
  class IpoptWarmStart;
  typedef IpoptWarmStart* IpoptWarmStartPtr;
  typedef const IpoptWarmStart* ConstIpoptWarmStartPtr;
 
  class IpoptWarmStart : public WarmStart {
  public:
    IpoptWarmStart();
 
    IpoptWarmStart(ConstIpoptWarmStartPtr ws);
 
    ~IpoptWarmStart();
 
    IpoptSolPtr getPoint();
 
    // Implement WarmStart::hasInfo().
    bool hasInfo();
 
    void setPoint(IpoptSolPtr sol);
 
    // Implement WarmStart::write().
    void write(std::ostream &out) const;
 
  private:
    IpoptSolPtr sol_;
  };
 
 
// ----------------------------------------------------------------------- //
// ----------------------------------------------------------------------- //
 
  class IpoptEngine : public NLPEngine {
  public:
 
    friend class Problem;
 
    IpoptEngine(EnvPtr env);
 
    ~IpoptEngine();
 
    // Base class method
    void addConstraint(ConstraintPtr c);
 
    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, NonlinearFunctionPtr);
 
    // change objective.
    void changeObj(FunctionPtr f, double cb);
 
    void clear();
 
    void disableStrBrSetup();
 
    EnginePtr emptyCopy();
 
    void enableStrBrSetup();
 
    // Implement Engine::fillStats()
    void fillStats(std::vector<double> &);
 
    // get name.
    std::string getName() const;
 
    // Implement Engine::getSolution().
    ConstSolutionPtr getSolution();
 
    // Implement Engine::getSolutionValue().
    double getSolutionValue();
 
    // Implement Engine::getStatus().
    EngineStatus getStatus();
 
    // Implement Engine::getWarmStart().
    ConstWarmStartPtr getWarmStart();
 
    // Implement Engine::getWarmStartCopy().
    WarmStartPtr getWarmStartCopy();
 
    void load(ProblemPtr problem);
 
    // Implement Engine::loadFromWarmStart().
    void loadFromWarmStart(const WarmStartPtr ws);
 
    // 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;};
 
    void setOptionsForSingleSolve();
 
    void setOptionsForRepeatedSolve();
 
    EngineStatus solve();
 
    void writeStats(std::ostream &out) const;
 
  private:
    bool bndChanged_;
 
    bool consChanged_;
 
    double *dual_x_l_;
 
    double *dual_x_u_;
 
    double *dual_g_;
 
    EnvPtr env_;
 
    const double etol_;
 
    bool justLoaded_;
 
    LoggerPtr logger_;
 
    static const int maxIterLimit_ = 3000;
 
    static const std::string me_;
 
    Ipopt::IpoptApplication  *myapp_; 
 
    // usually gets freed automatically when myapp_ is deleted.
    // In case myapp_->Optimize or myapp_->Reoptimize are
    // not called even once, then we have to free it (see
    // IpoptStats::opt, reopt).
    Ipopt::IpoptFunInterface *mynlp_;
 
    bool prepareWs_;
 
    bool presolve_();
 
    ProblemPtr problem_;
 
    IpoptSolPtr sol_;
 
    IpoptStats *stats_;
 
    bool strBr_;
 
    Timer *timer_;
 
    bool useWs_;
 
    IpoptWarmStartPtr ws_;
 
    IpoptWarmStartPtr wsSb_;
 
    void setOptionsForProb_();
  };
}
 
#endif