PerspCutHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURPERSPCUTHANDLER_H
#define MINOTAURPERSPCUTHANDLER_H
 
#include "Handler.h"
#include "Problem.h"
#include "Function.h"
#include "PerspCon.h"
#include "LinearFunction.h"
 
namespace Minotaur {
//MS: constraint form expected is f(x) <= b
  class PerspCutHandler;
  typedef PerspCutHandler* PerspCutHandlerPtr;
  typedef const PerspCutHandler* ConstPerspCutHandlerPtr;
 
  struct PRStats {
    size_t imprvPt;   
    size_t infPt;   
    size_t cuts;      
  }; 
 
  class PerspCutHandler : public Handler {
  public:
 
  PerspCutHandler();
  
  PerspCutHandler(EnvPtr env, ProblemPtr problem);
 
  ~PerspCutHandler();
 
  virtual Branches getBranches(BrCandPtr, DoubleVector &,
                               RelaxationPtr, SolutionPoolPtr)
    {return Branches();}; 
 
  // Does nothing.
  virtual void getBranchingCandidates(RelaxationPtr,
                                      const DoubleVector &, ModVector &,
                                      BrVarCandSet &, BrCandVector &,
                                      bool &) {};
 
  virtual ModificationPtr getBrMod(BrCandPtr, DoubleVector &,
                                   RelaxationPtr, BranchDirection)
    {return ModificationPtr();};
 
  std::string getName() const;
 
  SolveStatus presolve(PreModQ *, bool *, Solution **sol) {return Finished;};
 
  virtual bool presolveNode(RelaxationPtr, NodePtr,
                            SolutionPoolPtr, ModVector &,
                            ModVector &) {return false;};
 
  void relaxInitFull(RelaxationPtr, bool * ) {};
  
  void relaxInitInc(RelaxationPtr, bool * ) {};
  
  void relaxNodeFull(NodePtr, RelaxationPtr, bool * ) {};
 
  void relaxNodeInc(NodePtr, RelaxationPtr, bool * ) {};
 
   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 addCut(RelaxationPtr rel, const double *nlpx, const double *lpx, UInt it,
              SeparationStatus * pcStatus);
 
  void atIntPt(RelaxationPtr rel , const double * nlpx, 
                 const double *lpx, SeparationStatus * pcStatus, CutManager *);
  
  void linearAt(RelaxationPtr rel, FunctionPtr f, double fval,
                const double *x, double *c, LinearFunctionPtr *lf,
                int *error);
  void getCutFun(RelaxationPtr rel,LinearFunctionPtr *lf, UInt it, const double *x, 
               double *c, int *error);
 
  void addCutToRel(RelaxationPtr rel, LinearFunctionPtr lf, double c);
 
  //void addCutOriFeas(RelaxationPtr rel , UInt it, const double *x);
 
  void oriFeasPt(RelaxationPtr rel , const double *x);
 
  void oriInfeasPt(RelaxationPtr rel, const double *x);
 
  //void addPCut(RelaxationPtr rel , UInt it, const double *x);
 
  void atPtx(RelaxationPtr rel, const double *x);
  
  void cutToCons(RelaxationPtr rel, const double *x, UInt it);
  //void feasBisecPt(const double *x, double *y, UInt it);
 
  //void vertexPt(double * y, UInt it);
 
  //void bisecPtOri(const double *x, double * w, double * w1, UInt it);
 
 
  void bisecPt(const double *x, double * y, UInt it);
  
  void cvxCombPt(RelaxationPtr rel, const double * y, UInt it);
 
  double changeVarForm(VariablePtr v, double xc, double xb, UInt itn,
                       int *error);
  void linearAt(RelaxationPtr rel, const double *y, double *c, LinearFunctionPtr *lf, UInt itn, int *error);
 
  std::vector<ConstraintPtr> getPRCons() {return cons_;};
  
  //std::vector<VariablePtr> getPRBinVar() {return binvar_;};
 
  //std::vector<UInt> getPRStruct() {return sType_;};
 
  bool isFeasible(ConstSolutionPtr, RelaxationPtr, bool &, double &);
 
  void prVars(const double *x, double *y,  UInt itn, int *error);
 
  void findPRCons();
 
  bool getStatus();
 
 
  void writeStats(std::ostream &out) const;
  
private:
  
  EnvPtr env_;
  
  ProblemPtr minlp_;
  
  LoggerPtr logger_;
 
  double solAbsTol_;
  
  double solRelTol_;
  
  double intTol_;
 
  double* cvxPt;
 
  PRStats *stats_;
 
  static const std::string me_;
  
  std::vector<ConstraintPtr> cons_;
   
  std::vector<ConstraintPtr> prcons_;
  
  std::vector<VariablePtr> binvar_;
 
  std::vector<int> sType_;
  
  std::vector<VariableGroup> nviv_;
 
 // the constraints amenable to PR are fixed to 
  std::vector<VariableGroup> lviv_;
  };
}
 
#endif // MINOTAURPERSPCUTHANDLER_H