LogHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2010 - 2025 The Minotaur Team.
//
 
//y=log(x) and log constraint have same meaning
#ifndef MINOTAURLOGHANDLER_H
#define MINOTAURLOGHANDLER_H
 
#include "Handler.h"
#include "Types.h"
namespace Minotaur {
 
  class Engine;
  class Function;
  class LinearFunction;
  class Objective;
  class Problem;
  typedef LinearFunction *LinearFunctionPtr;
  typedef Objective *ObjectivePtr;
 
 
  class LogHandler : public Handler {
 
  public:
    // Constructor
    LogHandler(EnvPtr env, ProblemPtr problem);
    LogHandler(EnvPtr env, ProblemPtr problem, ProblemPtr orig_);
    // Destructor
    ~LogHandler();
 
    void addConstraint(ConstraintPtr newcon, ConstVariablePtr ivar,
                       ConstVariablePtr ovar, char sense = 'E');
 
    // base class method—not used here
    void addConstraint(ConstraintPtr) { assert(0); }
 
   
    // Full relaxation (unused)
    void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) {}
 
    // Create initial relaxation at root and then updation
    void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *is_inf);
 
    //Base Class method
    bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation,
                    bool &should_prune, double &inf_meas);
 
    // Separation (cuts) -cutmanager not implemented
    void separate(ConstSolutionPtr sol, NodePtr node, RelaxationPtr rel,
                  CutManager *cutman, SolutionPoolPtr s_pool,
                  ModVector &p_mods, ModVector &r_mods, bool *sol_found,
                  SeparationStatus *status);
 
    // Full relaxation at a node (unused for LogHandler)
    void relaxNodeFull(NodePtr, RelaxationPtr, bool *) {}
 
    // Incremental relaxation at a node.
    void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *isInfeasible);
 
    // Branching candidates.
    void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x,
                                ModVector &mods, BrVarCandSet &cands,
                                BrCandVector &gencands, bool &is_inf);
 
    // Branch modification for a variable.
    ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x,
                             RelaxationPtr rel, BranchDirection dir);
 
    // Generate branches.
    Branches getBranches(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel,
                         SolutionPoolPtr s_pool);
 
    // Top-level presolve.
    SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol);
 
    // Node-level presolve.
    bool presolveNode(RelaxationPtr p, NodePtr node, SolutionPoolPtr s_pool,
                      ModVector &p_mods, ModVector &r_mods);
 
    // Name of the handler.
    std::string getName() const override;
 
    // Stats
    void writeStats(std::ostream &out) const override;
  
 
 
 
  private:
 
    // Per-constraint data for log constraints 
    struct LogCons
    {
      ConstraintPtr con;         
      ConstVariablePtr iv;       
      ConstVariablePtr ov;       
      VariablePtr riv;           
      VariablePtr rov;           
      char sense;                
      ConstraintPtr secCon;      
      ConstraintVector linCons;  
 
      LogCons(ConstraintPtr newcon, ConstVariablePtr ivar,
              ConstVariablePtr ovar, char s)
        : con(newcon),
          iv(ivar),
          ov(ovar),
          riv(0),
          rov(0),
          sense(s),
          secCon(0),
          linCons()
      {
      }
    };
 
    typedef LogCons *LogConsPtr;
    typedef std::vector<LogConsPtr> LogConsVec;
    typedef LogConsVec::iterator LogConsIter;
 
    // All log constraints data
    LogConsVec consd_;
 
    // For printing
    static const std::string me_;
 
    //Stats to store separation data
 struct SepaStats {
    int iters;       
    int tangentcuts; 
    int optcuts;     
    int optrem;      
    double time;     
  };
 
    // Presolve statistics container
      struct LogPresolveStats
    {
      UInt iters;
      double time;
      UInt conDel;
      UInt vBnd;
      UInt nMods;
 
      LogPresolveStats()
        : iters(0),
          time(0.0),
          conDel(0),
          vBnd(0),
          nMods(0)
      {
      }
    };
 
    struct BoundTighteningStats
    {
      int niters;
      int nLP;
      int dlb;
      int dub;
      double timeLP;
    };
 
    BoundTighteningStats bStats_;
    LogPresolveStats pStats_;
    SepaStats sStats_;
    // Default bounds for presolve
    double LBd_;
    double UBd_;
 
    double bTol_;  
 
    // Environment
    EnvPtr env_;
 
    //Problem pointer to the original problem
    ProblemPtr orig_;
 
 // Optional cuts
    ConstraintVector optCuts_;
 
 
    // Absolute feasibility tolerance
    double aTol_;
 
    // Relative feasibility tolerance
    double rTol_;
 
    // Tolerances for log constraints
    double eTol_;
 
    // Tolerance for when lower and upper bounds are considered equal
    double vTol_;
    // Problem pointer to the transformed problem
    ProblemPtr p_;
 
        // Logger
    LoggerPtr log_;
 
    // Temporary vectors for evaluations
    DoubleVector tmpX_;
    DoubleVector grad_;
 
    
    //separating 
    void addCut_(VariablePtr x, VariablePtr y, double xval, double yval, 
                         RelaxationPtr rel, bool& ifcuts); 
 
 
    //add default bounds for x in y=log(x) if no finite bound was added by presolve
    double addDefaultLogBounds_(VariablePtr x, BoundType lu);
 
    void addLin_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
                 DoubleVector &grad, ModVector &mods, bool init);
 
 
    void addSecant_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
                    ModVector &mods, bool init);
 
    //Marks duplicate constraint if changed == True
    void dupRows_(bool *changed);
    //branching decision
    BranchPtr doBranch_(BranchDirection UpOrDown, ConstVariablePtr v,
                        double bvalue);
 
    LinearFunctionPtr getLogSec_(VariablePtr x, VariablePtr y, double lb,
                                 double ub, double &rhs);
 
    //returns the violation for functon y=log(x) and takes  input solution vector 
    double getViol_(const LogCons &cd, const DoubleVector &x) const;
 
 
 // Check feasibility.
    bool isFeasible_(ConstSolutionPtr sol, RelaxationPtr relaxation,
                    bool &should_prune, double &inf_meas);
 
 
 
 
    void initRelax_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
                    DoubleVector &grad);
 
 
    // For a given y = log(x) constraint,
    // derive bounds on y from bounds on x. Also derive bounds on x from bounds
    // on y.
    bool propLogBnds_(LogConsPtr lcd, bool *changed);
 
    //Deletes duplicate row which was marked by dupRows
    bool treatDupRows_(ConstraintPtr c1, ConstraintPtr c2, double mult,
                       bool *changed);
 
  
 
    void updateRelax_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
                      DoubleVector &grad, ModVector &mods);
 
    int updatePBnds_(VariablePtr p, double newlb, double newub,
                     bool *changed);
 
    int updatePBnds_(VariablePtr v, double newlb, double newub,
                             RelaxationPtr rel, bool mod_rel, bool *changed,
                             ModVector &p_mods, ModVector &r_mods);
 
 
    bool varBndsFromCons_(bool *changed);
 
 
     };
 
}  // namespace Minotaur
 
#endif  // MINOTAURLOGHANDLER_H