CxQuadHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURCXQUADRATICHANDLER_H
#define MINOTAURCXQUADRATICHANDLER_H
 
#include "Handler.h"
#include "Types.h"
 
namespace Minotaur {
 
class Engine;
class Function;
class LinearFunction;
class Problem;
class QuadraticFunction;
typedef LinearFunction* LinearFunctionPtr;
typedef QuadraticFunction* QuadraticFunctionPtr;
 
struct Secant {
  VariablePtr   auxVar;   
  VariablePtr   sqVar;    
  ConstraintPtr cons;     
};
 
typedef Secant * SecantPtr;
 
typedef std::vector< SecantPtr >::iterator SecantIterator;
 
typedef std::map<VariablePtr, SecantPtr, CompareVariablePtr> VarSecantMap;
 
typedef VarSecantMap::iterator VarSecantMapIter;
 
 
class McCormick {
public:
  typedef enum {
    LT,
    GT,
    EQ
  } Sense;
 
private:
  VariablePtr x0_;
 
  VariablePtr x1_;
 
  VariablePtr y_;
 
  Sense s_;
 
  ConstraintPtr c0_;
        
  ConstraintPtr c1_;
 
  ConstraintPtr c2_;
 
  ConstraintPtr c3_;
 
public:
  McCormick(VariablePtr x0, VariablePtr x1, Sense sense);
 
  ~McCormick();
 
  void setAux(VariablePtr y) {y_ = y;};
 
  void setC0(ConstraintPtr c) {c0_ = c;};
 
  void setC1(ConstraintPtr c) {c1_ = c;};
 
  void setC2(ConstraintPtr c) {c2_ = c;};
 
  void setC3(ConstraintPtr c) {c3_ = c;};
 
  ConstraintPtr getC0() {return c0_;};
  ConstraintPtr getC1() {return c1_;};
  ConstraintPtr getC2() {return c2_;};
  ConstraintPtr getC3() {return c3_;};
 
  VariablePtr getAux() {return y_;};
 
  VariablePtr getX0() {return x0_;};
 
  VariablePtr getX1() {return x1_;};
 
  VariablePtr getOtherX(ConstVariablePtr x) const;
 
  Sense getSense() {return s_;};
 
  void  setSense(Sense sense) {s_ = sense;};
 
  bool isViolated(const double *x, const double &tol) const;
 
  bool isViolated(const double &x0val, const double &x1val, 
                  const double &y0val, const double &tol) const;
};
typedef McCormick* McCormickPtr;
 
struct CompareMcCormick {
  bool operator()(McCormickPtr b0, McCormickPtr b1) const;
};
 
typedef std::set<McCormickPtr, CompareMcCormick> McCormickSet;
 
typedef McCormickSet::iterator McCormickSetIter;
 
 
class CxQuadHandler : public Handler {
protected:
  VarSecantMap cvCons_;
 
  McCormickSet mcCons_;
 
  VarSet brVars_;
 
  double eTol_;
 
  LoggerPtr logger_;
      
  static const std::string me_;
 
  ProblemPtr problem_;
 
  void relaxTwoSided_(QuadraticFunctionPtr qf, ConstraintPtr cons,
                      RelaxationPtr rel);
 
  void relaxOneSided_(QuadraticFunctionPtr qf, ConstraintPtr cons, 
                      RelaxationPtr rel);
 
  void relaxObj_(ObjectivePtr obj, RelaxationPtr rel);
 
  void addSecant_(VariablePtr x, VariablePtr y, RelaxationPtr rel);
 
  LinearFunctionPtr getNewSecantLf_(VariablePtr x, VariablePtr y, 
                                    double & lb, double & ub, double & r);
 
  VariablePtr addMcCormick_(VariablePtr x0, VariablePtr x1, 
                            RelaxationPtr rel);
 
  VariablePtr addMcCormickLower_(VariablePtr x0, VariablePtr x1, 
                                 RelaxationPtr rel);
 
  VariablePtr addMcCormickUpper_(VariablePtr x0, VariablePtr x1, 
                                 RelaxationPtr rel);
 
  LinearFunctionPtr getMcLf_(VariablePtr x0, double lb0, double ub0,
                             VariablePtr x1, double lb1, double ub1, VariablePtr y, 
                             double &rhs, UInt i);
 
  void binToLin_();
  void binToLinFun_(FunctionPtr f, LinearFunctionPtr lf2);
 
  void relax_(RelaxationPtr rel, bool *is_inf);
 
  void removeFixed_();
  void removeFixedFun_(FunctionPtr f, LinearFunctionPtr lf2, double *c);
public:
  CxQuadHandler(EnvPtr env, ProblemPtr problem);
 
  ~CxQuadHandler();
 
  // Does nothing.
  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);
 
 
  bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation, 
                  bool &is_inf, double &inf_meas);
 
  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 getBranchingCandidates(RelaxationPtr rel, 
                              const DoubleVector &x, ModVector &mods,
                              BrVarCandSet &cands, BrCandVector &,
                              bool & is_inf);
 
  // Implement Handler::getBrMod().
  ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x, 
                           RelaxationPtr rel, BranchDirection dir);
 
  // Implement Handler::getBranches().
  Branches getBranches(BrCandPtr cand, DoubleVector & x,
                       RelaxationPtr rel, SolutionPoolPtr s_pool);
 
  // presolve.
  SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol);
 
  // Implement Handler::presolveNode().
  bool presolveNode(RelaxationPtr rel, NodePtr node,
                    SolutionPoolPtr s_pool, ModVector &p_mods,
                    ModVector &r_mods);
 
  // Write name
  std::string getName() const;
 
};
 
typedef CxQuadHandler* CxQuadHandlerPtr;
 
typedef const CxQuadHandler* CxQuadConstHandlerPtr;
}
#endif