CutMan2.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2010 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURCUTMAN2_H
#define MINOTAURCUTMAN2_H
 
#include <list>
#include <map>
#include "CutManager.h"
#include "Types.h"
 
namespace Minotaur {
 
  class Constraint;
 
  class Node;
  class Timer;
  typedef Constraint *ConstraintPtr;  //changed from boost-> simple
  typedef std::list<CutPtr> cutList;
 
  struct CutStat
  {
    int numAddedCuts;
    int numDeletedCuts;
    int numPoolToRel;
    int numRelToPool;
    int callNums;
    int PoolSize;
    int RelSize;
    int numCuts;
  };
 
  class CutMan2 : public CutManager {
 
  public:
    CutMan2();
 
    CutMan2(EnvPtr env, ProblemPtr p);
 
    ~CutMan2();
 
    // base class method
    void addCut(CutPtr c);
 
    // base class method
    void addCuts(CutVectorIter cbeg, CutVectorIter cend);
 
    size_t getNumCuts() const { return numCuts_; };
 
    size_t getNumEnabledCuts() const { return rel_.size(); };
 
    size_t getNumDisabledCuts() const { return pool_.size(); };
 
    size_t getNumNewCuts() const { return 0; };
 
    // base class method
    ConstraintPtr addCut(ProblemPtr rel, FunctionPtr fn, double lb, double ub,
                         bool directToRel, bool neverDelete);
 
    // base class method
    void NodeIsBranched(NodePtr node, ConstSolutionPtr sol, int num);
 
    // base class method
    void NodeIsProcessed(NodePtr node);
 
    // base class method
    void postSolveUpdate(ConstSolutionPtr, EngineStatus){};
 
    // base class method
    void separate(ProblemPtr, ConstSolutionPtr, bool *, size_t *) {};
 
    // base class method
    void updatePool(ProblemPtr rel, ConstSolutionPtr sol);
 
    // base class method
    void updateRel(ConstSolutionPtr sol, ProblemPtr rel);
 
    // base class method
    void write(std::ostream &out) const;
 
    // base class method
    void writeStats(std::ostream &out) const;
 
    void writeStat();
 
    struct ctMngrInfo
    {
      double t;
      int RelSize;
      int PoolSize;
      int RelToPool;
      int PoolToRel;
      double RelAve;
      double PoolAve;
      int RelTr;
      int PoolTr;
      int PrntActCnt;
    };
 
    ctMngrInfo getInfo() { return ctmngrInfo_; }
 
  private:
    cutList pool_;
 
    cutList rel_;
 
    std::map<NodePtr, cutList> NodeCutsMap_;
 
    std::map<NodePtr, int> ChildNum_;
 
    EnvPtr env_;
 
    double *hashVec_;
 
    LoggerPtr logger_;
 
    const static std::string me_;
 
    ProblemPtr p_;
 
    void addToRel_(ProblemPtr rel, CutPtr cut, bool newcut);
 
    void addToRel_(CutPtr cut);
 
    void addToPool_(CutPtr cut);
 
    double absTol_;
 
    size_t MaxInactiveInRel_;
 
    size_t PoolSize_;
 
    size_t CtThrsh_;
 
    CutStat *stats_;
 
    Timer *timer_;
 
    double ctMngrtime_;
 
    double updateTime_;
 
    double checkTime_;
 
    double processedTime_;
 
    double branchedTime_;
 
    ctMngrInfo ctmngrInfo_;
 
    int PrntCntThrsh_;
 
    size_t numCuts_;
  };
  typedef CutMan2 *CutMan2Ptr;
}  //namespace Minotaur
#endif