STOAHandler.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURSTOAHANDLER_H
#define MINOTAURSTOAHANDLER_H
 
#include <stack>
 
#include "Handler.h"
#include "Engine.h"
#include "MILPEngine.h"
#include "Problem.h"
#include "Function.h"
#include "Timer.h"
 
namespace Minotaur {
 
struct STOAStats {
  size_t nlpS;      
  size_t nlpF;      
  size_t nlpI;      
  size_t nlpIL;     
  size_t cuts;      
};
 
class STOAHandler : public Handler {
 
private: 
  EnvPtr env_;
 
  double intTol_;
 
  LoggerPtr logger_;
 
  static const std::string me_;
 
  ProblemPtr minlp_;
 
  Timer *timer_;
 
  ConstraintVector nlCons_;
 
  EnginePtr nlpe_;
  
  MILPEnginePtr milpe_;
 
  //std::stack<Modification *> nlpMods_;
  
  EngineStatus nlpStatus_;
 
  VariablePtr objVar_;
 
  bool oNl_;
  
  double newUb_;
 
  RelaxationPtr rel_;
 
  SolutionPoolPtr solPool_;
 
  //double relobj_;
 
  double solAbsTol_;
 
  double solRelTol_;
 
  double npATol_;
 
  double npRTol_;
 
  UInt numCalls_;
 
  double cbtime_;
 
  STOAStats *stats_;
 
 
public:
  STOAHandler(EnvPtr env, ProblemPtr minlp, EnginePtr nlpe, MILPEnginePtr milpe, SolutionPoolPtr solPool); 
 
  ~STOAHandler();
   
  Branches getBranches(BrCandPtr, DoubleVector &, RelaxationPtr,
                       SolutionPoolPtr)
  {return Branches();};
 
  UInt getNumCalls() {return numCalls_;}
 
  double getCbTime() {return cbtime_;}
 
  void setCbTime(double timeval) {cbtime_ = timeval;}
 
  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, RelaxationPtr, 
                  bool &, double &) {return 0;};
 
  //bool isFeas(const double* x);
 
  SolveStatus presolve(PreModQ *, bool *, Solution **) {return Finished;};
 
  bool presolveNode(RelaxationPtr, NodePtr, SolutionPoolPtr, ModVector &,
                    ModVector &)
  {return false;};
 
  void postsolveGetX(const double *, UInt, DoubleVector *) {};
 
  // Base class method. calls relax_().
  void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) {};
 
  // Base class method. calls relax_().
  void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *);
 
  // Base class method. Does nothing.
  void relaxNodeFull(NodePtr, RelaxationPtr, bool *) {};
 
  // Base class method. Does nothing.
  void relaxNodeInc(NodePtr, RelaxationPtr, bool *) {};
 
 
  // Base class method. Find cuts.
  void separate(ConstSolutionPtr, NodePtr, RelaxationPtr, 
                CutManager *, SolutionPoolPtr, ModVector &, 
                ModVector &, bool *, SeparationStatus *) {};
 
  //void solveMILP(double* objfLb, double* objfUb,
                 //SolutionPoolPtr solPool, CutManager* cutMan);
  void solveMILP(double* objfLb, ConstSolutionPtr* sol,
                 SolutionPoolPtr solPool, CutManager* cutMan);
  // Show statistics.
  void writeStats(std::ostream &out) const;
 
  // Return the relaxation pointer
  RelaxationPtr getRel() {return rel_;}
 
  // Return true if the fixed NLP was feasible
  //bool fixedNLP(const double *lpx, const double * nlpx);
  bool fixedNLP(const double *lpx, EnginePtr &nlpe, ProblemPtr &minlp);
 
  // Return the upper bound obtained from an integer solution
  double newUb(std::vector<UInt> *varIdx,
                        std::vector<double>* varCoeff);
 
  //void cutIntSol(const double *lpx, double objVal);
 
  ConstraintConstIterator consBegin() const { return nlCons_.begin(); }
 
  ConstraintConstIterator consEnd() const { return nlCons_.end(); }
 
 
  void OACutToCons(const double *lpx, ConstraintPtr con, double* rhs,
                   std::vector<UInt> *varIdx, std::vector<double>* varCoeff,
                   EnginePtr nlpe);
 
  void OACutToObj(const double *lpx, double* rhs, std::vector<UInt> *varIdx,
                  std::vector<double>* varCoeff, double ub, EnginePtr nlpe);
 
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, ProblemPtr minlp, std::stack<Modification *> &nlpMods);
  
  void initLinear_(bool *isInf);
 
  void linearizeObj_();
 
 
  void linearAt_(FunctionPtr f, double fval, const double *x, 
                 double *c, LinearFunctionPtr *lf, int *error);
 
  void cutToCons_(ConstraintPtr con, const double *nlpx, const double *lpx, double* rhs, std::vector<UInt> *varIdx,
                            std::vector<double>* varCoeff);
  
  void addCut_(const double *nlpx, const double *lpx, ConstraintPtr con, double* rhs, std::vector<UInt> *varIdx,
                            std::vector<double>* varCoeff);
 
  void objCutAtLpSol_(const double *lpx, double* rhs,
                             std::vector<UInt> *varIdx,
                            std::vector<double>* varCoeff, double relobj);
 
  void consCutAtLpSol_(ConstraintPtr con, const double *lpx, double* rhs,
                             std::vector<UInt> *varIdx,
                            std::vector<double>* varCoeff);
 
  void cutToObj_(const double *nlpx, const double *lpx,
                 double* rhs, std::vector<UInt> *varIdx,
                            std::vector<double>* varCoeff, double relobj);
 
  void relax_(bool *is_inf);
 
  void solveNLP_();
 
  void unfixInts_(ProblemPtr minlp, std::stack<Modification *> &nlpMods);
 
  void updateUb_(SolutionPoolPtr s_pool, double *nlp_val, bool *sol_found);
 
  };
 
  typedef STOAHandler* STOAHandlerPtr;
}
#endif