#include <CEvaluationNodeChoice.h>

Inheritance diagram for CEvaluationNodeChoice:

Collaboration diagram for CEvaluationNodeChoice:

Public Types
enum	SubType { INVALID = 0x00FFFFFF, IF = 0x00000000 }

Public Types inherited from CEvaluationNode
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
virtual void	calculate ()

	CEvaluationNodeChoice (const SubType &subType, const Data &data)

	CEvaluationNodeChoice (const CEvaluationNodeChoice &src)

virtual bool	compile (const CEvaluationTree *pTree)

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

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

virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const

virtual	~CEvaluationNodeChoice ()

Public Member Functions inherited from CEvaluationNode
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

	CEvaluationNode ()

	CEvaluationNode (const CEvaluationNode &src)

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

const Type &	getType () const

const C_FLOAT64 &	getValue () const

const C_FLOAT64 *	getValuePointer () 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	~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 *	fromAST (const ASTNode pASTNode, const std::vector< CEvaluationNode > &children)

Static Public Member Functions inherited from CEvaluationNode
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)

Private Member Functions
	CEvaluationNodeChoice ()

Private Attributes
CEvaluationNode *	mpFalse

CEvaluationNode *	mpIf

CEvaluationNode *	mpTrue

Additional Inherited Members
Protected Member Functions inherited from CEvaluationNode
	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 inherited from CEvaluationNode
class CEvaluationNode::CPrecedence	mPrecedence

const C_FLOAT64 *	mpValue

Type	mType

C_FLOAT64	mValue

Protected Attributes inherited from CCopasiNode< std::string >
Data	mData

Detailed Description

This is the class for nodes presenting operators used in an evaluation trees.

Definition at line 33 of file CEvaluationNodeChoice.h.

Member Enumeration Documentation

enum CEvaluationNodeChoice::SubType

Enumeration of possible node types.

Enumerator
INVALID
IF

Definition at line 39 of file CEvaluationNodeChoice.h.

   {
     INVALID = 0x00FFFFFF,
     IF = 0x00000000
   };

Constructor & Destructor Documentation

CEvaluationNodeChoice::CEvaluationNodeChoice ( )

private

Default constructor

Definition at line 22 of file CEvaluationNodeChoice.cpp.

References CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

Referenced by fromAST().

                                             :
   CEvaluationNode(CEvaluationNode::INVALID, ""),
   mpIf(NULL),
   mpTrue(NULL),
   mpFalse(NULL)
 {mPrecedence = PRECEDENCE_NUMBER;}

CEvaluationNodeChoice::CEvaluationNodeChoice	(	const SubType &	subType,
		const Data &	data
	)

Default constructor

Parameters

const	SubType & subType
const	Data & data

Definition at line 29 of file CEvaluationNodeChoice.cpp.

References fatalError, IF, CEvaluationNode::mPrecedence, and PRECEDENCE_FUNCTION.

                       :
   CEvaluationNode((Type)(CEvaluationNode::CHOICE | subType), data),
   mpIf(NULL),
   mpTrue(NULL),
   mpFalse(NULL)
 {
   switch (subType)
     {
       case IF:
         break;
 
       default:
         fatalError();
         break;
     }
 
   mPrecedence = PRECEDENCE_FUNCTION;
 }

CEvaluationNodeChoice::CEvaluationNodeChoice ( const CEvaluationNodeChoice & src )

Copy constructor

Parameters

const CEvaluationNodeChoice & src

Definition at line 49 of file CEvaluationNodeChoice.cpp.

                                                                              :
   CEvaluationNode(src),
   mpIf(src.mpIf),
   mpTrue(src.mpTrue),
   mpFalse(src.mpFalse)
 {}

CEvaluationNodeChoice::~CEvaluationNodeChoice ( )

virtual

Destructor

Definition at line 56 of file CEvaluationNodeChoice.cpp.

56 {}

Member Function Documentation

void CEvaluationNodeChoice::calculate ( void )

virtual

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

Reimplemented from CEvaluationNode.

Definition at line 58 of file CEvaluationNodeChoice.cpp.

