QGHandlerAdvance.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURQGHANDLERADVANCE_H
#define MINOTAURQGHANDLERADVANCE_H
 
#include <stack>
 
#include "Handler.h"
#include "Engine.h"
#include "Problem.h"
#include "Function.h"
#include "Linearizations.h"
#include "PerspCutGenerator.h"
 
#include "Solution.h"
 
namespace Minotaur {
// MS: remove the ones not needed
struct QGStats {
  size_t nlpS;      
  size_t nlpM;      
  size_t nlpF;      
  size_t nlpI;      
  size_t nlpIL;     
  size_t cuts;    
  size_t fracCuts;    
  //size_t preNodes;    /// Number of nodes on which presolving is carried out
  //size_t preNodesInf;    /// Number of nodes on which presolving is carried out and became infeasible
  //size_t fix;    /// Number of nodes on which vars from implication are fixed
  //size_t prInf;   
  //size_t prAct;   
}; 
 
 
class QGHandlerAdvance : public Handler {
 
private: 
  EnvPtr env_;
 
  double intTol_;
 
  LoggerPtr logger_;
 
  static const std::string me_;
 
  ProblemPtr minlp_;
  
  Timer *timer_;
 
  std::vector<ConstraintPtr> nlCons_;
  
  std::vector<ConstraintPtr> highDualCons_;
  
  EnginePtr nlpe_;
  
  EnginePtr lpe_;
 
  std::stack<Modification *> nlpMods_;
 
  EngineStatus nlpStatus_;
 
  void prModNLP_(const double *x);
 
  void perspectiveCutsObjX_(const double *lpx, CutManager *, SeparationStatus *status);
 
  void perspectiveCutsConsX_(const double *nlpx, const double *lpx, CutManager *, SeparationStatus *status);
 
  void prFeasibleInactive_(bool binVal, UInt bIdx, UInt i, FunctionPtr f, const double *x, double * y, double * prPt, const double * ptToCut, CutManagerPtr cutMan);
 
  bool prInfeasibility_(bool bisect, bool binVal, const double *x, double * y, double * prPt, const double *ptToCut, UInt i, bool isObj, double relVal, UInt bIdx, FunctionPtr f);
 
  void shortestDist_(ConstSolutionPtr sol);
 
  double * solC_;
  VariablePtr objVar_;
 
  bool oNl_;
 
  RelaxationPtr rel_;
 
  double relobj_; 
 
  double solAbsTol_;
 
  double solRelTol_;
 
  double objAbsTol_;
 
  double objRelTol_;
  
  LinearizationsPtr extraLin_;
 
  int rs3_;
  
  double maxVioPer_;
  
  double objVioMul_;
 
  UInt nodeDep_;
 
  std::vector<double > consDual_; 
 
  bool findC_;
 
  std::string cutMethod_;
 
  //double lpdist_;
  //EngineStatus shortestNlpStatus_;
  
  int lastNodeId_;
  
  UInt lastNodeIdPre_;
 
  double lpdist_;
  EngineStatus shortestNlpStatus_;
  
  std::unordered_map<VariablePtr, std::forward_list<impliVar>> impli0_;
  std::unordered_map<VariablePtr, std::forward_list<impliVar>> impli1_;
  
  PerspCutGeneratorPtr prCutGen_;
  
  QGStats *stats_;
 
public:
  QGHandlerAdvance(EnvPtr env, ProblemPtr minlp, EnginePtr nlpe); 
  
  ~QGHandlerAdvance();
   
  Branches getBranches(BrCandPtr, DoubleVector &, RelaxationPtr,
                       SolutionPoolPtr)
  {return Branches();};
 
  void getBranchingCandidates(RelaxationPtr, 
                              const DoubleVector &, ModVector &,
                              BrVarCandSet &, BrCandVector &, bool &) {};
 
  ModificationPtr getBrMod(BrCandPtr, DoubleVector &, RelaxationPtr,
                           BranchDirection)
  {return ModificationPtr();};
 
       
  // Base class method. 
  std::string getName() const;
 
