PerspCutGenerator.h

Go to the documentation of this file.

//
//    Minotaur -- It's only 1/2 bull
//
//    (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURPERSPCUTGENERATOR_H
#define MINOTAURPERSPCUTGENERATOR_H
 
#include "CutManager.h"
#include "Engine.h" 
#include "Problem.h"
#include "Function.h"
#include "PerspCon.h"
#include "SolutionPool.h"
#include "LinearFunction.h"
 
namespace Minotaur {
//MS: constraint form expected is f(x) <= b
// MS: make functions private/public
  class PerspCutGenerator;
  typedef PerspCutGenerator* PerspCutGeneratorPtr;
  typedef const PerspCutGenerator* ConstPerspCutGeneratorPtr;
 
  struct PRStats {
    size_t imprvPt;   
    size_t infPt;   
    size_t cuts;      
  }; 
 
  class PerspCutGenerator {
  public:
 
  PerspCutGenerator();
  
  PerspCutGenerator(EnvPtr env, ProblemPtr problem, EnginePtr nlpe_);
 
  ~PerspCutGenerator();
 
 
  bool addPC(RelaxationPtr rel, const double * y, UInt i, 
                              const double *ptToCut, const double *prPt, bool isObj,
                              VariablePtr objVar, CutManagerPtr cutMan, double relVal);
 
  std::string getName() const;
  
  UInt getNumCuts() {return stats_->cuts;}
 
  void fixedValue(double * prPt, bool isObj, UInt i);
 
  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);
 
  bool addCutToRel(RelaxationPtr rel, const double * ptToCut, 
                                    LinearFunctionPtr lf, double c, VariablePtr objVar, double relVal, CutManagerPtr);
  //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);
 
 
  bool bisecPt(double *x, double * newPt, UInt i,
                                bool isObj, double relVal);
 
  void cvxCombPt(RelaxationPtr rel, const double * y, UInt it);
 
  bool changeVarForm(VariablePtr v, double xc, double sb, UInt itn, double *newPt, bool isObj, bool nlin);
  void linearAt(RelaxationPtr rel, const double *x, const double *prPt, double *c, LinearFunctionPtr *lf, UInt itn, int *error, bool isObj);
 
  std::vector<prCons> getPRCons() {return prCons_;};
  
  prObj getPRObj() {return prObj_;};
  
  //std::vector<VariablePtr> getPRBinVar() {return binvar_;};
 
  //std::vector<UInt> getPRStruct() {return sType_;};
 
  UInt isFeasible(const double *x, UInt i, bool isObj, double relVal);
 
  //variables, if z has value 0 then the function returns false; And if z has
  //value 1, then the function returns the same point. Similarly, for z = 1
  //fixing case.
  bool prVars(const double *y, double *prPt, UInt itn, bool isObj);
 
  void findPRCons();
 
  bool uniDirZSearch(double *y, double * newPt, UInt i, double zdir);
 
  bool getStatus();
  
 
  //only if solC_ satisfies the PR amenable constraint or (xC, 1) satisfies,
  //where xC is x components of  solC_.
  bool lineSearchAC(double *y, double * newPt, UInt i, bool isObj, double relVal);
 
  void writeStats(std::ostream &out) const;
  
private:
 
  //void fixBinVars_(std::stack<Modification *> &varMods);
  
  //void unfixBinVars_(std::stack<Modification *> &varMods);
  
  bool lineSearch_(double *y, double * newPt, UInt i, bool isObj, double relVal);
  EnvPtr env_;
  
  ProblemPtr minlp_;
 
  EnginePtr nlpe_;
  
  LoggerPtr logger_;
 
  double solAbsTol_;
  
  double solRelTol_;
  
  double objAbsTol_;
 
  double objRelTol_;
  
  double intTol_;
 
  double* cvxPt;
 
  PRStats *stats_;
 
  static const std::string me_;
  
  std::vector<prCons> prCons_;
 
  prObj prObj_;
 
  double * solC_;
 
  //bool isObj_;
 
  };
}
 
#endif // MINOTAURPERSPCUTHANDLER_H