References CEvaluationNode::getValue(), mpFalse, mpIf, mpTrue, and CEvaluationNode::mValue.

 {
   if (mpIf->getValue() > 0.5)
     {
       mValue = mpTrue->getValue();
     }
   else
     {
       mValue = mpFalse->getValue();
     }
 }

bool CEvaluationNodeChoice::compile ( const CEvaluationTree * pTree )

virtual

Compile a node;

Parameters

const CEvaluationTree * pTree

Returns: bool success;

Reimplemented from CEvaluationNode.

Definition at line 70 of file CEvaluationNodeChoice.cpp.

References CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getSibling(), mpFalse, mpIf, and mpTrue.

Referenced by getBerkeleyMadonnaString(), getCCodeString(), getDisplayString(), getInfix(), getMMLString(), and getXPPString().

 {
   mpIf = static_cast<CEvaluationNode *>(getChild());
 
   if (mpIf == NULL) return false;
 
   mpTrue = static_cast<CEvaluationNode *>(mpIf->getSibling());
 
   if (mpTrue == NULL) return false;
 
   mpFalse = static_cast<CEvaluationNode *>(mpTrue->getSibling());
 
   if (mpFalse == NULL) return false;
 
   return (mpFalse->getSibling() == NULL); // We must have exactly three children
 }

CEvaluationNode * CEvaluationNodeChoice::fromAST	(	const ASTNode *	pASTNode,
		const std::vector< CEvaluationNode * > &	children
	)

static

Creates a new CEvaluationNodeCall from an ASTNode and the given children

Parameters

const	ASTNode* pNode
const	std::vector< CEvaluationNode * > & children

Returns: CEvaluationNode * pCretedNode

Definition at line 133 of file CEvaluationNodeChoice.cpp.

References CEvaluationNodeConstant::_NaN, CCopasiNode< _Data >::addChild(), CEvaluationNodeChoice(), IF, INVALID, and CEvaluationNode::subType().

