CEvaluationNode Class Reference

#include <CEvaluationNode.h>

Inheritance diagram for CEvaluationNode:

Collaboration diagram for CEvaluationNode:

Classes
class	CPrecedence

Public Types
enum	Type {   INVALID = 0xFF000000, NUMBER = 0x01000000, CONSTANT = 0x02000000, OPERATOR = 0x03000000,   OBJECT = 0x04000000, FUNCTION = 0x05000000, CALL = 0x06000000, STRUCTURE = 0x07000000,   CHOICE = 0x08000000, VARIABLE = 0x09000000, WHITESPACE = 0x0a000000, LOGICAL = 0x0b000000,   MV_FUNCTION = 0x0c000000, VECTOR = 0x0d000000, DELAY = 0x0e000000 }
Public Types inherited from CCopasiNode< std::string >
typedef std::string	Data

Public Member Functions
void	addChildren (const std::vector< CEvaluationNode * > &children)
std::string	buildBerkeleyMadonnaString () const
std::string	buildCCodeString () const
std::string	buildDisplayString () const
std::string	buildInfix () const
std::string	buildMMLString (bool expand, const std::vector< std::vector< std::string > > &variables) const
std::string	buildXPPString () const
virtual void	calculate ()
	CEvaluationNode ()
	CEvaluationNode (const CEvaluationNode &src)
virtual bool	compile (const CEvaluationTree *pTree)
CEvaluationNode *	copyBranch () const
CEvaluationNode *	copyNode (CEvaluationNode *child1, CEvaluationNode *child2) const
CEvaluationNode *	copyNode (const std::vector< CEvaluationNode * > &children) const
const CEvaluationNode *	findTopMinus (const std::vector< CFunctionAnalyzer::CValue > &callParameters) const
virtual std::string	getBerkeleyMadonnaString (const std::vector< std::string > &children) const
virtual std::string	getCCodeString (const std::vector< std::string > &children) const
virtual std::string	getDisplayString (const std::vector< std::string > &children) const
virtual std::string	getInfix (const std::vector< std::string > &children) const
virtual std::string	getMMLString (const std::vector< std::string > &children, bool expand, const std::vector< std::vector< std::string > > &variables) const
const Type &	getType () const
const C_FLOAT64 &	getValue () const
const C_FLOAT64 *	getValuePointer () const
virtual std::string	getXPPString (const std::vector< std::string > &children) const
virtual bool	isBoolean () const
virtual bool	operator!= (const CEvaluationNode &right) const
bool	operator< (const CEvaluationNode &right) const
bool	operator< (const CEvaluationNode &rhs)
bool	operator== (const CEvaluationNode &right) const
void	printRecursively (std::ostream &os, int indent=0) const
void	printRecursively () const
virtual CEvaluationNode *	simplifyNode (const std::vector< CEvaluationNode * > &children) const
CEvaluationNode *	splitBranch (const CEvaluationNode *splitnode, bool left) const
virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const
virtual	~CEvaluationNode ()
Public Member Functions inherited from CCopasiNode< std::string >
virtual bool	addChild (CCopasiNode< Data > *pChild, CCopasiNode< Data > *pAfter=NULL)
bool	addSibling (CCopasiNode< Data > *pSibling, CCopasiNode< Data > *pAfter=NULL)
	CCopasiNode (CCopasiNode< Data > *pParent=NULL)
	CCopasiNode (const CCopasiNode< Data > &src)
	CCopasiNode (const Data &data, CCopasiNode< Data > *pParent=NULL)
bool	deleteChildren ()
CCopasiNode< Data > *	getChild ()
const CCopasiNode< Data > *	getChild () const
CCopasiNode< Data > *	getChild (const size_t &index)
const CCopasiNode< Data > *	getChild (const size_t &index) const
virtual const Data &	getData () const
CCopasiNode< Data > *	getNext ()
const CCopasiNode< Data > *	getNext () const
CCopasiNode< Data > *	getNextNonChild ()
const CCopasiNode< Data > *	getNextNonChild () const
size_t	getNumChildren () const
CCopasiNode< Data > *	getParent ()
const CCopasiNode< Data > *	getParent () const
CCopasiNode< Data > *	getSibling ()
const CCopasiNode< Data > *	getSibling () const
virtual bool	removeChild (CCopasiNode< Data > *pChild)
virtual bool	setData (const Data &data)
virtual	~CCopasiNode ()

Static Public Member Functions
static CEvaluationNode *	create (const Type &type, const Data &data)
static bool	isKeyword (const std::string &str)
static Type	subType (const Type &type)
static Type	type (const Type &type)

Protected Member Functions
	CEvaluationNode (const Type &type, const Data &data)
Protected Member Functions inherited from CCopasiNode< std::string >
bool	setChild (CCopasiNode< Data > *pChild)
bool	setParent (CCopasiNode< Data > *pParent)
bool	setSibling (CCopasiNode< Data > *pSibling)

Protected Attributes
class CEvaluationNode::CPrecedence	mPrecedence
const C_FLOAT64 *	mpValue
Type	mType
C_FLOAT64	mValue
Protected Attributes inherited from CCopasiNode< std::string >
Data	mData

Static Private Attributes
static const char *	Keywords []

Detailed Description

This is the base class for nodes used in an evaluation trees

Definition at line 33 of file CEvaluationNode.h.

Member Enumeration Documentation

enum CEvaluationNode::Type

Enumeration of possible node types.

Enumerator
INVALID
NUMBER
CONSTANT
OPERATOR
OBJECT
FUNCTION
CALL
STRUCTURE
CHOICE
VARIABLE
WHITESPACE
LOGICAL
MV_FUNCTION
VECTOR
DELAY

Definition at line 39 of file CEvaluationNode.h.

  {
    INVALID = 0xFF000000,
    NUMBER = 0x01000000,
    CONSTANT = 0x02000000,
    OPERATOR = 0x03000000,
    OBJECT = 0x04000000,
    FUNCTION = 0x05000000,
    CALL = 0x06000000,
    STRUCTURE = 0x07000000,
    CHOICE = 0x08000000,
    VARIABLE = 0x09000000,
    WHITESPACE = 0x0a000000,
    LOGICAL = 0x0b000000,
    MV_FUNCTION = 0x0c000000, // This not yet implemented
    VECTOR = 0x0d000000,
    DELAY = 0x0e000000
  };

Constructor & Destructor Documentation

CEvaluationNode::CEvaluationNode

(

)

Default constructor

Definition at line 183 of file CEvaluationNode.cpp.

References mpValue, and mValue.

Referenced by create().

                                :
  CCopasiNode<Data>(""),
  mType(CEvaluationNode::INVALID),
  mValue(std::numeric_limits<C_FLOAT64>::quiet_NaN()),
  mpValue(NULL),
  mPrecedence(PRECEDENCE_DEFAULT)
{
  mpValue = & mValue;
}

CEvaluationNode::CEvaluationNode ( const Type &  type, const Data &  data  )

protected

Specific constructor

Parameters

const	Type & type
const	Data & data

Definition at line 193 of file CEvaluationNode.cpp.

References mpValue, and mValue.

                                                   :
  CCopasiNode<Data>(data),
  mType(type),
  mValue(std::numeric_limits<C_FLOAT64>::quiet_NaN()),
  mpValue(NULL),
  mPrecedence(PRECEDENCE_DEFAULT)
{
  mpValue = & mValue;
}

CEvaluationNode::CEvaluationNode

(

const CEvaluationNode &

src

)

Copy constructor

Parameters

const

CEvaluationNode & src

Definition at line 204 of file CEvaluationNode.cpp.

References mpValue, and mValue.

                                                           :
  CCopasiNode<Data>(src),
  mType(src.mType),
  mValue(src.mValue),
  mpValue(NULL),
  mPrecedence(src.mPrecedence)
{
  mpValue = & mValue;
}

CEvaluationNode::~CEvaluationNode ( )

virtual

Destructor

Definition at line 214 of file CEvaluationNode.cpp.

{}

Member Function Documentation

void CEvaluationNode::addChildren

(

const std::vector< CEvaluationNode * > &

children

)

Add the children to the node

Parameters

const

std::vector< CEvaluationNode * > & children

Definition at line 364 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::addChild().

Referenced by CEvaluationNodeCall::fromAST().

{
  std::vector< CEvaluationNode * >::const_iterator it = children.begin();
  std::vector< CEvaluationNode * >::const_iterator end = children.end();

  for (; it != end; ++it)
    {
      addChild(*it);
    }
}

