CNode.h

Go to the documentation of this file.

//
//    Minotaur -- It's only 1/2 bull
//
//    (C)opyright 2008 - 2025 The Minotaur Team.
//
 
 
#ifndef MINOTAURCNODE_H
#define MINOTAURCNODE_H
 
#include "OpCode.h"
#include "Types.h"
 
namespace Minotaur {
 
  class CNode;
 
  struct CompareCNodes
  {
    bool operator()(const CNode *n1, const CNode *n2) const;
  };
  struct CompareCNodesR
  {
    bool operator()(const CNode *n1, const CNode *n2) const;
  };
  typedef std::set<CNode *, CompareCNodes> CNodeSet;
  typedef std::set<CNode *, CompareCNodesR> CNodeRSet;
 
  class CQIter2 {
  public:
    CNode *node;
    CQIter2 *next;
    CQIter2 *prev;
  };
 
  class CNode {
  public:
    CNode();
 
    CNode(OpCode op, CNode **children, size_t num_child);
 
    CNode(OpCode op, CNode *lchild, CNode *rchild);
 
    ~CNode();
 
    CNode *clone() const;
 
    void addPar(CNode *node);
 
    void changeChild(CNode *out, CNode *in);
 
    void copyParChild(CNode *out,
                      std::map<const CNode *, CNode *> *nmap) const;
 
    void eval(const double *x, int *error);
 
    double evalSingle(double x, int *error) const;
 
    FunctionType findFType();
 
    void fwdGrad();
 
    bool getB() const { return b_; };
 
    double getG() const { return g_; };
 
    double getH() const { return h_; };
 
    size_t getId() const { return id_; };
 
    size_t getIndex() const { return index_; };
 
    CNode *getL() const { return l_; };
 
    double getLb() const { return lb_; };
 
    CNode **getListL() const { return child_; };
 
    CNode **getListR() const { return child_ + numChild_; };
 
    OpCode getOp() const { return op_; };
    CQIter2 *getParB() const { return parB_; };
 
    CNode *getR() const { return r_; };
    int getTempI() const { return ti_; };
 
    FunctionType getType() const { return fType_; };
 
    double getUb() const { return ub_; };
 
    CNode *getUPar() const { return uPar_; };
 
    const Variable *getV() const { return v_; };
 
    double getVal() const { return val_; };
 
    void grad(int *error);
 
    size_t numChild() const { return numChild_; };
 
    size_t numPar() const { return numPar_; };
 
    void propHessSpa();
 
    void propHessSpa2(CNodeRSet *nset);
 
    void propBounds(bool *is_inf, int *error);
 
    void hess(int *error);
 
    void hess2(CNodeRSet *nset, int *error);
 
    void setB(bool b) { b_ = b; };
 
    void setBounds(double lb, double ub)
    {
      lb_ = lb;
      ub_ = ub;
    };
 
    void setDouble(double d) { d_ = d; };
 
    void setG(double g) { g_ = g; };
 
    void setGi(double gi) { gi_ = gi; };
 
    void setH(double h) { h_ = h; };
 
    void setId(size_t i) { id_ = i; };
 
    void setIndex(size_t i) { index_ = i; };
 
 
    void setL(CNode *n) { l_ = n; };
 
    void setOp(OpCode op) { op_ = op; };
 
    void setR(CNode *n) { r_ = n; };
 
    void setTempI(int i) { ti_ = i; };
 
    void setType(FunctionType t);
 
    void setVal(double v);
 
    void setV(VariablePtr v)
    {
      v_ = v;
    };  // Changed (showing error while compiling)
 
    void updateBnd(int *error);
 
    void write(std::ostream &out) const;
 
    void writeSubExp(std::ostream &out) const;
 
    void writeSubNl(std::stringstream &s, int *err) const;
 
  protected:
    bool b_;  
    CNode *
        *child_;  
    double d_;    
    FunctionType fType_;  
    double g_;   
    double gi_;  
    double h_;   
    size_t id_;  
    size_t index_;     
    CNode *l_;         
    double lb_;        
    size_t numChild_;  
    size_t numPar_;    
    OpCode op_;        
    CQIter2 *parB_;    
    CQIter2 *parE_;    
    CNode *r_;         
    int ti_;           
    double ub_;        
 
 
    CNode *uPar_;        
    const Variable *v_;  
    double val_;  
 
    void propBounds_(double lb, double ub, bool *is_inf);
  };
  typedef std::vector<CNode *> CNodeVector;
}  //namespace Minotaur
 
 
#endif