math::TNode< class > Class Template Reference

#include <nodes.h>

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 32 of file utils.h.

Member Typedef Documentation

const_iterator

template<class >

const TNodeIterator<T> math::TNode< class >::const_iterator

Definition at line 231 of file nodes.h.

const_operand_iterator

template<class >

TOperandIter<const TNode<T> > math::TNode< class >::const_operand_iterator

Definition at line 234 of file nodes.h.

iterator

template<class >

TNodeIterator<T> math::TNode< class >::iterator

Definition at line 230 of file nodes.h.

operand_iterator

template<class >

TOperandIter<TNode<T> > math::TNode< class >::operand_iterator

Definition at line 233 of file nodes.h.

Member Enumeration Documentation

TNodeType

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)
    };

Member Function Documentation

accept()

template<class >

virtual void math::TNode< class >::accept ( TNodeVisitor< T > & )

pure virtual

calls the visit method in TNodeVisitor<>

Implemented in math::TCosNode< class >, math::TDivNode< class >, math::TEquNode< class >, math::TFuncNode< class >, math::TGreaterEquNode< class >, math::TGreaterNode< class >, math::TIfNode< class >, math::TLessEquNode< class >, math::TLessNode< class >, math::TLnNode< class >, math::TMulNode< class >, math::TNegNode< class >, math::TNumberNode< class >, math::TParamNode< class >, math::TPlusNode< class >, math::TPowNode< class >, math::TSinNode< class >, math::TSqrtNode< class >, math::TSymbolNode< class >, math::TTanNode< class >, and math::TUnEquNode< class >.

begin()

template<class >

iterator math::TNode< class >::begin ( )

inline

iterator access to the first value node in this operator level

Definition at line 319 of file nodes.h.

{ return iterator(this).rewind(); }

clone()

template<class >

virtual TNode< T > * math::TNode< class >::clone ( ) const

pure virtual

clones that node

Implemented in math::TCosNode< class >, math::TDivNode< class >, math::TEquNode< class >, math::TFuncNode< class >, math::TGreaterEquNode< class >, math::TGreaterNode< class >, math::TIfNode< class >, math::TLessEquNode< class >, math::TLessNode< class >, math::TLnNode< class >, math::TMulNode< class >, math::TNegNode< class >, math::TNumberNode< class >, math::TParamNode< class >, math::TPlusNode< class >, math::TPowNode< class >, math::TSinNode< class >, math::TSqrtNode< class >, math::TSymbolNode< class >, math::TTanNode< class >, and math::TUnEquNode< class >.

end()

template<class >

iterator math::TNode< class >::end ( )

inline

iterator access to the end

Definition at line 322 of file nodes.h.

{ return iterator(0); }

equals()

template<class >

virtual bool math::TNode< class >::equals ( const TNode< T > * ANode ) const

pure virtual

returns true, if given node equals to this one

Implemented in math::TBinaryNodeOp< T >, math::TNumberNode< class >, math::TParamNode< class >, math::TSymbolNode< class >, and math::TUnaryNodeOp< T >.

left()

template<class >

virtual TNode< T > * math::TNode< class >::left ( ) const

virtual

returns the left child node (returns 0 if this node doesn't support one)

Reimplemented in math::TBinaryNodeOp< T >.

right()

template<class >

virtual TNode< T > * math::TNode< class >::right ( ) const

virtual

returns the right child node (returns 0 if this node doesn't support one)

Reimplemented in math::TBinaryNodeOp< T >, and math::TUnaryNodeOp< T >.

Friends And Related Symbol Documentation

TBinaryNodeOp< T >

template<class >

friend class TBinaryNodeOp< T >

friend

Definition at line 288 of file nodes.h.

TUnaryNodeOp< T >

template<class >

friend class TUnaryNodeOp< T >

friend

Definition at line 288 of file nodes.h.

---

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

• library.h
• nodes.h
• reader.h
• utils.h