Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | Related Pages

math::TNode< T > Class Template Reference

#include <nodes.h>

Inheritance diagram for math::TNode< T >:

math::TBinaryNodeOp< T > math::TNumberNode< T > math::TParamNode< T > math::TSymbolNode< T > math::TUnaryNodeOp< T > math::TDivNode< T > math::TEquNode< T > math::TIfNode< T > math::TMulNode< T > math::TPlusNode< T > math::TPowNode< T > math::TCosNode< T > math::TFuncNode< T > math::TLnNode< T > math::TNegNode< T > math::TSinNode< T > math::TSqrtNode< T > math::TTanNode< T > List of all members.

Public Types

typedef TNodeIterator< T > iterator
typedef const TNodeIterator<
T > 
const_iterator
typedef TOperandIter< TNode<
T > > 
operand_iterator
typedef TOperandIter< const
TNode< T > > 
const_operand_iterator
enum  TNodeType {
  NUMBER_NODE, SYMBOL_NODE, PARAM_NODE, PLUS_NODE,
  NEG_NODE, MUL_NODE, DIV_NODE, MOD_NODE,
  POW_NODE, EQU_NODE, UNEQU_NODE, LESS_EQU_NODE,
  GREATER_EQU_NODE, LESS_NODE, GREATER_NODE, FUNC_NODE,
  SQRT_NODE, SIN_NODE, COS_NODE, TAN_NODE,
  LN_NODE, IF_NODE
}

Public Member Functions

virtual ~TNode ()
 each virtual class needs a virtual destructor (this one does nothing)
TNodeType nodeType () const
 returns the type of this node
short priority () const
 returns the node priority
TNode< T > * parent () const
 returns the parent node (returns 0 if this node is the root node)
virtual TNode< T > * left () const
 returns the left child node (returns 0 if this node doesn't support one)
virtual TNode< T > * right () const
 returns the right child node (returns 0 if this node doesn't support one)
virtual void accept (TNodeVisitor< T > &)=0
 calls the visit method in TNodeVisitor<>
virtual TNode< T > * clone () const =0
 clones that node
iterator begin ()
 iterator access to the first value node in this operator level
iterator end ()
 iterator access to the end
virtual bool equals (const TNode< T > *ANode) const =0
 returns true, if given node equals to this one

Protected Member Functions

 TNode (TNodeType ANodeType, short APriority, TNode< T > *AParentNode=0)
 initializes this node for given node type.
 TNode (const TNode< T > &n)
void parent (TNode< T > *AParent)
 initializes the parent node with the given one

Friends

class TUnaryNodeOp< T >
class TBinaryNodeOp< T >

Detailed Description

template<typename T>
class math::TNode< T >

TNode<T> represents the abstract node base.

Definition at line 228 of file nodes.h.


Member Enumeration Documentation

template<typename T>
enum math::TNode::TNodeType
 

This enumeration, TNodeType, is implemented for node type access. This makes it also faster because it replaces the dynamic_cast<> operator.

Definition at line 240 of file nodes.h.

00240                    {
00241         // take care, the order below is hard coded
00242 
00243         NUMBER_NODE,    // numbers: 0, 3.1415, 2.17, 0.815, ... (prio: 0)
00244         SYMBOL_NODE,    // any symbol value: pi, e, ...         (prio: 0)
00245         PARAM_NODE,     // the function parameter... (e.g. x)   (prio: 0)
00246 
00247         PLUS_NODE,      // x + y                    (prio: -5)
00248         NEG_NODE,       // -x                       (prio: -5)
00249 
00250         MUL_NODE,       // x * y                    (prio: -3)
00251         DIV_NODE,       // x / y                    (prio: -3)
00252         MOD_NODE,       // x mod y                  (prio: -3)
00253 
00254         POW_NODE,       // x ^ y                    (prio: -1)
00255 
00256         EQU_NODE,       // x == y                   (prio: -10)
00257         UNEQU_NODE,     // x != y                   (prio: -10)
00258         LESS_EQU_NODE,  // x <= y                   (prio: -10)
00259         GREATER_EQU_NODE,// x >= y                  (prio: -10)
00260         LESS_NODE,      // x < y                    (prio: -10)
00261         GREATER_NODE,   // x > y                    (prio: -10)
00262 
00263         FUNC_NODE,      // userfunc(x)              (prio: -1)
00264 
00265         SQRT_NODE,      // sqrt(x); x ^ 0.5         (prio: -1)
00266         SIN_NODE,       // sin(x)                   (prio: -1)
00267         COS_NODE,       // cos(x)                   (prio: -1)
00268         TAN_NODE,       // tan(x)                   (prio: -1)
00269         LN_NODE,        // logn(x)                  (prio: -1)
00270 
00271         IF_NODE         // IF(cond, then, else)     (prio: -1)
00272     };


The documentation for this class was generated from the following file:
Generated on Thu Sep 30 21:40:03 2004 for MathTypeLibrary(libmath++) by  doxygen 1.3.8-20040913