UnivarQuadHandler.h

Go to the documentation of this file.

 
//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURUNIVARQUADHANDLER_H
#define MINOTAURUNIVARQUADHANDLER_H
 
#include "Handler.h"
 
namespace Minotaur {
 
class LinearFunction;
class Timer;
typedef LinearFunction* LinearFunctionPtr;
 
struct LinUnivar {
  VariablePtr   y;     
  VariablePtr   x;     
  double a;            
  double b;            
  ConstraintPtr oeCon; 
  ConstraintPtr tan1;  
  ConstraintPtr tan2;  
};
typedef LinUnivar* LinUnivarPtr;                 
typedef std::vector<LinUnivarPtr> LinUnivarVec;  
typedef LinUnivarVec::iterator LinUnivarVecIter; 
 
struct LinBivar {
  VariablePtr y;          
  VariablePtr x1;         
  VariablePtr x2;         
  bool pos;               
  ConstraintPtr oeCon1;   
  ConstraintPtr oeCon2;   
  ConstraintPtr tan1;     
  ConstraintPtr tan2;     
  ConstraintPtr tan3;     
  ConstraintPtr tan4;     
};
typedef LinBivar* LinBivarPtr;                 
typedef std::vector<LinBivarPtr> LinBivarVec;  
typedef LinBivarVec::iterator LinBivarVecIter; 
 
//typedef std::map<VariablePtr, LinSqrPtr, CompareVariablePtr> LinSqrMap;
//typedef LinSqrMap::iterator LinSqrMapIter; ///> Iterator for LinSqrMap
 
class UnivarQuadHandler : public Handler {
public:
  UnivarQuadHandler(EnvPtr env, ProblemPtr problem);
 
  ~UnivarQuadHandler();
 
  // base class method
  void addConstraint(ConstraintPtr newcon);
 
  // Implement Handler::getBranches().
  Branches getBranches(BrCandPtr cand, DoubleVector & x,
                       RelaxationPtr rel, SolutionPoolPtr s_pool);
 
  // base class method
  void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x,
                              ModVector &mods, BrVarCandSet &cands, 
                              BrCandVector &gencands, bool &is_inf);
 
  double getBranchingPt_(double vio, double lb, double ub, double allowed_vio);
 
  // base class method
  ModificationPtr getBrMod(BrCandPtr , DoubleVector &, 
                           RelaxationPtr , BranchDirection )
  { return 0; };
 
  // base class method
  std::string getName() const;
 
  // base class method.
  bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation, 
                  bool &should_prune, double &inf_meas);
 
  // base class method.
  SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **);
 
  // base class method. Tightens bounds.
  bool presolveNode(RelaxationPtr p, NodePtr node,
                    SolutionPoolPtr s_pool, ModVector &p_mods,
                    ModVector &r_mods);
 
  // base class method. Adds linear inequalities
  void relaxInitFull(RelaxationPtr rel, SolutionPool *sp, bool *is_inf);
 
  // Does nothing.
  void relaxInitInc(RelaxationPtr rel, SolutionPool *sp, bool *is_inf);
 
  // Does nothing.
  void relaxNodeFull(NodePtr node, RelaxationPtr rel, bool *is_inf);
 
  // Does nothing.
  void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *is_inf);
 
 
  // base class method. Adds linearlization cuts when available.
  void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel, 
                CutManager *cutman, SolutionPoolPtr s_pool, ModVector &p_mods,
                ModVector &r_mods, bool *sol_found, SeparationStatus *status);
 
  // base class method. 
  void writeStats(std::ostream &out) const;
 
private:
  struct SepaStats 
  {
    int iters;   
    int cuts;    
    double time; 
  };
 
  struct PresolveStats 
  {
    int iters;   
    double time; 
    double timeN;
    int vBnd;    
    int nMods;   
  };
 
  double aTol_;
 
  double bTol_;
 
  LinBivarVec bivarFuns_;
 
  LoggerPtr logger_;
      
  static const std::string me_;
 
  ProblemPtr p_;
 
  PresolveStats pStats_;
 
  double rTol_;
 
  SepaStats sStats_;
 
  const Timer* timer_;
 
  LinUnivarVec univarFuns_;
 
  void addCut_(RelaxationPtr rel, LinUnivarPtr luv, double xl, double xval,
               double yval, bool &ifcuts);
 
  void addCut_(RelaxationPtr rel, LinBivarPtr lbv, double x1l, double x2l,
               double x1val, double x2val, double yval, bool &ifcuts);
 
  bool bwdPropBivar_(LinBivarPtr lbv, bool *changed);
  
  bool bwdPropBivar_(LinBivarPtr lbv, RelaxationPtr rel, bool mod_rel,
                    bool *changed, ModVector &p_mods, ModVector &r_mods);
 
  bool bwdPropUnivar_(LinUnivarPtr luv, bool *changed);
  
  bool bwdPropUnivar_(LinUnivarPtr luv, RelaxationPtr rel, bool mod_rel,
                    bool *changed, ModVector &p_mods, ModVector &r_mods);
 
  double calcUpperUnivar_(double a, double b, double lx, double ux);
  
  void findLinPt_(double xval, double yval, LinUnivarPtr luv, double &xl);
  
  bool fwdPropBivar_(LinBivarPtr lbv, bool *changed);
 
  bool fwdPropBivar_(LinBivarPtr lbv, RelaxationPtr rel, bool mod_rel,
                    bool *changed, ModVector &p_mods, ModVector &r_mods);
  
  bool fwdPropUnivar_(LinUnivarPtr luv, bool *changed);
 
  bool fwdPropUnivar_(LinUnivarPtr luv, RelaxationPtr rel, bool mod_rel,
                    bool *changed, ModVector &p_mods, ModVector &r_mods);
 
  LinearFunctionPtr getSecant_(VariablePtr y, VariablePtr x,
                               double a, double b);
 
  std::vector<LinearFunctionPtr> getSecant_(VariablePtr y, VariablePtr x1,
                VariablePtr x2, bool pos, DoubleVector &rhs);
  
  LinearFunctionPtr getTangent_(VariablePtr y, VariablePtr x,
                               double a, double b, double pt);
 
  LinearFunctionPtr getTangent_(VariablePtr y, VariablePtr x1, VariablePtr x2,
                               bool pos, UInt i, double &rhs);
 
  bool isAtBnds_(ConstVariablePtr x, double xval);
 
  bool isViolatedAtBounds_(ConstraintPtr c1, ConstraintPtr c2, VariablePtr x1,
                      VariablePtr x2, double l1, double u1, double l2,
                      double u2, bool pos);
 
  void relax_(RelaxationPtr rel, bool *is_inf);
 
  void resetStats_();
 
  void upBivarCon_(LinBivarPtr lbv, RelaxationPtr rel, ModVector &r_mods);
 
  int updatePBounds_(VariablePtr v, double lb, double ub, bool *changed);
 
  int updatePBounds_(VariablePtr v, double lb, double ub, RelaxationPtr rel,
                     bool mod_rel, bool *changed, ModVector &p_mods,
                     ModVector &r_mods);
 
  void upUnivarCon_(ConstraintPtr con, VariablePtr x, VariablePtr y, double a, 
                    double b, RelaxationPtr rel, ModVector &r_mods);
 
  bool varBndsFromCons_(bool *changed);
};
 
typedef UnivarQuadHandler* UnivarQuadHandlerPtr;
}
#endif