LogHandler.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2010 - 2025 The Minotaur Team.
//
 
#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 {
 
 
  private:
    // ---------------------------------------------------------
    // Per-constraint data for log constraints (data only)
    // ---------------------------------------------------------
    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;
 
    LogConsVec consd_;
 
    static const std::string me_;
 
    // ---------------------------------------------------------
    // Presolve statistics containers
    // ---------------------------------------------------------
    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_;
 
    double LBd_;
    double UBd_;
    double bTol_;  
 
    EnvPtr env_;
 
    ProblemPtr orig_;
 
    ConstraintVector optCuts_;
 
    // ---------------------------------------------------------
    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);
 
 
    double getViol_(const LogCons &cd, const DoubleVector &x) const;
 
    void initRelax_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
                    DoubleVector &grad);
 
 
    // adding bounds on the added variable
    bool propLogBnds_(LogConsPtr lcd, bool *changed);
    //Deletes duplicate row which was marked by dupRows
    bool treatDupRows_(ConstraintPtr c1, ConstraintPtr c2, double mult,
                       bool *changed);
 
    //multiple times bound tightening
    bool tightenSimple_(bool *changed);
 
    void updateRelax_(LogCons &cd, RelaxationPtr rel, DoubleVector &tmpX,
                      DoubleVector &grad, ModVector &mods);
 
 
    int updatePBnds_(VariablePtr p, double newlb, double newub,
                     bool *changed);
    bool varBndsFromCons_(bool *changed);
 
 
  public:
    double aTol_;
 
    double rTol_;
 
    double eTol_;
    double vTol_;
 
    ProblemPtr p_;
 
    LoggerPtr log_;
 
    DoubleVector tmpX_;
    DoubleVector grad_;
 
    LogHandler(EnvPtr env, ProblemPtr problem);
 
    ~LogHandler();
 
    void addConstraint(ConstraintPtr newcon, ConstVariablePtr ivar,
                       ConstVariablePtr ovar, char sense = 'E');
 
    // base class method—not used here
    void addConstraint(ConstraintPtr) { assert(0); }
 
 
    BranchPtr doBranch_(BranchDirection UpOrDown, ConstVariablePtr v,
                        double bvalue);
 
 
    void relaxInitFull(RelaxationPtr, SolutionPool *, bool *) {}
 
    void relaxInitInc(RelaxationPtr rel, SolutionPool *, bool *is_inf);
 
    bool isFeasible(ConstSolutionPtr sol, RelaxationPtr relaxation,
                    bool &should_prune, double &inf_meas);
 
    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 relaxNodeFull(NodePtr, RelaxationPtr, bool *) {}
 
    void relaxNodeInc(NodePtr node, RelaxationPtr rel, bool *isInfeasible);
 
    void getBranchingCandidates(RelaxationPtr rel, const DoubleVector &x,
                                ModVector &mods, BrVarCandSet &cands,
                                BrCandVector &gencands, bool &is_inf);
 
    ModificationPtr getBrMod(BrCandPtr cand, DoubleVector &x,
                             RelaxationPtr rel, BranchDirection dir);
 
    Branches getBranches(BrCandPtr cand, DoubleVector &x, RelaxationPtr rel,
                         SolutionPoolPtr s_pool);
 
    SolveStatus presolve(PreModQ *pre_mods, bool *changed, Solution **sol);
 
    bool presolveNode(RelaxationPtr p, NodePtr node, SolutionPoolPtr s_pool,
                      ModVector &p_mods, ModVector &r_mods);
 
    std::string getName() const override;
 
    void writeStats(std::ostream &out) const override;
  };
 
}  // namespace Minotaur
 
#endif  // MINOTAURLOGHANDLER_H