Node.h

Go to the documentation of this file.

//
//     Minotaur -- It's only 1/2 bull
//
//     (C)opyright 2008 - 2025 The Minotaur Team.
//
 
#ifndef MINOTAURNODE_H
#define MINOTAURNODE_H
 
#include "Types.h"
 
namespace Minotaur {
 
  class Node;
  class Relaxation;
  class WarmStart;
  typedef const Node *ConstNodePtr;
  typedef Relaxation *RelaxationPtr;
  typedef WarmStart *WarmStartPtr;
 
  class Node {
 
  public:
    Node();
 
    Node(NodePtr parentNode, BranchPtr branch);
 
    virtual ~Node();
 
    void addChild(NodePtr childNode);
 
    void addCutToPool(CutPtr cut, RelaxationPtr rel);
 
    void addPMod(ModificationPtr m) { pMods_.push_back(m); }
 
    void addRMod(ModificationPtr m) { rMods_.push_back(m); }
 
    void applyCutsByIndex(RelaxationPtr rel);
 
    void applyPMods(ProblemPtr p);
 
    void applyRMods(RelaxationPtr rel);
 
    void applyRModsTrans(RelaxationPtr rel);
 
    void applyMods(RelaxationPtr rel, ProblemPtr p);
 
    NodePtrIterator childrenBegin() { return children_.begin(); }
 
    NodePtrIterator childrenEnd() { return children_.end(); }
 
    BranchPtr getBranch() const { return branch_; }
 
    CutList getCutPool() { return cutPool_; }
 
    UInt getDepth() const { return depth_; }
 
    UInt getId() const { return id_; }
 
    UIntVector getLastStrongBranched() { return lastStrBranched_; }
 
    double getLb() const { return lb_; }
 
    size_t getNumChildren() { return children_.size(); }
 
    NodePtr getParent() const { return parent_; }
 
    //DoubleVector getPCDown() const { return pseudoDown_; }
    DoubleVector getPCDown() { return pseudoDown_; }
 
    UIntVector getBrCands() const { return brCands_; }
 
    DoubleVector getPCUp() const { return pseudoUp_; }
 
    NodeStatus getStatus() const { return status_; }
 
    double getTbScore() const { return tbScore_; }
 
    double setVioVal(double v) { return vioVal_ = v; }
 
    double getVioVal() { return vioVal_; }
 
    UIntVector getTimesDown() const { return timesDown_; }
 
    UIntVector getTimesUp() const { return timesUp_; }
 
    WarmStartPtr getWarmStart() { return ws_; }
 
    void makeChildOf(const Node *parent);
 
    ModificationConstIterator modsBegin() const { return pMods_.begin(); }
    ModificationConstIterator modsrBegin() const { return rMods_.begin(); }
 
    ModificationConstIterator modsEnd() const { return pMods_.end(); }
    ModificationConstIterator modsrEnd() const { return rMods_.end(); }
 
    ModificationRConstIterator modsRBegin() const { return pMods_.rbegin(); }
 
    ModificationRConstIterator modsREnd() const { return pMods_.rend(); }
 
    void removeChild(NodePtrIterator childNodeIter);
 
    void removeChildren();
 
    void removeParent();
 
    void removeWarmStart();
 
    void setBrCands(UIntVector brCands) { brCands_ = brCands; }
 
    void setDepth(UInt depth);
 
    void setId(UInt id);
 
    void setLastStrongBranched(UIntVector lstStrnBrnchd)
    {
      lastStrBranched_ = lstStrnBrnchd;
    }
 
    void setLb(double value);
 
    void setPCDown(DoubleVector pcDown) { pseudoDown_ = pcDown; }
 
    void setPCUp(DoubleVector pcUp) { pseudoUp_ = pcUp; }
 
    void setStatus(NodeStatus status) { status_ = status; }
 
    void setTbScore(double d) { tbScore_ = d; }
 
    void setTimesDown(UIntVector timesDown) { timesDown_ = timesDown; }
 
    void setTimesUp(UIntVector timesUp) { timesUp_ = timesUp; }
 
    void setWarmStart(WarmStartPtr ws);
 
    void undoPMods(ProblemPtr p);
 
    void undoRMods(RelaxationPtr r);
 
    void undoRModsTrans(RelaxationPtr r);
 
    void undoMods(RelaxationPtr rel, ProblemPtr p);
 
    void updateBrCands(UInt index);
 
    void updateLastStrBranched(UInt index, double value);
 
    void updatePCDown(UInt index, double value);
 
    void updatePCUp(UInt index, double value);
 
    void updateTimesDown(UInt index, double value);
 
    void updateTimesUp(UInt index, double value);
 
    void write(std::ostream &o) const;
 
  private:
    BranchPtr branch_;
 
    NodePtrVector children_;
 
    UInt depth_;
 
    UInt id_;
 
    UIntVector lastStrBranched_;
 
    double lb_;
 
    std::vector<ModificationPtr> pMods_;
 
    std::vector<ModificationPtr> rMods_;
 
    NodePtr parent_;
 
    UIntVector brCands_;
 
    DoubleVector pseudoDown_;
 
    DoubleVector pseudoUp_;
 
    NodeStatus status_;
 
    double vioVal_;
 
    double tbScore_;
 
    CutList cutPool_;
 
    UIntVector timesDown_;
 
    UIntVector timesUp_;
 
    WarmStartPtr ws_;
 
    Node(const Node &node);
 
    Node(NodePtr node);
  };
 
 
}  //namespace Minotaur
#endif