  // Base class method. Check if x is feasible. x has to satisfy integrality
  // and also nonlinear constraints.
  bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation, 
                  bool & should_prune, double &inf_meas);
 
  SolveStatus presolve(PreModQ *, bool *, Solution **sol) {return Finished;};
 
  bool presolveNode(RelaxationPtr, NodePtr, SolutionPoolPtr, ModVector &,
                    ModVector &)
  {return false;};
 
  void postsolveGetX(const double *, UInt, DoubleVector *) {};
 
  void relaxInitFull(RelaxationPtr rel, bool *is_inf);
 
  void relaxInitInc(RelaxationPtr rel, bool *is_inf);
 
  void relaxNodeFull(NodePtr node, RelaxationPtr rel, bool *is_inf);
 
  void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *is_inf);
 
 
  void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, 
                CutManager *cutman, SolutionPoolPtr s_pool, ModVector &p_mods,
                ModVector &r_mods, bool *sol_found, SeparationStatus *status);
 
 
  void setLpEngine(EnginePtr lpe) {lpe_ = lpe;};
 
  void writeStats(std::ostream &out) const;
 
  //ConstSolutionPtr getRootNLPSol_() {return rootNLPSol_;}
 
private:
  void addInitLinearX_(ConstSolutionPtr sol);
 
  void addCutAtRoot_(ConstraintPtr con, const double * x, bool isObj);
 
  void dualBasedCons_(ConstSolutionPtr sol);
 
  //void cutIntSol_(ConstSolutionPtr sol, CutManager *cutMan, 
  void cutIntSol_(const double *lpx, CutManager *cutMan, 
                  SolutionPoolPtr s_pool, bool *sol_found, 
                  SeparationStatus *status);
 
 
  void ESHTypeCut_(const double *lpx, CutManager *cutMan,
                             ConstraintPtr con);
 
 
  void gradientIneq_(const double *nlpx, const double *lpx,
                             CutManager *cutman, SeparationStatus *status,
                             ConstraintPtr con, bool isObj);
 
  void findCenter_();
  void fixInts_(const double *x);
  
  void initLinear_(bool *isInf);
 
  void linearAt_(FunctionPtr f, double fval, const double *x, 
                 double *c, LinearFunctionPtr *lf, int *error);
 
  void linearizeObj_();
 
  void cutToCons_(const double *nlpx, const double *lpx, CutManager *,
                    SeparationStatus *status);
  
  void addCut_(const double *nlpx, const double *lpx, ConstraintPtr con, 
               CutManager *cutman, SeparationStatus *status);
  
  void ECPTypeCut_(const double *x, CutManager *, ConstraintPtr con, double act);
 
  void consCutsAtLpSol_(const double *lpx, CutManager *cutman,
                    SeparationStatus *status);
 
  void genLin_(const double *x, std::vector<UInt> vioCons, CutManager *cutMan);
 
  bool isIntFeas_(const double* x);
 
  void perspReform_();
 
  void maxVio_(ConstSolutionPtr sol, NodePtr node,
                               CutManager *cutMan,
                               SeparationStatus *status);
 
  void ESHTypeCut_(const double *lpx, CutManager *cutMan);
 
  void objCutAtLpSol_(const double *lpx, CutManager *,
                                  SeparationStatus *status, bool fracNode);
  //void objCutAtLpSol_(const double *lpx, CutManager *cutman,
                    //SeparationStatus *status);
 
 
  bool boundaryPtForCons_(double* xnew, const double *xOut,
                                     std::vector<UInt > &vioCons);
  void cutToObj_(const double *nlpx, const double *lpx, CutManager *,
                   SeparationStatus *status);
 
  void relax_(bool *is_inf);
 
  void solveCenterNLP_(EnginePtr nlpe);
 
  void solveNLP_();
 
  void undoMods_();
 
  void updateUb_(SolutionPoolPtr s_pool, double nlpval, bool *sol_found);
 
  //void shortestDist_(ConstSolutionPtr sol);
 
  };
 
  typedef QGHandlerAdvance* QGHandlerAdvancePtr;
}
#endif