Referenced by CEvaluationTree::fromAST().

 {
   assert(pASTNode->getNumChildren() == children.size());
 
   size_t i = 0, iMax = children.size();
 
   // a piecewise function definition can have zero or more children.
   if (iMax == 0)
     {
       // create a NaN node
       return new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
     }
 
   if (iMax == 1)
     {
       // this must be the otherwise
       // It is not clearly specified what happens if there are no pieces, but
       // an otherwise. I would assume that in this case, the otherwise always
       // takes effect
 
       return children[0];
     }
 
   SubType subType;
   std::string data = "";
 
   switch (pASTNode->getType())
     {
       case AST_FUNCTION_PIECEWISE:
         subType = IF;
         data = "if";
         break;
 
       default:
         subType = INVALID;
         break;
     }
 
   CEvaluationNodeChoice * pNode = new CEvaluationNodeChoice(subType, data);
   CEvaluationNode * pCurrent = pNode;
 
   // We have at least 2 children
   while (i < iMax - 1)
     {
       // add the condition
       pCurrent->addChild(children[i + 1]);
       // the true value
       pCurrent->addChild(children[i]);
 
       i += 2;
 
       switch (iMax - i)
         {
           case 0:
             // We are missing the false value
             pCurrent->addChild(new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN"));
             break;
 
           case 1:
             // the false value
             pCurrent->addChild(children[i++]);
             break;
 
           default:
             // We have at least 2 more children
           {
             // create a new piecewise as the false value
             CEvaluationNode * pTmp = new CEvaluationNodeChoice(subType, data);
             pCurrent->addChild(pTmp);
             pCurrent = pTmp;
           }
           break;
         }
     }
 
   return pNode;
 }

std::string CEvaluationNodeChoice::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: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 115 of file CEvaluationNodeChoice.cpp.

References compile().

 {
   if (const_cast<CEvaluationNodeChoice *>(this)->compile(NULL))
     return "(if " + children[0] + " then " + children[1] + " else " + children[2] + ")";
   else
     return "@";
 }

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

virtual

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

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 106 of file CEvaluationNodeChoice.cpp.

References compile().

 {
   if (const_cast<CEvaluationNodeChoice *>(this)->compile(NULL))
     return "(" + children[0] + " ? " + children[1] + " : " + children[2] + ")";
   else
     return "@";
 }

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

virtual

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

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 97 of file CEvaluationNodeChoice.cpp.

References compile(), and CCopasiNode< std::string >::mData.

 {
   if (const_cast<CEvaluationNodeChoice *>(this)->compile(NULL))
     return mData + "(" + children[0] + "," + children[1] + "," + children[2] + ")";
   else
     return "@";
 }

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

virtual

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

Returns: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 88 of file CEvaluationNodeChoice.cpp.

References compile(), and CCopasiNode< std::string >::mData.

 {
   if (const_cast<CEvaluationNodeChoice *>(this)->compile(NULL))
     return mData + "(" + children[0] + "," + children[1] + "," + children[2] + ")";
   else
     return "@";
 }

std::string CEvaluationNodeChoice::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 from CEvaluationNode.

Definition at line 231 of file CEvaluationNodeChoice.cpp.

References compile().

 {
   std::ostringstream out;
 
   if (const_cast<CEvaluationNodeChoice *>(this)->compile(NULL))
     {
       out << "<mrow>" << std::endl;
       out << "<mo> {</mo>" << std::endl;
       out << "<mtable>" << std::endl;
 
       out << "<mtr>" << std::endl;
 
       out << "<mtd>" << std::endl;
       out << children[0];
       out << "<mo> , </mo>" << std::endl;
       out << "</mtd>" << std::endl;
 
       out << "<mtd>" << std::endl;
       out << children[1];
 
       out << "</mtd>" << std::endl;
 
       out << "</mtr>" << std::endl;
 
       out << "<mtr>" << std::endl;
 
       out << "<mtd>" << std::endl;
       out << "<mo> else, </mo>" << std::endl;
 
       out << "</mtd>" << std::endl;
       out << "<mtd>" << std::endl;
       out << children[2];
       out << "</mtd>" << std::endl;
 
       out << "</mtr>" << std::endl;
 
       out << "</mtable>" << std::endl;
       out << "</mrow>" << std::endl;
     }
 
   return out.str();
 }

std::string CEvaluationNodeChoice::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: const Data & value

Reimplemented from CEvaluationNode.

Definition at line 124 of file CEvaluationNodeChoice.cpp.

References compile().

 {
   if (const_cast<CEvaluationNodeChoice *>(this)->compile(NULL))
     return "if(" + children[0] + ")then(" + children[1] + ")else(" + children[2] + ")";
   else
     return "@"; //TODO
 }

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

virtual

Create a new ASTNode corresponding to this choice node.

Returns: ASTNode* return a pointer to the newly created node;

Reimplemented from CEvaluationNode.

Definition at line 211 of file CEvaluationNodeChoice.cpp.

References CCopasiNode< std::string >::getChild(), CCopasiNode< _Data >::getSibling(), and CEvaluationNode::toAST().

 {
   ASTNode* node = new ASTNode(AST_FUNCTION_PIECEWISE);
   const CEvaluationNode* child1 = dynamic_cast<const CEvaluationNode*>(this->getChild());
   assert(child1 != NULL);
   const CEvaluationNode* child2 = dynamic_cast<const CEvaluationNode*>(child1->getSibling());
   assert(child2 != NULL);
   const CEvaluationNode* child3 = dynamic_cast<const CEvaluationNode*>(child2->getSibling());
   assert(child3 != NULL);
   // the condition is the second child to the AST node but the first child in
   // the CEvaluationNode
   node->addChild(child2->toAST(pDataModel));
   node->addChild(child1->toAST(pDataModel));
   node->addChild(child3->toAST(pDataModel));
   return node;
 }

Member Data Documentation

CEvaluationNode* CEvaluationNodeChoice::mpFalse

private

Definition at line 148 of file CEvaluationNodeChoice.h.

Referenced by calculate(), and compile().

CEvaluationNode* CEvaluationNodeChoice::mpIf

private

Definition at line 146 of file CEvaluationNodeChoice.h.

Referenced by calculate(), and compile().

CEvaluationNode* CEvaluationNodeChoice::mpTrue

private

Definition at line 147 of file CEvaluationNodeChoice.h.

Referenced by calculate(), and compile().

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation