QGAdvHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2009 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURQGADVHANDLER_H
#define MINOTAURQGADVHANDLER_H
 
#include <stack>
 
#include "Handler.h"
#include "Engine.h"
#include "Problem.h"
#include "Function.h"
#include "PerspCutHandler.h"
 
namespace Minotaur {
 
struct QGStats {
  size_t nlpS;      
  size_t nlpF;      
  size_t nlpI;      
  size_t nlpIL;     
  size_t cuts;      
};
 
 
class QGAdvHandler : public Handler {
 
private:
  EnvPtr env_;
 
  double intTol_;
 
  LoggerPtr logger_;
 
  static const std::string me_;
 
  ProblemPtr minlp_;
 
  std::vector<ConstraintPtr> nlCons_;
 
  EnginePtr nlpe_;
 
  std::stack<Modification *> nlpMods_;
  
  EngineStatus nlpStatus_;
 
  VariablePtr objVar_;
 
  bool oNl_;
 
  RelaxationPtr rel_;
 
  double relobj_;
 
  double solAbsTol_;
 
  double solRelTol_;
 
  double npATol_;
 
  double npRTol_;
 
  QGStats *stats_;
 
  bool prStatus_;
 
  PerspCutHandlerPtr pcPtr_;
 
public:
  QGAdvHandler();
 
  QGAdvHandler(EnvPtr env, ProblemPtr minlp, EnginePtr nlpe);
   
  QGAdvHandler(EnvPtr env, ProblemPtr minlp, EnginePtr nlpe,
            PerspCutHandlerPtr pcHand);
 
  ~QGAdvHandler();
   
  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 writeStats(std::ostream &out) const;
 
private:
  void addInitLinearX_(const double *x);
 
  void cutIntSol_(ConstSolutionPtr sol, CutManager *cutMan,
                  SolutionPoolPtr s_pool, bool *sol_found,
                  SeparationStatus *status);
 
  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 oaCutToCons_(const double *nlpx, const double *lpx, CutManager *,
                    SeparationStatus *status);
  
  void addCut_(const double *nlpx, const double *lpx, ConstraintPtr con,
               CutManager *cutman, SeparationStatus *status);
  
  void oaCutToObj_(const double *nlpx, const double *lpx, CutManager *,
                   SeparationStatus *status);
 
  void oaCutEngLim_(const double *lpx, CutManager *cutman,
                    SeparationStatus *status);
 
  void relax_(bool *is_inf);
 
  void solveNLP_();
 
  void unfixInts_();
 
  void updateUb_(SolutionPoolPtr s_pool, double *nlp_val, bool *sol_found);
 
  };
 
  typedef QGAdvHandler* QGAdvHandlerPtr;
}
#endif