BqpdEngine.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2010 - 2025 The Minotaur Team.
// 
 
 
 
#ifndef MINOTAURBQPDENGINE_H
#define MINOTAURBQPDENGINE_H
 
#include "QPEngine.h"
 
namespace Minotaur {
 
  class   Timer;
  class   Environment;
  class   Problem;
  class   Solution;
  typedef Environment* EnvPtr;
  typedef Problem* ProblemPtr;
  typedef Solution* SolutionPtr;
 
  struct BqpdStats {
    UInt calls;     
    UInt strCalls;  
    double time;    
    double strTime; 
    double cTime;   
    UInt iters;     
    UInt strIters;  
  };
 
  class BqpdData;
  class BqpdEngine : public QPEngine {
  public:
    friend class Problem;
 
    BqpdEngine(EnvPtr env);    
 
    ~BqpdEngine();
 
    // Implement Engine::addConstraint() */
    void addConstraint(ConstraintPtr);
 
    // 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::changeConstraint().
    void changeConstraint(ConstraintPtr con, LinearFunctionPtr lf, 
                          double lb, double ub);
 
    // base class method
    void changeConstraint(ConstraintPtr con, NonlinearFunctionPtr nlf);
 
    // change objective.
    void changeObj(FunctionPtr f, double cb);
 
    void clear();
 
    // Implement Engine::disableStrBrSetup()
    void disableStrBrSetup();
 
    EnginePtr emptyCopy();
 
    // Implement Engine::enableStrBrSetup()
    void enableStrBrSetup();
 
    // get name.
    std::string getName() const;
 
    ConstSolutionPtr getSolution();
 
    double getSolutionValue();
 
    EngineStatus getStatus();
 
    // Implement Engine::getWarmStart(). // NULL for now.
    ConstWarmStartPtr getWarmStart() {return 0; }; 
 
    // Implement Engine::getWarmStartCopy(). // NULL for now.
    WarmStartPtr getWarmStartCopy() {return 0; };
 
    void load(ProblemPtr problem);
 
    // Implement Engine::loadFromWarmStart().
    void loadFromWarmStart(WarmStartPtr ) {};
 
    // Convert 'min f' to 'min -f'.
    void negateObj();
 
    // delete constraints.
    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;};
 
    EngineStatus solve();
 
    // Write statistics.
    void writeStats(std::ostream &out) const;
 
  private:
    UInt bndChanges_;
 
    bool bndRelaxed_;
 
    const double bTol_;
 
    BqpdData *chkPt_;
 
    bool consModed_;
 
    double *dualCons_;
 
    double *dualX_;
 
    EnvPtr env_;
 
    BqpdData *fStart_;
 
    const double infty_;
 
    int iterLimit_; 
 
    const int maxIterLimit_;
 
    static const std::string me_;
 
    double objOff_;
 
    bool prevStrBr_;
 
    ProblemPtr problem_;
 
    bool resolveError_;
 
    SolutionPtr sol_;
 
    BqpdStats *stats_;
 
    bool strBr_;
 
    Timer *timer_;
 
    int wsMode_;
 
    void freeProb_();
 
    void load_();
 
    void setConsBounds_();
 
    void setGradient_();
 
    void setHessian_();
 
    void setInitialPoint_();
 
    void setVarBounds_();
 
    void solve_(int mode, double &f);
 
    void storeSol_(double f);
 
  };
 
 
  class BqpdData {
  public: 
    BqpdData(UInt n_t, UInt m_t, int kmax_t, UInt maxa_t, UInt lh1_t,
             UInt nJac, bool zero=true);
 
    ~BqpdData();
 
    BqpdData *clone();
 
    void copyFrom(const BqpdData* rhs);
 
    void write(std::ostream &out) const;
 
    UInt n;
 
    UInt m;
 
    int kmax;
 
    UInt lh1;
 
    UInt nJac;
 
    UInt maxa;
 
    double *x;
 
    double *r;
 
    double *e;
 
    double *w;
 
    double *g;
 
    int *ls;
 
    double *alp;
 
    int *lp;
 
    int *info;
 
    double *bl;
 
    double *bu;
 
    double *a;
 
    int *la;
 
    double *ws;
 
    int *lws;
 
    int peq;
 
    // Dimension of reduced-space, set only when mode>=0.
    int k;
  };
 
  
  typedef BqpdEngine* BqpdEnginePtr;
} // end namespace Minotaur 
 
#endif