NlPresHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURNLPRESHANDLER_H
#define MINOTAURNLPRESHANDLER_H
 
#include "Handler.h"
#include "VarBoundMod.h"
#include "QuadraticFunction.h"
 
namespace Minotaur {
 
class CGraph;
class CNode;
class PreAuxVars;
typedef CGraph* CGraphPtr;
typedef PreAuxVars* PreAuxVarsPtr;
 
 
struct NlPresStats 
{
  int iters;    
  double time;  
  double timeN; 
  int varDel;   
  int conDel;   
  int conRel;   
  int infBnds;  
  int pRefs;    
  int vBnd;     
  int cBnd;     
  int cImp;     
  int nMods;    
  int qCone;    
};
 
 
struct NlPresOpts {
  bool doPresolve; 
  bool showStats;  
  int  maxIters;   
  bool coeffImp;   
}; 
 
 
class NlPresHandler : public Handler {
public:
 
  NlPresHandler();
 
  NlPresHandler(EnvPtr env, ProblemPtr p);
 
  ~NlPresHandler();
 
  // Does nothing.
  void relaxInitFull(RelaxationPtr , SolutionPool *, bool *) {};
 
  // Does nothing.
  void relaxInitInc(RelaxationPtr , SolutionPool *, bool *) {};
 
  // Does nothing.
  void relaxNodeFull(NodePtr , RelaxationPtr , bool *) {};
 
  // Does nothing.
  void relaxNodeInc(NodePtr , RelaxationPtr , bool *) {};
 
  bool isFeasible(ConstSolutionPtr, RelaxationPtr, bool &, double &)
  {return true;}
 
  void separate(ConstSolutionPtr , NodePtr , RelaxationPtr , CutManager *,
                SolutionPoolPtr , ModVector &, ModVector &, bool *,
                SeparationStatus *) {};
 
  void getBranchingCandidates(RelaxationPtr, const DoubleVector &,
                              ModVector &, BrVarCandSet &, BrCandVector &,
                              bool &) {};
 
  ModificationPtr getBrMod(BrCandPtr, DoubleVector &, 
                           RelaxationPtr, BranchDirection)
  {return ModificationPtr();}; // NULL
 
  Branches getBranches(BrCandPtr, DoubleVector &, RelaxationPtr, 
                               SolutionPoolPtr)
  {return Branches();}; // NULL
 
  // presolve.
  SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol);
 
  // Implement Handler::presolveNode().
  bool presolveNode(RelaxationPtr p, NodePtr node, SolutionPoolPtr s_pool,
                    ModVector &p_mods, ModVector &rmods);
 
  // Write name
  std::string getName() const;
 
  void simplePresolve(ProblemPtr p, SolutionPoolPtr s_pool,
                      ModVector &t_mods, SolveStatus &status);
  void writePreStats(std::ostream &out) const;
 
  // base class method.
  void writeStats(std::ostream &out) const;
 
 
 
 
 
 
 
  void x_bound_with_c(double a,double b,double c, double *l,
                                    double *u, double *l2);
 
 
  //void x_bound_range_with_c(double a,double blb,double bub, double c, double *l,
                                  //double *u, int infeasibility);
 
 
 void linear_var_set(VariableSet lfvars, FunctionPtr f,VariableSet *linear_terms);
 
  void lin_var_bound(VarBoundModVector lfmod, LinearFunctionPtr lf, QuadraticFunctionPtr qf, 
                              VariableSet qfvars,  VariableSet linear_terms, double cl, double cu, int &change);
 
 
 
  void get_other_linear_var_bounds(VariablePtr v, double *lflb, double *lfub, 
                                            VariableSet linear_tSerms, LinearFunctionPtr lf);
 
 
 
  void quad_var_bound(VarBoundModVector qfmod, LinearFunctionPtr lf, QuadraticFunctionPtr qf, 
                                  VariableSet qfvars,  VariableSet linear_terms, double cl, double cu,
                                  int &change);
 
 
 
 
  void get_other_quad_var_bounds(VariablePtr v, double *qflb, double *qfub, VariableSet qfvars, 
                                        QuadraticFunctionPtr qf, LinearFunctionPtr lf);
 
  void bilinear_bounds(VariablePtr v, double *qflb1, double *qfub1, VariableSet qfvars,
                                        QuadraticFunctionPtr qf);
 
 
 
  void quad_bound(VariablePtr v, double a,double b, double *l,
                                     double *u);
 
 
  void quad_bound_range(VariablePtr v, double a,double blb, double bub, double *l,
                                     double *u);
 
 
 
 
 
private:
  bool doPersp_;
 
  bool doQuadCone_;
 
  EnvPtr env_;
 
  double eTol_;
 
  LoggerPtr logger_;
 
  ProblemPtr p_;
 
  NlPresStats stats_;
 
  double zTol_;
 
  static const std::string me_;
 
  void bin2Lin_(ProblemPtr p, PreModQ *mods, bool *changed);
  void bin2LinF_(ProblemPtr p, LinearFunctionPtr lf,
                 UInt nz, const UInt *irow, const UInt *jcol,
                 const double *values, PreAuxVarsPtr mods);
 
  bool canBin2Lin_(ProblemPtr p, UInt nz, const UInt *irow,
                   const UInt *jcol, const double *values);
  void chkRed_(ProblemPtr p, bool apply_to_prob, bool *changed,
               ModQ *mods, SolveStatus &status);
  void  coeffImpr_(bool *changed);
  void  computeImpBounds_(ConstraintPtr c, VariablePtr z, 
                          double zval, double *lb, double *ub);
 
  void copyBndsFromRel_(RelaxationPtr rel, ModVector &p_mods);
 
  void fixedNl_(ProblemPtr p, bool purge_cons, bool *changed,
                ModQ *, SolveStatus &status);
  void fixObjBins_(ProblemPtr p, double ub, bool *changed, ModQ *mods,
                   SolveStatus &status);
 
  void perspMod_(ConstraintPtr c, VariablePtr z);
  void perspRef_(ProblemPtr p, PreModQ *mods, bool *changed);
  void quadConeRef_(ProblemPtr p, PreModQ *mods, bool *changed);
  void varBndsFromCons_(ProblemPtr p, bool apply_to_prob, bool *changed,
                        ModQ* mods, SolveStatus &status);
};
typedef NlPresHandler* NlPresHandlerPtr;
}
#endif