QPDProcessor.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURQPDPROCESSOR_H
#define MINOTAURQPDPROCESSOR_H
 
#include "NodeProcessor.h"
#include "Types.h"
 
namespace Minotaur {
 
  class Engine;
  class NonlinearFunction;
  class Problem;
  class Solution;
  typedef NonlinearFunction* NonlinearFunctionPtr;
  typedef Solution* SolutionPtr;
  typedef const Solution* ConstSolutionPtr;
 
  struct QPDStats {
    UInt bra;    
    UInt cuts;   
    UInt inf;    
    UInt nlp;    
    UInt nlpI;   
    UInt nlpU;   
    UInt opt;    
    UInt prob;   
    UInt proc;   
    UInt sep;    
    UInt ub;     
  };
 
  class QPDProcessor : public NodeProcessor {
 
  public:
    QPDProcessor();
 
    QPDProcessor(EnvPtr env, ProblemPtr p, EnginePtr e, EnginePtr qe,
                 HandlerVector &handlers);
 
    ~QPDProcessor();
 
    // Add a heuristic.
    void addHeur(HeurPtr h);
 
    // True if a new solution was found while processing this node.
    bool foundNewSolution();
 
    // Find branches that will be used to branch at this node.
    Branches getBranches();
 
    // Get warm-start information.
    WarmStartPtr getWarmStart();
 
    // Implement NodeProcessor::process().
    void process(NodePtr node, RelaxationPtr rel, 
                 SolutionPoolPtr s_pool);
 
    // Process root node.
    void processRootNode(NodePtr node, RelaxationPtr rel, 
                         SolutionPoolPtr s_pool);
 
    // write statistics. Base class method.
    void writeStats(std::ostream &out) const; 
 
    // write statistics to logger. Base class method.
    void writeStats() const {}; 
 
  private:
    Branches branches_;
 
    EnginePtr e_;
 
    EnvPtr env_;
 
    VariablePtr eta_;
 
    VariablePtr etaL_;
 
    HandlerVector handlers_;
 
    LoggerPtr logger_;
 
    /* 
     * If Filter-SQP is used, the duals are negative of what QP from Hessian
     * evaluation expects. If this flag is on, the duals are negated before
     * creating QP.
     */
    bool negDuals_;
 
    static const std::string me_;
 
    std::vector<ConstConstraintPtr> nlCons_;
 
    UInt numSolutions_;
 
    ProblemPtr p_;
 
    RelaxationPtr qp_;
 
    EnginePtr qpe_;
 
    const double solAbsTol_;
 
    const double solRelTol_;
 
    bool solveQPafNLP_;
 
    QPDStats stats_;
 
    ConstraintPtr ubCon_;
 
    WarmStartPtr ws_;
 
    bool boundTooFar_(ConstSolutionPtr sol, NodePtr node,
                      double best) ;
 
    void getLin_(FunctionPtr f, const double *x, UInt n,
                 VariableConstIterator vbeg, VariableConstIterator vend, 
                 LinearFunctionPtr &lf, double &val);
 
    void getObjLin_(NonlinearFunctionPtr nlf, const double *x,
                    UInt n, VariableConstIterator vbeg,
                    VariableConstIterator vend, 
                    LinearFunctionPtr &lf, double &val);
 
    void fixInts_(const double *x, std::stack<Modification *> *nlp_mods);
 
    void chkObjVio_(double vio, double etaval, bool &large_vio);
 
    void chkVio_(NodePtr node, double *vio, double &tvio, double &maxvio,
                 bool &large_vio);
 
    bool isHFeasible_(ConstSolutionPtr sol, bool &should_prune);
    bool isHFeasible2_(ConstSolutionPtr sol, bool &ishigh,
                       bool &should_prune);
    void chkObjVio2_(const double *qpx, NodePtr node, double best,
                     bool &hiobjd, bool &hietavio);
 
    bool isNLPFeasible2_(const double *qpx, double *vio, NodePtr node, bool
                         &hicvio);
    bool isLargeCVio_(ConstConstraintPtr c, double vio, UInt depth);
 
    //bool isQPFeasible_(NodePtr node, ConstSolutionPtr sol, 
    //                  SolutionPoolPtr s_pool, bool &should_prune);
 
    bool isNLPFeasible_(ConstSolutionPtr sol, double *vio);
 
    SolutionPtr nlpSol2Qp_(ConstSolutionPtr sol);
 
    void OAFromPoint_(const double *x, ConstSolutionPtr sol,
                      SeparationStatus *status); 
 
    bool presolveNode_(NodePtr node, SolutionPoolPtr s_pool);
 
    void processNLP_(NodePtr node, ConstSolutionPtr &sol,
                     ConstSolutionPtr qpsol,
                     SolutionPoolPtr s_pool, bool &should_prune);
 
    void processQP_(UInt iter, NodePtr node, ConstSolutionPtr &sol,
                    SolutionPoolPtr s_pool, bool &should_prune,
                    bool &should_resolve);
 
    void processQP2_(UInt iter, NodePtr node, ConstSolutionPtr &sol,
                     SolutionPoolPtr s_pool, bool &should_prune,
                     bool &should_resolve);
 
    void saveSol_(ConstSolutionPtr sol, SolutionPoolPtr s_pool,
                  NodePtr node);
    void saveQPSol_(ConstSolutionPtr sol, SolutionPoolPtr s_pool,
                    NodePtr node);
 
    void separate_(bool is_nec, ConstSolutionPtr sol, const double *vio,
                   ConstSolutionPtr nlp_sol, NodePtr node,
                   SolutionPoolPtr s_pool, SeparationStatus *status);
 
    void separateB_(ConstSolutionPtr sol, ConstSolutionPtr nlp_sol,
                    double *vio, NodePtr node, SolutionPoolPtr s_pool,
                    SeparationStatus *status);
 
    void separateC_(ConstSolutionPtr sol, ConstSolutionPtr nlp_sol,
                    double *vio, NodePtr node, SolutionPoolPtr s_pool,
                    SeparationStatus *status);
 
    void separateO_(ConstSolutionPtr sol, ConstSolutionPtr nlp_sol,
                    double *vio, NodePtr node, SolutionPoolPtr s_pool,
                    SeparationStatus *status);
 
    void separateECP_(ConstSolutionPtr sol, const double *vio,
                      NodePtr node, SolutionPoolPtr ,
                      SeparationStatus *status);
 
    void separateObj_(ConstSolutionPtr sol, ConstSolutionPtr nlp_sol,
                      double vio, SeparationStatus *status);
 
    void setupQP_(ConstSolutionPtr sol);
 
    bool shouldPrune_(NodePtr node, EngineStatus nlp_status, 
                      ConstSolutionPtr sol, SolutionPoolPtr s_pool);
 
    bool shouldPruneQP_(NodePtr node, EngineStatus nlp_status, 
                        ConstSolutionPtr sol, SolutionPoolPtr s_pool);
 
    bool shouldSep_(bool is_nec, double vio, ConstConstraintPtr c);
    bool shouldSepObj_(bool is_nec, double vio, double etaval);
 
    void solveNLP_(ConstSolutionPtr &sol, EngineStatus &nlp_status);
 
    void solveQP_(ConstSolutionPtr &sol, EngineStatus &qp_status);
 
    SolutionPtr translateSol_(ConstSolutionPtr sol);
 
    void unfixInts_(std::stack<Modification *> *nlp_mods);
 
    void updateObjCons_(ConstSolutionPtr sol);
 
    void updateUb_(SolutionPoolPtr s_pool, double *nlpval);
  };
 
  typedef QPDProcessor* QPDProcessorPtr;
 
}
#endif