Linearizations.h

Go to the documentation of this file.

// 
//     Minotaur -- It's only 1/2 bull
// 
//     (C)opyright 2009 - 2025 The Minotaur Team.
// 
 
#ifndef MINOTAURLINEARIZATIONS_H
#define MINOTAURLINEARIZATIONS_H
 
#include <stack>
 
#include "Handler.h"
#include "Engine.h"
#include "Problem.h"
#include "Function.h"
 
#include "Solution.h"
 
namespace Minotaur {
 
  struct LinStats {
  size_t cuts;    
  size_t rs1Cuts; 
  size_t rs2Cuts; 
  size_t rs3Cuts; 
  size_t rs4Cuts; 
  size_t rgs1Cuts; 
  size_t rgs2Cuts; 
  double linSchemesTime; 
};
 
class Linearizations {
 
private: 
  EnvPtr env_;
 
  RelaxationPtr rel_;
 
  ProblemPtr minlp_;
  
  Timer *timer_;
 
  double intTol_;
 
  LoggerPtr logger_;
 
  static const std::string me_;
 
  std::vector<ConstraintPtr> nlCons_;
 
  //EnginePtr lpe_;
 
  EnginePtr nlpe_;
 
  std::stack<Modification *> nlpMods_;
 
  EngineStatus nlpStatus_;
 
  //VariablePtr objVar_;
 
  //bool oNl_;
 
  double rs1_;
  
  double rs2Per_;
 
  double rs2NbhSize_;
  
  UInt rs3_;
  
  bool rgs1_;
  
  double rgs2Per_;
 
  //double relobj_; 
  
  double solAbsTol_;
  
  double * solC_; 
 
  double * nlpx_; 
 
  double solRelTol_;
 
  double objATol_;
 
  double objRTol_;
  
  double nbhSize_; //MS: make a parameter later
 
  // populate this if any general scheme is on 
  std::vector<VariablePtr> varPtrs_; 
  
  bool oNl_;
  // auxiliary variable for nonlinear objective
  VariablePtr objVar_;
    
  // index of the variables to be changed in line search
  std::vector<UInt > changeVar_;
 
  double * nlpDuals_;
 
  bool hasEqCons_;
  
  UInt numDir_;
 
  // Is the center point found as a boundary point?
  bool isBoundPt_;
 
  LinStats *stats_;
 
 
  public:
  Linearizations(EnvPtr env, RelaxationPtr rel,
                               ProblemPtr minlp, std::vector<ConstraintPtr> nlCons,
                               VariablePtr objVar, ConstSolutionPtr sol); 
  
  ~Linearizations();
   
  //void rootLinearizations(const double * nlpx);
  bool rootLinearizationsUniS();
  
  void rootLinearizationsGen();
 
  double * getCenter() {return solC_;}
  
  void findCenter();
  
  LinStats* getStats() {return stats_; };
 
  void rootLinScheme3(EnginePtr lpe_, SeparationStatus *status);
 
  //void setLpEngine(EnginePtr lpe) {lpe_ = lpe;};
  
  void setNlpEngine(EnginePtr nlpe) {nlpe_ = nlpe;};
 
  void writeStats(std::ostream &out) const;
 
 
private:
 
  bool addCutAtRoot_(double *x, FunctionPtr f, UInt &newConId, double UB,
                     bool isObj);
 
  //void objCutGenScheme2_(double *xnew, double *lastGrad,
                                       //double &alpha);
 
  bool boundaryPtForObj_(double* xnew, const double *xOut,
                                     std::vector<ConstraintPtr> &vioCons);
 
  void candConsForObj_(double *xOut, std::vector<ConstraintPtr > &consToLin,
                       bool &active, bool &vio);
 
  void candLinCons_(const double *x, std::vector<UInt > &consToLin,
                             bool &foundActive, bool &foundVio);
 
  void cutsAtBoundary_(double *xOut);
 
  bool findIntersectPt_(std::vector<UInt > newConsId, VariablePtr vl,
                       VariablePtr vnl, double * iP);
 
  bool boundaryPtForCons_(double* xnew, const double *xOut, 
                                     std::vector<UInt > &vioCons);
 
  void solveNLP_();
 
 
  void setStepSize_(double &alpha, std::vector<VariablePtr > vars,
                                  double *xOut, std::vector<double > unitVec);
 
  void foundLinPt_(UInt vIdx, std::vector<UInt> varIdx, UInt pos,
                   std::vector<double> alphaSign, double varBound, double *xOut,
                   bool isAllOne);
 
  void insertNewPt_(UInt j, UInt k, std::vector<double > & xc, 
                    std::vector<double> & yc, ConstraintPtr con, 
                    VariablePtr vl, VariablePtr vnl, bool & shouldCont);
 
 
  double angleBetVectors_(double *v1, double *v2, int n);
 
  bool isInteriorPt_(double *xOut,
                                   std::vector<double* > & lastGrad,
                                   double* & lastGradObj, double &alpha);
 
  void findLinPoint_(double *xOut, std::vector<double* > & lastGrad,
                                   double * &lastGradObj, double &alpha);
 
  void genLin_(double *x, std::vector<UInt > vioConsPos,
                                     std::vector<double *> &lastGrad,
                                     double * &lastGradObj, double &alpha);
 
  bool genLinObj_(double *x, double* &lastGradObj);
 
  void genLin_(const double *x, std::vector<UInt > vioConsPos);
 
  void linearAt_(FunctionPtr f, double fval, const double *x, 
                 double *c, LinearFunctionPtr *lf, int *error);
 
 
  bool linPart_(double *b1, UInt lVarIdx, double lVarCoeff,
                double act, FunctionPtr f, double UB);
 
  bool atBound_(std::vector<double > unitVec, std::vector<VariablePtr > vars);
 
  bool boundCheck_(double dirVal, double varVal, VariablePtr v);
 
  bool newPoint_(std::vector<VariablePtr> vars, double *xOut, double alpha,
                 std::vector<double> unitVec);
 
  void rootLinGenScheme1_();
    
  void ifNonlinCons_();
 
  void ifOnlyNonlinObj_();
  
  void rootLinGenScheme2_();
  void rootLinScheme1_(FunctionPtr fun, double lVarCoeff, UInt lVarIdx,
                       UInt nVarIdx, double nVarCoeff, double UB, bool isObj);
  
  void rootLinScheme2_(FunctionPtr f, double UB, double lVarCoeff,
                       UInt lVarIdx, UInt nVarIdx, bool isObj);
 
  void rScheme2Cut_(FunctionPtr f, double UB, double &delta, double lVarCoeff,
                    double &lastSlope, UInt nVarIdx, double * npt,
                    double * grad, bool isObj);
 
  void exploreDir_(std::vector<VariablePtr > vars, std::vector<double > dir,
                   double* xOut, double* objGrad,
                   std::vector<double* > nlconsGrad);
 
  bool shouldStop_(EngineStatus eStatus);
 
  bool objCut_(const double* xNew);
 
  void search_(std::vector<VariablePtr > vars, std::vector<double* > nlconsGrad,
               double *xOut, double *objGrad, std::vector<double > dir);
 
  bool uniVarNlFunc_(FunctionPtr f, double &lVarCoeff, UInt & lVarIdx,
                     UInt & nVarIdx, double &nVarCoeff, bool isObj);
 
  void updateInfo_(std::vector<double > &xc,
                                 std::vector<double > &yc,
                                 std::vector<double > &linVioVal, UInt j);
  void varsInNonlinCons_();
  };
 
  typedef Linearizations* LinearizationsPtr;
}
#endif