qpOASESEngine.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2011 - 2025 The Minotaur Team.
//
 
 
 
#ifndef MINOTAURQPOASESENGINE_H
#define MINOTAURQPOASESENGINE_H
 
#include "QPEngine.h"
#include "WarmStart.h"
 
#include <qpOASES.hpp>
 
namespace Minotaur {
 
  class   Timer;
  class   Environment;
  class   Problem;
  class   Solution;
  typedef Environment* EnvPtr;
  typedef Problem* ProblemPtr;
  typedef Solution* SolutionPtr;
 
 
  class qpOASESData {
  public:
    qpOASES::SQProblem       *qp;
 
    qpOASES::SymSparseMat *H;
    qpOASES::SparseMatrixRow    *A;
 
    qpOASES::sparse_int_t *Hir;
    qpOASES::sparse_int_t *Hjc;
    qpOASES::real_t       *Hval;
 
    qpOASES::sparse_int_t *Air;
    qpOASES::sparse_int_t *Ajc;
    qpOASES::real_t       *Aval;
 
    size_t  n;
    size_t  m;
    double *g;
    double *lb;
    double *ub;
    double *lbA;
    double *ubA;
 
    qpOASESData (int n_, int m_, int nnzh_, int nnza_);
    ~qpOASESData ();
  };
 
 
  class qpOASESPoint {
  public:
    double *x;
    double *y;
    double *lb;
    double *ub;
    double *lbA;
    double *ubA;
    qpOASES::Bounds bounds;
    qpOASES::Constraints constraints;
  };
 
 
  class qpOASESWarmStart : public WarmStart
  {
  public:
    virtual bool hasInfo() { return 1; };
 
    virtual void write(std::ostream &) const {};
 
  public:
    qpOASESPoint pt;
  };
 
  class qpOASESStats {
  public:
    UInt   calls;     
    UInt   strCalls;  
    double time;      
    double strTime;   
    double cTime;     
    UInt   iters;     
    UInt   strIters;  
 
    UInt n_total;
    UInt n_cold;
    UInt n_strbr;
    UInt n_dive;
    UInt n_warm;
 
    UInt piv_total;
    UInt piv_cold;
    UInt piv_strbr;
    UInt piv_dive;
    UInt piv_warm;
 
    double time_total;
    double time_cold;
    double time_strbr;
    double time_dive;
    double time_warm;       
  };
 
 
  class qpOASESEngine : public QPEngine {
 
  public:
    friend class Problem;
 
    qpOASESEngine ();
 
    qpOASESEngine (EnvPtr env);
 
    EnginePtr emptyCopy();
 
    void load(ProblemPtr problem);
 
    void clear();
 
    EngineStatus solve();
 
    double getSolutionValue();
 
    ConstSolutionPtr getSolution();
 
    EngineStatus getStatus();
 
    // Change bound on a constraint.
    void changeBound(ConstraintPtr cons, BoundType lu, double new_val);
 
    // Change bound on a variable.
    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::addConstraint() */
    void addConstraint(ConstraintPtr) {};
 
    // change objective.
    void changeObj(FunctionPtr f, double cb);
 
    // Convert 'min f' to 'min -f'.
    void negateObj();
 
    // Implement Engine::changeConstraint().
    void changeConstraint(ConstraintPtr con, LinearFunctionPtr lf,
                          const double & ub);
 
    // Implement Engine::getWarmStart(). // NULL for now.
    ConstWarmStartPtr getWarmStart();
 
    // Implement Engine::getWarmStartCopy(). // NULL for now.
    WarmStartPtr getWarmStartCopy();
 
    // Implement Engine::loadFromWarmStart().
    void loadFromWarmStart(WarmStartPtr );
 
    // Implement Engine::setIterationLimit().
    void setIterationLimit(int limit);
 
    // Implement Engine::setDualObjLimit().
    int setDualObjLimit(double) {return 1;};
 
    // Implement Engine::resetIterationLimit().
    void resetIterationLimit();
 
    // Implement Engine::enableStrBrSetup()
    void enableStrBrSetup();
 
    // Implement Engine::disableStrBrSetup()
    void disableStrBrSetup();
 
    // Write statistics.
    void writeStats();
 
    // get name.
    std::string getName() const;
 
    ~qpOASESEngine();
 
  private:
 
    void load_();
 
    void solve_ (int mode, double *f);
 
    void storeSol_ (double f);
 
    void setGradient_ ();
 
    void setHessian_ ();
 
    void setInitialPoint_ ();
 
    void setVarBounds_ ();
 
    void setConsBounds_ ();
 
    EnvPtr env_;
 
    ProblemPtr problem_;
 
    SolutionPtr sol_;
 
    bool consModed_;
    bool hessModed_;
 
    qpOASESData *data_;
 
    bool resolveError_;
 
    int iterLimit_;
 
    int maxIterLimit_;
 
    const double infty_;
 
    const double bTol_;
 
    qpOASESStats stats_;
 
    bool strBr_;
    bool ldWarm_;
    UInt n_changed_;
    qpOASESWarmStart ws;
    double objOff_;
 
  private:
    void savePoint (qpOASESPoint *);
    void restorePoint (qpOASESPoint *);
  };
 
  typedef qpOASESEngine* qpOASESEnginePtr;
} // end namespace Minotaur
 
#endif