#include <nodes.h>

Inheritance diagram for math::TNode< class >:

Public Types
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 }

typedef TNodeIterator< T >	iterator

typedef const TNodeIterator< T >	const_iterator

typedef TOperandIter< TNode< T > >	operand_iterator

typedef TOperandIter< const TNode< T > >	const_operand_iterator

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<class>
class math::TNode< class >

TNode<T> represents the abstract node base.

Definition at line 34 of file library.h.

Member Enumeration Documentation

template<class >

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.

                    {
         // take care, the order below is hard coded
 
         NUMBER_NODE,    // numbers: 0, 3.1415, 2.17, 0.815, ... (prio: 0)
         SYMBOL_NODE,    // any symbol value: pi, e, ...         (prio: 0)
         PARAM_NODE,     // the function parameter... (e.g. x)   (prio: 0)
 
         PLUS_NODE,      // x + y                    (prio: -5)
         NEG_NODE,       // -x                       (prio: -5)
 
         MUL_NODE,       // x * y                    (prio: -3)
         DIV_NODE,       // x / y                    (prio: -3)
         MOD_NODE,       // x mod y                  (prio: -3)
 
         POW_NODE,       // x ^ y                    (prio: -1)
 
         EQU_NODE,       // x == y                   (prio: -10)
         UNEQU_NODE,     // x != y                   (prio: -10)
         LESS_EQU_NODE,  // x <= y                   (prio: -10)
         GREATER_EQU_NODE,// x >= y                  (prio: -10)
         LESS_NODE,      // x < y                    (prio: -10)
         GREATER_NODE,   // x > y                    (prio: -10)
 
         FUNC_NODE,      // userfunc(x)              (prio: -1)
 
         SQRT_NODE,      // sqrt(x); x ^ 0.5         (prio: -1)
         SIN_NODE,       // sin(x)                   (prio: -1)
         COS_NODE,       // cos(x)                   (prio: -1)
         TAN_NODE,       // tan(x)                   (prio: -1)
         LN_NODE,        // logn(x)                  (prio: -1)
 
         IF_NODE         // IF(cond, then, else)     (prio: -1)
     };

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Protected Member Functions

Friends

Detailed Description

template<class> class math::TNode< class >

Member Enumeration Documentation

template<class>
class math::TNode< class >