std::string CEvaluationNode::buildBerkeleyMadonnaString

(

)

const

Build the Berkeley Madonna string.

Returns

std::string BerkeleyMadonnaString

Definition at line 307 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), getBerkeleyMadonnaString(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CExpression::getBerkeleyMadonnaString(), CODEExporterBM::getDisplayExpressionString(), and CODEExporterBM::getDisplayFunctionString().

{
  std::string BerkeleyMadonnaString = "";
  CNodeContextIterator< const CEvaluationNode, std::vector< std::string > > it(this);

  while (it.next() != it.end())
    {
      if (*it != NULL)
        {
          if (it.parentContextPtr() != NULL)
            {
              it.parentContextPtr()->push_back(it->getBerkeleyMadonnaString(it.context()));
            }
          else
            {
              BerkeleyMadonnaString = it->getBerkeleyMadonnaString(it.context());
            }
        }
    }

  return BerkeleyMadonnaString;
}

std::string CEvaluationNode::buildCCodeString

(

)

const

Build the C-code string.

Returns

std::string CCodeString

Build the C-code string.

Definition at line 280 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), getCCodeString(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CODEExporterC::exportSingleFunction(), CExpression::getCCodeString(), and CODEExporterC::getDisplayExpressionString().

{
  std::string CCodeString = "";
  CNodeContextIterator< const CEvaluationNode, std::vector< std::string > > it(this);

  while (it.next() != it.end())
    {
      if (*it != NULL)
        {
          if (it.parentContextPtr() != NULL)
            {
              it.parentContextPtr()->push_back(it->getCCodeString(it.context()));
            }
          else
            {
              CCodeString = it->getCCodeString(it.context());
            }
        }
    }

  return CCodeString;
}

std::string CEvaluationNode::buildDisplayString

(

)

const

Build the human readable display string.

Returns

std::string DisplayString

Definition at line 250 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), getDisplayString(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CExpression::compile().

{
  std::string DisplayString = "";
  CNodeContextIterator< const CEvaluationNode, std::vector< std::string > > it(this);

  while (it.next() != it.end())
    {
      if (*it != NULL)
        {
          if (it.parentContextPtr() != NULL)
            {
              it.parentContextPtr()->push_back(it->getDisplayString(it.context()));
            }
          else
            {
              DisplayString = it->getDisplayString(it.context());
            }
        }
    }

  return DisplayString;
}

std::string CEvaluationNode::buildInfix

(

)

const

Build the infix string.

Returns

std::string Infix

Definition at line 223 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), getInfix(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CExpression::compile(), CMathExpression::convertToInitialExpression(), createItem(), CKinFunction::createParameters(), CNormalTranslation::eliminate(), CNormalTranslation::matchPowerBases(), CNormalTranslation::matchSummands(), CNormalTranslation::normAndSimplifyReptdly(), operator<<(), CMathContainer::replaceDiscontinuousNode(), CNormalTranslation::simplify(), CEvaluationNodeOperator::simplifyNode(), CNormalTranslation::simplifyTreeReptdly(), CExpression::updateInfix(), and CEvaluationTree::updateTree().

{
  std::string Infix = "";
  CNodeContextIterator< const CEvaluationNode, std::vector< std::string > > it(this);

  while (it.next() != it.end())
    {
      if (*it != NULL)
        {
          if (it.parentContextPtr() != NULL)
            {
              it.parentContextPtr()->push_back(it->getInfix(it.context()));
            }
          else
            {
              Infix = it->getInfix(it.context());
            }
        }
    }

  return Infix;
}

std::string CEvaluationNode::buildMMLString	(	bool	expand,
		const std::vector< std::vector< std::string > > &	variables
	)		const

Build the MathML string

Parameters

bool	expand = true
const	std::vector< std::vector< std::string > > & variables

Returns

std::string MMLString

Definition at line 452 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), getMMLString(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CExpression::writeMathML(), and CFunction::writeMathML().

{
  std::string MMLString = "";
  CNodeContextIterator< const CEvaluationNode, std::vector< std::string > > it(this);

  while (it.next() != it.end())
    {
      if (*it != NULL)
        {
          if (it.parentContextPtr() != NULL)
            {
              it.parentContextPtr()->push_back(it->getMMLString(it.context(), expand, variables));
            }
          else
            {
              MMLString = it->getMMLString(it.context(), expand, variables);
            }
        }
    }

  return MMLString;
}

std::string CEvaluationNode::buildXPPString

(

)

const

Build the XPPAUT string.

Returns

std::string XPPString

Definition at line 334 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), CNodeContextIterator< Node, Context >::end(), getXPPString(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CODEExporterXPPAUT::getDisplayExpressionString(), CODEExporterXPPAUT::getDisplayFunctionString(), and CExpression::getXPPString().

{
  std::string BerkeleyMadonnaString = "";
  CNodeContextIterator< const CEvaluationNode, std::vector< std::string > > it(this);

  while (it.next() != it.end())
    {
      if (*it != NULL)
        {
          if (it.parentContextPtr() != NULL)
            {
              it.parentContextPtr()->push_back(it->getXPPString(it.context()));
            }
          else
            {
              BerkeleyMadonnaString = it->getXPPString(it.context());
            }
        }
    }

  return BerkeleyMadonnaString;
}

virtual void CEvaluationNode::calculate ( void  )

inlinevirtual

Calculate the numerical result of the node. It is assumed that all child nodes are up to date.

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeVariable, CEvaluationNodeOperator, CEvaluationNodeChoice, and CEvaluationNodeCall.

Definition at line 150 of file CEvaluationNode.h.

{};

bool CEvaluationNode::compile ( const CEvaluationTree *  pTree )

virtual

Compile a node;

Parameters

const

CEvaluationTree * pTree

Returns

bool success;

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeDelay, CEvaluationNodeOperator, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeCall, and CEvaluationNodeVariable.

Definition at line 216 of file CEvaluationNode.cpp.

Referenced by CEvaluationTree::compileNodes(), CDerive::compileTree(), convertToCEvaluationNode(), and CEvaluationNodeDelay::fromAST().

{return true;}

CEvaluationNode * CEvaluationNode::copyBranch

(

)

const

Copy the whole branch with this node as root.

Returns

CEvaluationNode*, return a pointer to the root of the newly copied branch

Definition at line 404 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, Context >::context(), copyNode(), CNodeContextIterator< Node, Context >::end(), CNodeContextIterator< Node, Context >::next(), and CNodeContextIterator< Node, Context >::parentContextPtr().

Referenced by CODEExporter::assembleSubTreeForMassAction(), CMathTrigger::compileNE(), convertToCEvaluationNode(), CMathExpression::copy(), CMathTrigger::copyBranch(), CNormalTranslation::createChain(), CFunction::createCopy(), SBMLImporter::createCReactionFromReaction(), createLogical(), createNormalRepresentation(), CNormalTranslation::createOperatorChain(), createProduct(), CDerive::deriveBranch(), SBMLImporter::divideByObject(), CNormalTranslation::elementaryEliminationDivide(), CNormalTranslation::elementaryEliminationFunction(), CNormalTranslation::elementaryEliminationMinus(), CNormalTranslation::elementaryEliminationMultiply(), CNormalTranslation::elementaryEliminationPlus(), CNormalTranslation::elementaryEliminationPower(), CNormalTranslation::eliminate(), CNormalTranslation::eliminateDirectlyNestedFractions(), CNormalTranslation::eliminateNestedPowers(), CNormalTranslation::eliminatePowersOfFractions(), expand_function_call(), CNormalTranslation::expandPowerBases(), CNormalTranslation::expandPowerNodes(), CODEExporter::exportSingleFunction(), CEvaluationNodeNormalizer::findChainNodes(), CNormalTranslation::findNegativeNumbers(), SBMLImporter::isMassActionExpression(), CNormalTranslation::matchPowerBases(), CNormalTranslation::matchSummands(), CSBMLExporter::multiplyByObject(), CNormalTranslation::newCancel(), CNormalTranslation::newEvaluateNumbers(), CEvaluationNodeNormalizer::normalize(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeChoice(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeConstant(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeDelay(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeFunction(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeLogical(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeNumber(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeObject(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeOperator(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeStructure(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeVariable(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeVector(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeWhiteSpace(), CEvaluationNodeNormalizer::normalizeDivideNode(), CEvaluationNodeNormalizer::normalizeMinusNode(), CEvaluationNodeNormalizer::normalizeModulusNode(), CEvaluationNodeNormalizer::normalizeMultiplyNode(), CEvaluationNodeNormalizer::normalizePlusNode(), CEvaluationNodeNormalizer::normalizePowerNode(), CNormalTranslation::product2fraction(), CSBMLExporter::replaceSpeciesReferences(), CReaction::setFunctionFromExpressionTree(), CNormalTranslation::simplify(), CEvaluationNodeOperator::simplifyNode(), CEvaluationNodeFunction::simplifyNode(), splitBranch(), and CNormalTranslation::splitSum().

{
  CEvaluationNode * pNode = NULL;
  CNodeContextIterator< const CEvaluationNode, std::vector< CEvaluationNode * > > itNode(this);

  while (itNode.next() != itNode.end())
    {
      if (*itNode == NULL)
        {
          continue;
        }

      if (itNode.parentContextPtr() != NULL)
        {
          itNode.parentContextPtr()->push_back(itNode->copyNode(itNode.context()));
        }
      else
        {
          assert(*itNode == this);
          pNode = itNode->copyNode(itNode.context());
        }
    }

  return pNode;
}

CEvaluationNode * CEvaluationNode::copyNode	(	CEvaluationNode *	child1,
		CEvaluationNode *	child2
	)		const

Copy a node and assign new children child1 and child2

Returns

CEvaluationNode* return a pointer to the new node

Definition at line 378 of file CEvaluationNode.cpp.

Referenced by CMathEventN::CTrigger::compile(), CMathContainer::copyBranch(), copyBranch(), CNormalTranslation::eliminateDirectlyNestedFractions(), CNormalTranslation::eliminateNestedPowers(), CNormalTranslation::eliminatePowersOfFractions(), expand_function_calls(), CNormalTranslation::expandPowerBases(), CNormalTranslation::expandPowerNodes(), CNormalTranslation::expandProducts(), CNormalTranslation::findNegativeNumbers(), CReaction::objects2variables(), CNormalTranslation::product2fraction(), replace_variable_names(), CMathContainer::replaceDiscontinuousNode(), CSBMLExporter::replaceSpeciesReferences(), CEvaluationNodeOperator::simplifyNode(), CEvaluationNodeFunction::simplifyNode(), simplifyNode(), and splitBranch().

{
  std::vector<CEvaluationNode*> children;

  if (child1 != NULL) children.push_back(child1);

  if (child2 != NULL) children.push_back(child2);

  return copyNode(children);
}

CEvaluationNode * CEvaluationNode::copyNode

(

const std::vector< CEvaluationNode * > &

children

)

const

Copy a node and assign new children in the vector

Returns

CEvaluationNode* return a pointer to the new node

Definition at line 389 of file CEvaluationNode.cpp.

References CCopasiNode< _Data >::addChild(), create(), CCopasiNode< std::string >::getData(), and mType.

{
  CEvaluationNode * pNode = create(mType, getData());
  std::vector<CEvaluationNode*>::const_iterator it = children.begin();
  std::vector<CEvaluationNode*>::const_iterator endit = children.end();

  while (it != endit)
    {
      pNode->addChild(*it);
      ++it;
    }

  return pNode;
}

CEvaluationNode * CEvaluationNode::create ( const Type &  type, const Data &  data  )

static

Creates an evaluation node of type with the given data

Parameters

const	Type & type
const	Data & data

Returns

CEvaluationNode * evaluationNode

Definition at line 37 of file CEvaluationNode.cpp.

References CALL, CEvaluationNode(), CHOICE, CONSTANT, DELAY, FUNCTION, INVALID, LOGICAL, MV_FUNCTION, NUMBER, OBJECT, OPERATOR, STRUCTURE, subType(), type(), VARIABLE, VECTOR, and WHITESPACE.

Referenced by CODEExporter::assembleSubTreeForMassAction(), CEvaluationNodeNormalizer::collectIdenticalBranches(), copyNode(), CNormalTranslation::expandPowerExponents(), CODEExporter::modifyTreeForMassAction(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall(), CEvaluationNodeOperator::simplifyNode(), CEvaluationNodeFunction::simplifyNode(), and SBMLImporter::variables2objects().

{
  CEvaluationNode * pNode = NULL;

  switch (CEvaluationNode::type(type))
    {
      case CEvaluationNode::CALL:
        pNode = new CEvaluationNodeCall((CEvaluationNodeCall::SubType) subType(type),
                                        contents);
        break;

      case CEvaluationNode::CHOICE:
        pNode = new CEvaluationNodeChoice((CEvaluationNodeChoice::SubType) subType(type),
                                          contents);
        break;

      case CEvaluationNode::CONSTANT:
        pNode = new CEvaluationNodeConstant((CEvaluationNodeConstant::SubType) subType(type),
                                            contents);
        break;

      case CEvaluationNode::DELAY:
        pNode = new CEvaluationNodeDelay((CEvaluationNodeDelay::SubType) subType(type),
                                         contents);
        break;

      case CEvaluationNode::FUNCTION:
        pNode = new CEvaluationNodeFunction((CEvaluationNodeFunction::SubType) subType(type),
                                            contents);
        break;

      case CEvaluationNode::LOGICAL:
        pNode = new CEvaluationNodeLogical((CEvaluationNodeLogical::SubType) subType(type),
                                           contents);
        break;

      case CEvaluationNode::NUMBER:
        pNode = new CEvaluationNodeNumber((CEvaluationNodeNumber::SubType) subType(type),
                                          contents);
        break;

      case CEvaluationNode::OBJECT:
        pNode = new CEvaluationNodeObject((CEvaluationNodeObject::SubType) subType(type),
                                          contents);
        break;

      case CEvaluationNode::OPERATOR:
        pNode = new CEvaluationNodeOperator((CEvaluationNodeOperator::SubType) subType(type),
                                            contents);
        break;

      case CEvaluationNode::STRUCTURE:
        pNode = new CEvaluationNodeStructure((CEvaluationNodeStructure::SubType) subType(type),
                                             contents);
        break;

      case CEvaluationNode::VARIABLE:
        pNode = new CEvaluationNodeVariable((CEvaluationNodeVariable::SubType) subType(type),
                                            contents);
        break;

      case CEvaluationNode::VECTOR:
        pNode = new CEvaluationNodeVector((CEvaluationNodeVector::SubType) subType(type),
                                          contents);
        break;

      case CEvaluationNode::WHITESPACE:
        pNode = new CEvaluationNodeWhiteSpace((CEvaluationNodeWhiteSpace::SubType) subType(type),
                                              contents);
        break;

      case CEvaluationNode::INVALID:
        pNode = new CEvaluationNode();
        break;

      case CEvaluationNode::MV_FUNCTION:
        break;
    }

  return pNode;
}

const CEvaluationNode * CEvaluationNode::findTopMinus

(

const std::vector< CFunctionAnalyzer::CValue > &

callParameters

)

const

Find a minus operator in the tree that is suitable for splitting with splitBranch(). Specifically it is a minus operator that is connected with the root node by multiplication or division nodes only. For the division nodes only the left child is considered.

Definition at line 566 of file CEvaluationNode.cpp.

References CNodeIteratorMode::After, CNodeIteratorMode::Before, CNodeContextIterator< Node, Context >::context(), CEvaluationNodeOperator::DIVIDE, CNodeContextIterator< Node, Context >::end(), CFunctionAnalyzer::evaluateNode(), CCopasiNode< _Data >::getChild(), CCopasiNode< _Data >::getData(), getType(), CFunctionAnalyzer::CValue::isPositive(), CEvaluationNodeOperator::MINUS, CEvaluationNodeOperator::MULTIPLY, CNodeContextIterator< Node, Context >::next(), CFunctionAnalyzer::NOOBJECT, OPERATOR, CNodeContextIterator< Node, Context >::parentContextPtr(), CNodeContextIterator< Node, Context >::processingMode(), CNodeContextIterator< Node, Context >::setProcessingModes(), and CNodeContextIterator< Node, Context >::skipChildren().

Referenced by CFunction::splitFunction().

{
  CNodeContextIterator< const CEvaluationNode, std::vector< const CEvaluationNode * > > itNode(this);
  itNode.setProcessingModes(CNodeIteratorMode::Before | CNodeIteratorMode::After);
  const CEvaluationNode * pMinus = NULL;

  while (itNode.next() != itNode.end())
    {
      if (*itNode == NULL)
        {
          continue;
        }

#ifdef COPASI_DEBUG
      std::cout << itNode->getData() << std::endl;
#endif

      switch (itNode.processingMode())
        {
          case CNodeIteratorMode::Before:

            if (itNode->getType() == (OPERATOR | CEvaluationNodeOperator::MINUS))
              {
                // We found a minus no need to go down the tree.
                itNode.skipChildren();
                pMinus = *itNode;

                if (itNode.parentContextPtr() != NULL)
                  {
                    itNode.parentContextPtr()->push_back(pMinus);
                  }
              }

            break;

          case CNodeIteratorMode::After:

            if (itNode->getType() == (OPERATOR | CEvaluationNodeOperator::MULTIPLY))
              {
                // Left child
                if (itNode.context()[0] != NULL)
                  {
                    // Both children contain a minus, this is not a valid split point.

                    if (itNode.context()[1] != NULL)
                      {
                        pMinus = NULL;
                      }
                    // Check whether the right is positive
                    else if (CFunctionAnalyzer::evaluateNode(static_cast< const CEvaluationNode *>(itNode->getChild(1)),
                             callParameters, CFunctionAnalyzer::NOOBJECT).isPositive())
                      {
                        pMinus = itNode.context()[0];
                      }
                    else
                      {
                        pMinus = NULL;
                      }
                  }
                // Right child
                else if (itNode.context()[1] != NULL)
                  {
                    // Check whether the left is positive
                    if (CFunctionAnalyzer::evaluateNode(static_cast< const CEvaluationNode *>(itNode->getChild(0)),
                                                        callParameters, CFunctionAnalyzer::NOOBJECT).isPositive())
                      pMinus = itNode.context()[1];
                    else
                      pMinus = NULL;
                  }
                else
                  {
                    pMinus = NULL;
                  }
              }
            else if (itNode->getType() == (OPERATOR | CEvaluationNodeOperator::DIVIDE))
              {
                // Left child
                pMinus = itNode.context()[0];
              }
            else
              {
                pMinus = NULL;
              }

            if (itNode.parentContextPtr() != NULL)
              {
                itNode.parentContextPtr()->push_back(pMinus);
              }

            break;

          default:
            // This will never happen
            break;
        }
    }

  return pMinus;
}

std::string CEvaluationNode::getBerkeleyMadonnaString ( const std::vector< std::string > &  children ) const

virtual

Retrieve the display string of the node and its eventual child nodes in Berkeley Madonna format.

Returns

std::string BerkeleyMadonnaString

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeOperator, CEvaluationNodeCall, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeConstant, CEvaluationNodeVector, and CEvaluationNodeDelay.

Definition at line 304 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::mData.

Referenced by buildBerkeleyMadonnaString().

{return mData;}

std::string CEvaluationNode::getCCodeString ( const std::vector< std::string > &  children ) const

virtual

Retrieve the display string of the node and its eventual child nodes in C.

Returns

std::string CCodeString

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeOperator, CEvaluationNodeCall, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeNumber, CEvaluationNodeConstant, CEvaluationNodeVector, and CEvaluationNodeDelay.

Definition at line 274 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::mData.

Referenced by buildCCodeString().

{return mData;}

std::string CEvaluationNode::getDisplayString ( const std::vector< std::string > &  children ) const

virtual

Retrieve the display string of the node and its eventual child nodes.

Returns

std::string DisplayString

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeOperator, CEvaluationNodeCall, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeVector, and CEvaluationNodeDelay.

Definition at line 247 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::mData.

Referenced by buildDisplayString().

{return mData;}

std::string CEvaluationNode::getInfix ( const std::vector< std::string > &  children ) const

virtual

Retrieve the infix value of the node and its eventual child nodes.

Returns

std::string Infix

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeDelay, CEvaluationNodeOperator, CEvaluationNodeObject, CEvaluationNodeCall, CEvaluationNodeChoice, and CEvaluationNodeVector.

Definition at line 220 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::mData.

Referenced by buildInfix().

{return mData;}

std::string CEvaluationNode::getMMLString ( const std::vector< std::string > &  children, bool  expand, const std::vector< std::vector< std::string > > &  variables  ) const

virtual

Build the MathML string

Parameters

const	std::vector< std::string > & children
bool	expand = true
const	std::vector< std::vector< std::string > > & variables

Returns

std::string MMLString

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeOperator, CEvaluationNodeCall, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeConstant, CEvaluationNodeDelay, CEvaluationNodeVariable, and CEvaluationNodeNumber.

Definition at line 445 of file CEvaluationNode.cpp.

Referenced by buildMMLString().

{
  return "";
}

const CEvaluationNode::Type & CEvaluationNode::getType

(

)

const

Retrieve the type of the node. Note the type combines type and subType information. To Retrieve the type use type(getType()) and to retrieve the subType use subType(getType()).

Returns

const Type & type.

Definition at line 357 of file CEvaluationNode.cpp.

References mType.

Referenced by SBMLImporter::areEqualSubtrees(), CODEExporter::assembleSubTreeForMassAction(), CEvaluationTree::buildCalculationSequence(), CSBMLExporter::checkForPiecewiseFunctions(), CSBMLExporter::checkForUnsupportedFunctionCalls(), CEvaluationNodeNormalizer::collectIdenticalBranches(), CMathEventN::CTrigger::compile(), CMathTrigger::compile(), CMathEventN::CTrigger::compileAND(), CMathTrigger::compileEQ(), CMathEventN::CTrigger::compileLE(), CMathTrigger::copyBranch(), CMathContainer::copyBranch(), CMathEventN::CTrigger::countRoots(), createCall(), createChoice(), SBMLImporter::createCReactionFromReaction(), CMathContainer::createDiscontinuityTriggerInfix(), CSBMLExporter::createEvent(), createFunction(), createGeneralPower(), CSBMLExporter::createInitialAssignment(), createItem(), createItemPower(), createItemPowerItem(), createLogical(), createLogicalChoice(), createLogicalItem(), CEvaluationNodeOperator::createModuloTree(), createNormalRepresentation(), createProduct(), CSBMLExporter::createRule(), createSum(), CDerive::deriveBranch(), SBMLImporter::divideByObject(), CNormalTranslation::elementaryElimination(), CNormalTranslation::elementaryEliminationDivide(), CNormalTranslation::elementaryEliminationFunction(), CNormalTranslation::elementaryEliminationMinus(), CNormalTranslation::elementaryEliminationModulus(), CNormalTranslation::elementaryEliminationMultiply(), CNormalTranslation::elementaryEliminationPlus(), CNormalTranslation::elementaryEliminationPower(), CNormalTranslation::eliminateDirectlyNestedFractions(), CNormalTranslation::eliminateNestedPowers(), CNormalTranslation::eliminatePowersOfFractions(), CFunctionAnalyzer::evaluateNode(), CNormalTranslation::expandPowerBases(), CNormalTranslation::expandPowerExponents(), CNormalTranslation::expandPowerNodes(), CNormalTranslation::expandProducts(), CSBMLExporter::exportEventAssignments(), CNormalTranslation::factorize(), CEvaluationNodeNormalizer::findChainNodes(), CFindDimensions::findDimension(), CSBMLExporter::findDirectlyUsedFunctions(), CSBMLExporter::findModelEntityDependencies(), CNormalTranslation::findNegativeNumbers(), CNormalTranslation::findSummands(), findTopMinus(), CEvaluationNodeConstant::getBerkeleyMadonnaString(), CEvaluationNodeLogical::getBerkeleyMadonnaString(), CEvaluationNodeFunction::getBerkeleyMadonnaString(), CEvaluationNodeConstant::getCCodeString(), CEvaluationNodeOperator::getCCodeString(), CEvaluationNodeLogical::getCCodeString(), CEvaluationNodeFunction::getCCodeString(), CEvaluationNodeConstant::getMMLString(), CEvaluationNodeOperator::getMMLString(), CEvaluationNodeLogical::getMMLString(), CEvaluationNodeFunction::getMMLString(), CEvaluationNodeConstant::getXPPString(), CEvaluationNodeOperator::getXPPString(), CEvaluationNodeLogical::getXPPString(), CEvaluationNodeFunction::getXPPString(), CEvaluationNodeFunction::handleNot(), CEvaluationNodeFunction::handleSign(), SBMLImporter::isConstantFlux(), CSBMLExporter::isEventAssignmentSBMLCompatible(), isLogical(), SBMLImporter::isMassAction(), SBMLImporter::isMassActionExpression(), CMathObject::isPrerequisiteForContext(), CNormalTranslation::matchPowerBases(), CNormalTranslation::matchSummands(), CSBMLExporter::multiplyByObject(), CNormalTranslation::newCancel(), CNormalTranslation::newEvaluateNumbers(), CEvaluationNodeNormalizer::normalize(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeChoice(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeDelay(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeFunction(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeLogical(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeOperator(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeVector(), CEvaluationNodeNormalizer::normalizeDivideNode(), CEvaluationNodeNormalizer::normalizeMinusNode(), CEvaluationNodeNormalizer::normalizeModulusNode(), CEvaluationNodeNormalizer::normalizeMultiplyNode(), CEvaluationNodeNormalizer::normalizePlusNode(), CEvaluationNodeNormalizer::normalizePowerNode(), CReaction::objects2variables(), operator<(), operator==(), CNormalTranslation::product2fraction(), CSBMLExporter::replaceSpeciesReferences(), SBMLImporter::separateProductArguments(), setBooleanRequired(), CSBMLExporter::setFunctionSBMLIds(), CEvaluationNodeOperator::simplifyNode(), CNormalTranslation::splitProduct(), CNormalTranslation::splitSum(), CNormalTranslation::swapNegativeNumbers(), test000053::test1_bug1000(), test000053::test2_bug1000(), test000053::test3_bug1000(), test000053::test4_bug1000(), test000053::test5_bug1000(), test000093::test_bug1503_1(), test000093::test_bug1503_2(), test000052::test_bug988(), test_compare_utilities::test_copasi_function_expansion(), test000091::test_delay_in_kinetic_law(), test000091::test_delay_in_kinetic_law_local_parameter(), test_depth_first_iterator::test_dfi(), test000042::test_hasOnlySubstanceUnits(), test000026::test_hasOnlySubstanceUnits(), test000040::test_hasOnlySubstanceUnits(), test000023::test_hasOnlySubstanceUnits(), test000043::test_hasOnlySubstanceUnits(), test000025::test_hasOnlySubstanceUnits(), test000033::test_hasOnlySubstanceUnits(), test000082::test_import_delayAssignment_1(), test000082::test_import_delayAssignment_2(), test000082::test_import_delayAssignment_3(), test000082::test_import_delayAssignment_4(), test000082::test_import_delayAssignment_5(), test000082::test_import_delayAssignment_6(), test000082::test_import_delayAssignment_7(), test000082::test_import_delayAssignment_8(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_2(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_3(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_5(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_7(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_8(), test000095::test_import_l3_event_1(), test000095::test_import_l3_event_2(), test000095::test_import_l3_event_3(), test000095::test_import_l3_event_4(), test000095::test_import_l3_event_5(), test000087::test_import_reaction_flux_reference_2(), test000065::test_import_reaction_with_unsuitable_kinetic_1(), test000065::test_import_reaction_with_unsuitable_kinetic_2(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_2(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_3(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_5(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_7(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_8(), test000075::test_import_time_dependent_function_definition(), test000078::test_l2v4_import_unordered_functions(), test000087::test_simulate_reaction_flux_reference_1(), CEvaluationNodeNumber::toAST(), CEvaluationNodeConstant::toAST(), CEvaluationNodeOperator::toAST(), CEvaluationNodeLogical::toAST(), CEvaluationNodeFunction::toAST(), SBMLImporter::variables2objects(), CReaction::variables2objects(), and CEvaluationNodeCall::verifyParameters().

{return mType;}

const C_FLOAT64& CEvaluationNode::getValue ( ) const

inline

Retrieve the value of the node

Returns

const C_FLOAT64 & value

Definition at line 144 of file CEvaluationNode.h.

References mpValue.

Referenced by CEvaluationNodeChoice::calculate(), CEvaluationNodeOperator::calculate(), CEvaluationNodeLogical::calculate(), CEvaluationNodeFunction::calculate(), CEvaluationTree::calculate(), createProduct(), CNormalTranslation::elementaryEliminationModulus(), CNormalTranslation::elementaryEliminationPower(), CEvaluationNodeNormalizer::eliminateMultipleNumbers(), CFunctionAnalyzer::evaluateNode(), CFindDimensions::findDimension(), CNormalTranslation::findNegativeNumbers(), CEvaluationNodeNumber::getCCodeString(), SBMLImporter::isMassActionExpression(), CNormalTranslation::matchPowerBases(), CNormalTranslation::matchSummands(), CNormalTranslation::newEvaluateNumbers(), CEvaluationNodeNormalizer::normalizeDivideNode(), CEvaluationNodeNormalizer::normalizeMinusNode(), CEvaluationNodeNormalizer::normalizeModulusNode(), CEvaluationNodeNormalizer::normalizeMultiplyNode(), CEvaluationNodeNormalizer::normalizePlusNode(), CEvaluationNodeNormalizer::normalizePowerNode(), CEvaluationNodeOperator::simplifyNode(), CNormalTranslation::splitSum(), CNormalTranslation::swapNegativeNumbers(), test000093::test_bug1503_1(), test000093::test_bug1503_2(), test_depth_first_iterator::test_dfi(), test000082::test_import_delayAssignment_1(), test000082::test_import_delayAssignment_2(), test000082::test_import_delayAssignment_3(), test000082::test_import_delayAssignment_4(), test000082::test_import_delayAssignment_5(), test000082::test_import_delayAssignment_6(), test000082::test_import_delayAssignment_7(), test000082::test_import_delayAssignment_8(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_2(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_3(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_5(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_7(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_8(), test000095::test_import_l3_event_1(), test000095::test_import_l3_event_2(), test000095::test_import_l3_event_3(), test000095::test_import_l3_event_4(), test000095::test_import_l3_event_5(), test000078::test_l2v4_import_unordered_functions(), and CEvaluationNodeNumber::toAST().

{return *mpValue;}

const C_FLOAT64 * CEvaluationNode::getValuePointer

(

)

const

Retrieve the pointer to the value of the node

Returns

const C_FLOAT64 * pValue

Definition at line 441 of file CEvaluationNode.cpp.

References mpValue.

{return mpValue;}

std::string CEvaluationNode::getXPPString ( const std::vector< std::string > &  children ) const

virtual

Retrieve the display string of the node and its eventual child nodes in XPPAUT format.

Returns

std::string XPPString

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeOperator, CEvaluationNodeCall, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeConstant, CEvaluationNodeVector, and CEvaluationNodeDelay.

Definition at line 331 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::mData.

Referenced by buildXPPString().

{return mData;}

bool CEvaluationNode::isBoolean ( ) const

virtual

Check whether the result is Boolean

Returns

bool isBoolean

Reimplemented in CEvaluationNodeCall, CEvaluationNodeFunction, CEvaluationNodeLogical, and CEvaluationNodeConstant.

Definition at line 361 of file CEvaluationNode.cpp.

Referenced by CMathEventN::CTrigger::compile(), CMathTrigger::compile(), CMathTrigger::compileEXPRESSION(), CMathTrigger::compileFUNCTION(), CMathTrigger::compileVARIABLE(), CMathEventN::CTrigger::countRoots(), CEvaluationTree::isBoolean(), and CExpression::setInfix().

{return false;}

bool CEvaluationNode::isKeyword ( const std::string &  str )

static

Check whether the string is a keyword

Parameters

const

std::string & str

Returns

bool isKeyword

Definition at line 173 of file CEvaluationNode.cpp.

References Keywords.

Referenced by CEvaluationNodeCall::CEvaluationNodeCall(), CEvaluationNodeCall::getData(), and CEvaluationNodeCall::setData().

{
  const char ** pKeyword = Keywords;

  for (; *pKeyword != NULL; ++pKeyword)
    if (!strcmp(str.c_str(), *pKeyword)) return true;

  return false;
}

bool CEvaluationNode::operator!= ( const CEvaluationNode &  right ) const

virtual

Unequal operator, compares two CEvaluationNode objects and return true if they are equal.

Definition at line 666 of file CEvaluationNode.cpp.

{
  return !(*this == right);
}

bool CEvaluationNode::operator<

(

const CEvaluationNode &

right

)

const

Less operator, compares two CEvaluationNode objects and return true if the first operand is smaller than the second.

Definition at line 699 of file CEvaluationNode.cpp.

References CALL, CHOICE, CONSTANT, DELAY, FUNCTION, CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getChild(), CCopasiNode< std::string >::getData(), CCopasiNode< _Data >::getData(), CCopasiNode< _Data >::getSibling(), getType(), INVALID, LOGICAL, MV_FUNCTION, NUMBER, OBJECT, OPERATOR, STRUCTURE, type(), VARIABLE, VECTOR, and WHITESPACE.

{
  bool result = false;

  if (this->getType() < right.getType())
    {
      result = true;
    }
  else if (this->getType() == right.getType())
    {
      switch (CEvaluationNode::type(this->getType()))
        {
          case CEvaluationNode::CONSTANT:
          case CEvaluationNode::NUMBER:
          case CEvaluationNode::OBJECT:
          case CEvaluationNode::CALL:
          case CEvaluationNode::STRUCTURE:
          case CEvaluationNode::VARIABLE:
          case CEvaluationNode::WHITESPACE:
            result = (this->getData() < right.getData());
            break;

          case CEvaluationNode::OPERATOR:
          case CEvaluationNode::FUNCTION:
          case CEvaluationNode::CHOICE:
          case CEvaluationNode::LOGICAL:
          case CEvaluationNode::MV_FUNCTION:
          case CEvaluationNode::VECTOR:
          case CEvaluationNode::DELAY:
          case CEvaluationNode::INVALID:
            break;
        }

      const CEvaluationNode* pChild1 = dynamic_cast<const CEvaluationNode*>(this->getChild());

      const CEvaluationNode* pChild2 = dynamic_cast<const CEvaluationNode*>(right.getChild());

      while (result == false)
        {
          if (pChild1 == NULL || pChild2 == NULL)
            {
              if (pChild1 == NULL && pChild2 != NULL)
                {
                  result = true;
                }
            }
          else
            {
              result = (*pChild1 < *pChild2);
            }

          pChild1 = dynamic_cast<const CEvaluationNode*>(pChild1->getSibling());
          pChild2 = dynamic_cast<const CEvaluationNode*>(pChild2->getSibling());
        }
    }

  return result;
}

bool CEvaluationNode::operator<

(

const CEvaluationNode &

rhs

)

Comparison operator used to evaluate the precedence of the node. it compares the right precedence of the left node with the left precedence of the right node.

Parameters

const

CEvaluationNode & rhs;

Returns

bool isLess

Definition at line 375 of file CEvaluationNode.cpp.

References CEvaluationNode::CPrecedence::left, mPrecedence, and CEvaluationNode::CPrecedence::right.

{return (mPrecedence.right < rhs.mPrecedence.left);}

bool CEvaluationNode::operator==

(

const CEvaluationNode &

right

)

const

Equals operator, compares two CEvaluationNode objects and return true if they are equal.

Definition at line 671 of file CEvaluationNode.cpp.

References CNodeContextIterator< Node, int >::end(), CCopasiNode< _Data >::getData(), getType(), and CNodeContextIterator< Node, int >::next().

{
  CNodeIterator< const CEvaluationNode > itLeft(this);
  CNodeIterator< const CEvaluationNode > itRight(&right);

  while (itLeft.next() != itLeft.end() &&
         itRight.next() != itRight.end())
    {
      if (*itLeft == NULL && *itRight == NULL)
        {
          continue;
        }

      if (*itLeft == NULL || *itRight == NULL)
        {
          return false;
        }

      if (itLeft->getType() != itRight->getType() ||
          itLeft->getData() != itRight->getData())
        {
          return false;
        }
    }

  return true;
}

void CEvaluationNode::printRecursively	(	std::ostream &	os,
		int	indent = 0
	)		const

Definition at line 477 of file CEvaluationNode.cpp.

References CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getSibling(), CCopasiNode< std::string >::mData, mType, mValue, printRecursively(), subType(), and type().

Referenced by stress_test::normalizeFunctionDB().

{
  int i;

  os << std::endl;

  for (i = 0; i < indent; ++i) os << " ";

  os << "mData: " << mData << std::endl;

  for (i = 0; i < indent; ++i) os << " ";

  os << "mType: " << type(mType) << "  subType: " << subType(mType) << std::endl;

  for (i = 0; i < indent; ++i) os << " ";

  os << "mValue: " << mValue << std::endl;

  CEvaluationNode* tmp;

  tmp = (CEvaluationNode*)getChild();

  while (tmp)
    {
      tmp -> printRecursively(os, indent + 2);
      tmp = (CEvaluationNode*)tmp->getSibling();
    }
}

void CEvaluationNode::printRecursively

(

)

const

Definition at line 506 of file CEvaluationNode.cpp.

Referenced by printRecursively().

{
  this->printRecursively(std::cout, 0);
}

CEvaluationNode * CEvaluationNode::simplifyNode ( const std::vector< CEvaluationNode * > &  children ) const

virtual

Create a simplified node from the original node with children child1 and child2 (if not exist, = NULL)

Returns

CEvaluationNode* return a pointer to the simplified node;

Reimplemented in CEvaluationNodeFunction, and CEvaluationNodeOperator.

Definition at line 430 of file CEvaluationNode.cpp.

References copyNode().

Referenced by CEvaluationNodeOperator::simplifyNode(), and CNormalTranslation::simplifyTree().

{
  CEvaluationNode *newnode = copyNode(children);
  return newnode;
}

CEvaluationNode * CEvaluationNode::splitBranch	(	const CEvaluationNode *	splitnode,
		bool	left
	)		const

Split the tree in two parts at the given splitnode, starting from *this. Returned is the root node of a copy of the tree, including everything above the split node and either the branch below the left child of the split node or the branch below the right child of the split node. The split node itself is not included either case.

Definition at line 511 of file CEvaluationNode.cpp.

References copyBranch(), copyNode(), CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getSibling(), and splitBranch().

Referenced by splitBranch(), and CFunction::splitFunction().

{
  if (splitnode == this)
    {
      const CEvaluationNode *child = dynamic_cast<const CEvaluationNode*>(this->getChild());

      if (!child) return NULL;

      if (left)
        {
          return child->copyBranch();
        }
      else
        {
          child = dynamic_cast<const CEvaluationNode*>(child->getSibling());

          if (!child) return NULL;

          return child->copyBranch();
        }
    }
  else
    {
      /*        const CEvaluationNode *child1 = dynamic_cast<const CEvaluationNode*>(getChild());
              CEvaluationNode *newchild1 = NULL;
              CEvaluationNode *newchild2 = NULL;
              if (child1 != NULL)
                {
                  newchild1 = child1->splitBranch(splitnode, left);
                  const CEvaluationNode *child2 = dynamic_cast<const CEvaluationNode*>(child1->getSibling());
                  if (child2 != NULL)
                    {
                      newchild2 = child2->splitBranch(splitnode, left);
                    }
                }
              CEvaluationNode *newnode = copyNode(newchild1, newchild2);
              return newnode;*/

      std::vector<CEvaluationNode*> children;
      const CEvaluationNode* child = dynamic_cast<const CEvaluationNode*>(getChild());

      while (child != NULL)
        {
          CEvaluationNode *newchild = NULL;
          newchild = child->splitBranch(splitnode, left);
          children.push_back(newchild);
          child = dynamic_cast<const CEvaluationNode*>(child->getSibling());
        }

      children.push_back(NULL);
      CEvaluationNode *newnode = copyNode(children);
      return newnode;
    }
}

CEvaluationNode::Type CEvaluationNode::subType ( const Type &  type )

static

Retrieve the subtype part of type

Parameters

const

Type & type

Returns

Type subType

Definition at line 120 of file CEvaluationNode.cpp.

Referenced by CSBMLExporter::checkForUnsupportedFunctionCalls(), CEvaluationNodeObject::compile(), CMathTrigger::compile(), CMathEventN::CTrigger::compileAND(), CMathEventN::CTrigger::compileLE(), CMathEventN::CTrigger::countRoots(), create(), createCall(), createFunction(), createGeneralPower(), createItemPower(), createItemPowerItem(), createLogical(), createLogicalItem(), CEvaluationNodeOperator::createModuloTree(), createProduct(), createSum(), CDerive::deriveBranch(), SBMLImporter::divideByObject(), CNormalTranslation::elementaryElimination(), CNormalTranslation::elementaryEliminationDivide(), CNormalTranslation::elementaryEliminationFunction(), CNormalTranslation::elementaryEliminationMinus(), CNormalTranslation::elementaryEliminationModulus(), CNormalTranslation::elementaryEliminationMultiply(), CNormalTranslation::elementaryEliminationPlus(), CNormalTranslation::elementaryEliminationPower(), CNormalTranslation::eliminateDirectlyNestedFractions(), CNormalTranslation::eliminateNestedPowers(), CNormalTranslation::eliminatePowersOfFractions(), CFunctionAnalyzer::evaluateNode(), CNormalTranslation::expandPowerBases(), CNormalTranslation::expandPowerExponents(), CNormalTranslation::expandPowerNodes(), CNormalTranslation::expandProducts(), CNormalTranslation::factorize(), CEvaluationNodeNormalizer::findChainNodes(), CNormalTranslation::findNegativeNumbers(), CNormalTranslation::findSummands(), CEvaluationNodeNumber::fromAST(), CEvaluationNodeDelay::fromAST(), CEvaluationNodeConstant::fromAST(), CEvaluationNodeChoice::fromAST(), CEvaluationNodeCall::fromAST(), CEvaluationNodeOperator::fromAST(), CEvaluationNodeLogical::fromAST(), CEvaluationNodeFunction::fromAST(), CEvaluationNodeConstant::getBerkeleyMadonnaString(), CEvaluationNodeLogical::getBerkeleyMadonnaString(), CEvaluationNodeFunction::getBerkeleyMadonnaString(), CEvaluationNodeConstant::getCCodeString(), CEvaluationNodeOperator::getCCodeString(), CEvaluationNodeLogical::getCCodeString(), CEvaluationNodeFunction::getCCodeString(), CEvaluationNodeObject::getData(), CEvaluationNodeObject::getInfix(), CEvaluationNodeConstant::getMMLString(), CEvaluationNodeLogical::getMMLString(), CEvaluationNodeConstant::getXPPString(), CEvaluationNodeOperator::getXPPString(), CEvaluationNodeLogical::getXPPString(), CEvaluationNodeFunction::getXPPString(), CEvaluationNodeConstant::isBoolean(), CEvaluationNodeFunction::isBoolean(), isLogical(), SBMLImporter::isMassActionExpression(), CNormalTranslation::matchPowerBases(), CNormalTranslation::matchSummands(), CSBMLExporter::multiplyByObject(), CNormalTranslation::newCancel(), CNormalTranslation::newEvaluateNumbers(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeCall(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeDelay(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeFunction(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeLogical(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeOperator(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeVector(), CEvaluationNodeNormalizer::normalizeModulusNode(), CEvaluationNodeNormalizer::normalizeMultiplyNode(), CEvaluationNodeNormalizer::normalizePlusNode(), printRecursively(), CNormalTranslation::product2fraction(), CSBMLExporter::replaceSpeciesReferences(), SBMLImporter::separateProductArguments(), CEvaluationNodeObject::setData(), CFunction::setInfix(), CEvaluationNodeObject::setObjectValuePtr(), CEvaluationNodeOperator::simplifyNode(), CEvaluationNodeFunction::simplifyNode(), CNormalTranslation::splitProduct(), CNormalTranslation::splitSum(), CNormalTranslation::swapNegativeNumbers(), test000053::test1_bug1000(), test000053::test2_bug1000(), test000053::test3_bug1000(), test000053::test4_bug1000(), test000053::test5_bug1000(), test000093::test_bug1503_1(), test000093::test_bug1503_2(), test000052::test_bug988(), test_compare_utilities::test_copasi_function_expansion(), test000047::test_delay(), test000091::test_delay_in_kinetic_law(), test000091::test_delay_in_kinetic_law_local_parameter(), test_depth_first_iterator::test_dfi(), test000023::test_hasOnlySubstanceUnits(), test000025::test_hasOnlySubstanceUnits(), test000033::test_hasOnlySubstanceUnits(), test000042::test_hasOnlySubstanceUnits(), test000040::test_hasOnlySubstanceUnits(), test000043::test_hasOnlySubstanceUnits(), test000026::test_hasOnlySubstanceUnits(), test000082::test_import_delayAssignment_1(), test000082::test_import_delayAssignment_2(), test000082::test_import_delayAssignment_3(), test000082::test_import_delayAssignment_4(), test000082::test_import_delayAssignment_5(), test000082::test_import_delayAssignment_6(), test000082::test_import_delayAssignment_7(), test000082::test_import_delayAssignment_8(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_2(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_3(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_5(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_7(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_8(), test000095::test_import_l3_event_1(), test000095::test_import_l3_event_2(), test000095::test_import_l3_event_3(), test000095::test_import_l3_event_4(), test000095::test_import_l3_event_5(), test000065::test_import_reaction_with_unsuitable_kinetic_1(), test000065::test_import_reaction_with_unsuitable_kinetic_2(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_7(), test000075::test_import_time_dependent_function_definition(), test000078::test_l2v4_import_unordered_functions(), CEvaluationNodeNumber::toAST(), CEvaluationNodeConstant::toAST(), CEvaluationNodeOperator::toAST(), CEvaluationNodeLogical::toAST(), CEvaluationNodeFunction::toAST(), and CReaction::variables2objects().

{return (Type)(type & 0x00FFFFFF);}

ASTNode * CEvaluationNode::toAST ( const CCopasiDataModel *  pDataModel ) const

virtual

Create a new invalid ASTNode.

Returns

ASTNode* return a pointer to the newly created node;

Reimplemented in CEvaluationNodeFunction, CEvaluationNodeLogical, CEvaluationNodeOperator, CEvaluationNodeCall, CEvaluationNodeObject, CEvaluationNodeChoice, CEvaluationNodeConstant, CEvaluationNodeVector, CEvaluationNodeDelay, CEvaluationNodeVariable, CEvaluationNodeNumber, CEvaluationNodeStructure, and CEvaluationNodeWhiteSpace.

Definition at line 436 of file CEvaluationNode.cpp.

Referenced by CSBMLExporter::convertToASTNode(), CEvaluationNodeOperator::createModuloTree(), CEvaluationNodeDelay::toAST(), CEvaluationNodeChoice::toAST(), CEvaluationTree::toAST(), CEvaluationNodeObject::toAST(), CEvaluationNodeCall::toAST(), CEvaluationNodeOperator::toAST(), CEvaluationNodeLogical::toAST(), and CEvaluationNodeFunction::toAST().

{
  return new ASTNode();
}

CEvaluationNode::Type CEvaluationNode::type ( const Type &  type )

static

Retrieve the type part of type

Parameters

const

Type & type

Returns

Type type

Definition at line 123 of file CEvaluationNode.cpp.

Referenced by CODEExporter::assembleSubTreeForMassAction(), CEvaluationTree::buildCalculationSequence(), CEvaluationNodeCall::buildParameters(), CSBMLExporter::checkForPiecewiseFunctions(), CSBMLExporter::checkForUnsupportedFunctionCalls(), CSBMLExporter::checkForUnsupportedObjectReferences(), CEvaluationNodeCall::clearParameters(), CMathEventN::CTrigger::compile(), CMathTrigger::compile(), CMathTrigger::compileEQ(), CModelAdd::copyDelayExpression(), CModelAdd::copyEventAssignmentExpression(), CModelAdd::copyExpression(), CModelAdd::copyInitialExpression(), CModelAdd::copyTriggerExpression(), CMathEventN::CTrigger::countRoots(), create(), createCall(), createChoice(), SBMLImporter::createCReactionFromReaction(), CSBMLExporter::createEvent(), createFunction(), createGeneralPower(), CSBMLExporter::createInitialAssignment(), createItem(), createItemPower(), createItemPowerItem(), createLogical(), createLogicalChoice(), createLogicalItem(), createNormalRepresentation(), createProduct(), CSBMLExporter::createRule(), createSum(), SBMLImporter::divideByObject(), CNormalTranslation::elementaryElimination(), CNormalTranslation::elementaryEliminationDivide(), CNormalTranslation::elementaryEliminationFunction(), CNormalTranslation::elementaryEliminationMinus(), CNormalTranslation::elementaryEliminationModulus(), CNormalTranslation::elementaryEliminationMultiply(), CNormalTranslation::elementaryEliminationPlus(), CNormalTranslation::elementaryEliminationPower(), CNormalTranslation::eliminateDirectlyNestedFractions(), CNormalTranslation::eliminateNestedPowers(), CNormalTranslation::eliminatePowersOfFractions(), CFunctionAnalyzer::evaluateNode(), CNormalTranslation::expandPowerBases(), CNormalTranslation::expandPowerExponents(), CNormalTranslation::expandPowerNodes(), CNormalTranslation::expandProducts(), CSBMLExporter::exportEventAssignments(), CODEExporter::exportExpression(), CODEExporter::exportKineticFunction(), CODEExporterC::exportSingleFunction(), CODEExporter::exportSingleFunction(), CNormalTranslation::factorize(), CEvaluationNodeNormalizer::findChainNodes(), CSBMLExporter::findDirectlyUsedFunctions(), SBMLImporter::findFunctionCalls(), CODEExporter::findFunctionsCalls(), CSBMLExporter::findModelEntityDependencies(), CNormalTranslation::findNegativeNumbers(), CNormalTranslation::findSummands(), CEvaluationNodeOperator::fromAST(), CEvaluationNodeFunction::fromAST(), CEvaluationNodeFunction::getMMLString(), CFunction::initVariables(), SBMLImporter::isConstantFlux(), CSBMLExporter::isEventAssignmentSBMLCompatible(), isLogical(), SBMLImporter::isMassActionExpression(), CODEExporter::isModelEntityExpressionODEExporterCompatible(), CNormalTranslation::matchPowerBases(), CNormalTranslation::matchSummands(), CModelMerging::mergeInExpression(), CODEExporter::modifyTreeForMassAction(), CNormalTranslation::multiply(), CSBMLExporter::multiplyByObject(), CNormalTranslation::newCancel(), CNormalTranslation::newEvaluateNumbers(), CEvaluationNodeNormalizer::normalize(), CEvaluationNodeNormalizer::normalizeCEvaluationNodeChoice(), CEvaluationNodeNormalizer::normalizeDivideNode(), CEvaluationNodeNormalizer::normalizeMinusNode(), CEvaluationNodeNormalizer::normalizeModulusNode(), CEvaluationNodeNormalizer::normalizeMultiplyNode(), CEvaluationNodeNormalizer::normalizePlusNode(), CEvaluationNodeNormalizer::normalizePowerNode(), CReaction::objects2variables(), operator<(), printRecursively(), CNormalTranslation::product2fraction(), CSBMLExporter::replaceSpeciesReferences(), setBooleanRequired(), CODEExporterC::setExportNameOfFunction(), CSBMLExporter::setFunctionSBMLIds(), CFunction::setInfix(), CEvaluationNodeOperator::simplifyNode(), CEvaluationNodeFunction::simplifyNode(), CNormalTranslation::splitProduct(), CNormalTranslation::splitSum(), CNormalTranslation::swapNegativeNumbers(), test000053::test1_bug1000(), test000053::test2_bug1000(), test000053::test3_bug1000(), test000053::test4_bug1000(), test000053::test5_bug1000(), test000093::test_bug1503_1(), test000093::test_bug1503_2(), test000061::test_bug_1044(), test_compare_utilities::test_copasi_function_expansion(), test000091::test_delay_in_kinetic_law(), test000091::test_delay_in_kinetic_law_local_parameter(), test_depth_first_iterator::test_dfi(), test000082::test_import_delayAssignment_1(), test000082::test_import_delayAssignment_2(), test000082::test_import_delayAssignment_3(), test000082::test_import_delayAssignment_4(), test000082::test_import_delayAssignment_5(), test000082::test_import_delayAssignment_6(), test000082::test_import_delayAssignment_7(), test000082::test_import_delayAssignment_8(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_2(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_3(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_5(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_7(), test000064::test_import_event_assignment_expression_and_hasOnlySubstanceUnits_8(), test000095::test_import_l3_event_1(), test000095::test_import_l3_event_2(), test000095::test_import_l3_event_3(), test000095::test_import_l3_event_4(), test000095::test_import_l3_event_5(), test000087::test_import_reaction_flux_reference_2(), test000065::test_import_reaction_with_unsuitable_kinetic_1(), test000065::test_import_reaction_with_unsuitable_kinetic_2(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_1(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_2(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_3(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_4(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_5(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_6(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_7(), test000064::test_import_rule_expression_and_hasOnlySubstanceUnits_8(), test000075::test_import_time_dependent_function_definition(), test000078::test_l2v4_import_unordered_functions(), test000087::test_simulate_reaction_flux_reference_1(), CReaction::variables2objects(), and CEvaluationNodeCall::verifyParameters().

{return (Type)(type & 0xFF000000);}

Member Data Documentation

const char * CEvaluationNode::Keywords

staticprivate

A list of reserved key words

Definition at line 86 of file CEvaluationNode.h.

Referenced by isKeyword().

class CEvaluationNode::CPrecedence CEvaluationNode::mPrecedence

protected

Referenced by CEvaluationNodeCall::CEvaluationNodeCall(), CEvaluationNodeChoice::CEvaluationNodeChoice(), CEvaluationNodeConstant::CEvaluationNodeConstant(), CEvaluationNodeDelay::CEvaluationNodeDelay(), CEvaluationNodeFunction::CEvaluationNodeFunction(), CEvaluationNodeLogical::CEvaluationNodeLogical(), CEvaluationNodeNumber::CEvaluationNodeNumber(), CEvaluationNodeObject::CEvaluationNodeObject(), CEvaluationNodeOperator::CEvaluationNodeOperator(), CEvaluationNodeStructure::CEvaluationNodeStructure(), CEvaluationNodeVariable::CEvaluationNodeVariable(), CEvaluationNodeVector::CEvaluationNodeVector(), and operator<().

const C_FLOAT64* CEvaluationNode::mpValue

protected

A pointer to the numerical value of the node

Definition at line 342 of file CEvaluationNode.h.

Referenced by CEvaluationNode(), CEvaluationNodeObject::CEvaluationNodeObject(), CEvaluationNodeObject::compile(), CEvaluationNodeObject::getObjectValuePtr(), getValue(), getValuePointer(), and CEvaluationNodeObject::setObjectValuePtr().

Type CEvaluationNode::mType

protected

The type the node

Definition at line 332 of file CEvaluationNode.h.

Referenced by CEvaluationNodeCall::calculate(), CEvaluationNodeOperator::calculate(), CEvaluationNodeLogical::calculate(), CEvaluationNodeLogical::CEvaluationNodeLogical(), CEvaluationNodeOperator::CEvaluationNodeOperator(), CEvaluationNodeCall::compile(), CEvaluationNodeObject::compile(), CEvaluationNodeDelay::compile(), copyNode(), CEvaluationNodeDelay::getBerkeleyMadonnaString(), CEvaluationNodeFunction::getBerkeleyMadonnaString(), CEvaluationNodeCall::getCalledTree(), CEvaluationNodeDelay::getCCodeString(), CEvaluationNodeCall::getCCodeString(), CEvaluationNodeFunction::getCCodeString(), CEvaluationNodeObject::getData(), CEvaluationNodeDelay::getDisplayString(), CEvaluationNodeCall::getDisplayString(), CEvaluationNodeFunction::getDisplayString(), CEvaluationNodeCall::getInfix(), CEvaluationNodeObject::getInfix(), CEvaluationNodeDelay::getInfix(), CEvaluationNodeFunction::getInfix(), CEvaluationNodeDelay::getMMLString(), CEvaluationNodeCall::getMMLString(), CEvaluationNodeOperator::getMMLString(), CEvaluationNodeFunction::getMMLString(), getType(), CEvaluationNodeDelay::getXPPString(), CEvaluationNodeFunction::getXPPString(), CEvaluationNodeConstant::isBoolean(), CEvaluationNodeFunction::isBoolean(), printRecursively(), CEvaluationNodeObject::setData(), CEvaluationNodeObject::setObjectValuePtr(), CEvaluationNodeOperator::simplifyNode(), and CEvaluationNodeFunction::simplifyNode().

C_FLOAT64 CEvaluationNode::mValue

protected

The numerical value of the node

Definition at line 337 of file CEvaluationNode.h.

Referenced by CEvaluationNodeCall::calculate(), CEvaluationNodeChoice::calculate(), CEvaluationNodeOperator::calculate(), CEvaluationNodeVariable::calculate(), CEvaluationNodeLogical::calculate(), CEvaluationNodeFunction::calculate(), CEvaluationNode(), CEvaluationNodeConstant::CEvaluationNodeConstant(), CEvaluationNodeDelay::CEvaluationNodeDelay(), CEvaluationNodeNumber::CEvaluationNodeNumber(), CEvaluationNodeObject::compile(), CEvaluationNodeConstant::getBerkeleyMadonnaString(), CEvaluationNodeConstant::getXPPString(), and printRecursively().

---

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

• CEvaluationNode.h
• CEvaluationNode.cpp