math::TNode< class > Class Template Referenceabstract

`#include <nodes.h>`

Inheritance diagram for math::TNode< class >:
[legend]

## 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:

- library.h
- nodes.h