#include <CEvaluationNodeNumber.h>

Inheritance diagram for CEvaluationNodeNumber:

Collaboration diagram for CEvaluationNodeNumber:

Public Types
enum	SubType { INVALID = 0x00FFFFFF, DOUBLE = 0x00000000, INTEGER = 0x00000001, ENOTATION = 0x00000002, RATIONALE = 0x00000003 }

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
	CEvaluationNodeNumber (const SubType &subType, const Data &data)

	CEvaluationNodeNumber (const C_FLOAT64 &number)

	CEvaluationNodeNumber (const CEvaluationNodeNumber &src)

virtual std::string	getCCodeString (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

ASTNode *	toAST (const CCopasiDataModel *pDataModel) const

virtual	~CEvaluationNodeNumber ()

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

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	getDisplayString (const std::vector< std::string > &children) const

virtual std::string	getInfix (const std::vector< std::string > &children) 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	~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
	CEvaluationNodeNumber ()

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 class for nodes presenting numbers used in an evaluation trees

Definition at line 23 of file CEvaluationNodeNumber.h.

Member Enumeration Documentation

enum CEvaluationNodeNumber::SubType

Enumeration of possible node types.

Enumerator
INVALID
DOUBLE
INTEGER
ENOTATION
RATIONALE

Definition at line 29 of file CEvaluationNodeNumber.h.

   {
     INVALID = 0x00FFFFFF,
     DOUBLE = 0x00000000,
     INTEGER = 0x00000001,
     ENOTATION = 0x00000002,
     RATIONALE = 0x00000003
   };

Constructor & Destructor Documentation

CEvaluationNodeNumber::CEvaluationNodeNumber ( )

private

Default constructor

Definition at line 26 of file CEvaluationNodeNumber.cpp.

References CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

Referenced by fromAST().

                                             :
   CEvaluationNode(CEvaluationNode::INVALID, "")
 {mPrecedence = PRECEDENCE_NUMBER;}

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

Specific constructor

Parameters

const	SubType & subType
const	Data & data

Definition at line 30 of file CEvaluationNodeNumber.cpp.

References DOUBLE, ENOTATION, fatalError, INTEGER, INVALID, CCopasiNode< std::string >::mData, CEvaluationNode::mPrecedence, CEvaluationNode::mValue, PRECEDENCE_NUMBER, RATIONALE, and strToDouble().

                       :
   CEvaluationNode((Type)(CEvaluationNode::NUMBER | subType), data)
 {
   const char * end;
   const char * str = mData.c_str();
 
   switch (subType)
     {
       case DOUBLE:
       case INTEGER:
       case ENOTATION:
       {
         //mValue = strToDouble(str, NULL);
         std::istringstream in;
         in.imbue(std::locale::classic());
         in.str(str);
         in >> mValue;
       }
       break;
 
       case RATIONALE:
         str++; // Skip the '('
         mValue = strToDouble(str, &end);
         end++; // Skip the '/'
         mValue /= strToDouble(end, NULL);
         break;
 
       case INVALID:
         fatalError();
         break;
     }
 
   mPrecedence = PRECEDENCE_NUMBER;
 }

CEvaluationNodeNumber::CEvaluationNodeNumber ( const C_FLOAT64 & number )

Specific constructor

Parameters

const C_FLOAT64 & number

Definition at line 66 of file CEvaluationNodeNumber.cpp.

References CCopasiNode< std::string >::mData, CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

                                                                     :
   CEvaluationNode((Type)(CEvaluationNode::NUMBER | CEvaluationNodeNumber::DOUBLE), "")
 {
   std::ostringstream Data;
 
   Data.imbue(std::locale::classic());
   Data.precision(16);
   Data << number;
 
   mData = Data.str();
   mPrecedence = PRECEDENCE_NUMBER;
 }

CEvaluationNodeNumber::CEvaluationNodeNumber ( const CEvaluationNodeNumber & src )

Copy constructor

Parameters

const CEvaluationNodeNumber & src

Definition at line 79 of file CEvaluationNodeNumber.cpp.

                                                                              :
   CEvaluationNode(src)
 {}

CEvaluationNodeNumber::~CEvaluationNodeNumber ( )

virtual

Destructor

Definition at line 83 of file CEvaluationNodeNumber.cpp.

83 {}

Member Function Documentation

CEvaluationNode * CEvaluationNodeNumber::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 86 of file CEvaluationNodeNumber.cpp.

References CEvaluationNodeConstant::_INFINITY, CEvaluationNodeConstant::_NaN, abs, CCopasiNode< _Data >::addChild(), CEvaluationNodeNumber(), DOUBLE, ENOTATION, INTEGER, INVALID, CEvaluationNodeFunction::MINUS, RATIONALE, and CEvaluationNode::subType().

Referenced by CEvaluationTree::fromAST().

 {
   assert(pASTNode->getNumChildren() == children.size());
 
   std::stringstream ss;
   SubType subType;
   std::string data = "";
   CEvaluationNode* pNode = NULL;
 
   switch (pASTNode->getType())
     {
       case AST_INTEGER:
         subType = INTEGER;
 
         if (pASTNode->getInteger() < 0)
           {
             pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS, "-");
 
             ss << abs(pASTNode->getInteger());
             data = ss.str();
             pNode->addChild(new CEvaluationNodeNumber(subType, data));
           }
         else
           {
             ss << pASTNode->getInteger();
             data = ss.str();
             pNode = new CEvaluationNodeNumber(subType, data);
           }
 
         break;
 
       case AST_REAL:
         subType = DOUBLE;
 
         if (pASTNode->getReal() == (std::numeric_limits<C_FLOAT64>::infinity()))
           {
             pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "INFINITY");
           }
         else if (pASTNode->getReal() == (-std::numeric_limits<C_FLOAT64>::infinity()))
           {
             pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS, "-");
             pNode->addChild(new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "INFINITY"));
           }
         else if (isnan(pASTNode->getReal()))
           {
             pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
           }
         else if (pASTNode->getReal() < 0.0)
           {
             pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS, "-");
 
             ss << fabs(pASTNode->getReal());
             data = ss.str();
             pNode->addChild(new CEvaluationNodeNumber(subType, data));
           }
         else
           {
             ss << pASTNode->getReal();
             data = ss.str();
             pNode = new CEvaluationNodeNumber(subType, data);
           }
 
         break;
 
       case AST_REAL_E:
         subType = ENOTATION;
 
         if (pASTNode->getReal() == (std::numeric_limits<C_FLOAT64>::infinity()))
           {
             pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "INFINITY");
           }
         else if (pASTNode->getReal() == (-std::numeric_limits<C_FLOAT64>::infinity()))
           {
             pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS, "-");
             pNode->addChild(new CEvaluationNodeConstant(CEvaluationNodeConstant::_INFINITY, "INFINITY"));
           }
         else if (isnan(pASTNode->getReal()))
           {
             pNode = new CEvaluationNodeConstant(CEvaluationNodeConstant::_NaN, "NAN");
           }
         else if (pASTNode->getReal() < 0.0)
           {
             pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS, "-");
 
             ss << fabs(pASTNode->getReal());
             data = ss.str();
             pNode->addChild(new CEvaluationNodeNumber(subType, data));
           }
         else
           {
             ss << pASTNode->getReal();
             data = ss.str();
             pNode = new CEvaluationNodeNumber(subType, data);
           }
 
         break;
 
       case AST_RATIONAL:
         subType = RATIONALE;
 
         if (pASTNode->getReal() < 0.0) // getReal returns the value of the node
           {
             pNode = new CEvaluationNodeFunction(CEvaluationNodeFunction::MINUS, "-");
 
             ss << "(" << abs(pASTNode->getNumerator()) << "/" << abs(pASTNode->getDenominator()) << ")";
             data = ss.str();
             pNode->addChild(new CEvaluationNodeNumber(subType, data));
           }
         else
           {
             ss << "(" << pASTNode->getNumerator() << "/" << pASTNode->getDenominator() << ")";
             data = ss.str();
             pNode = new CEvaluationNodeNumber(subType, data);
           }
 
         break;
 
       default:
         subType = INVALID;
         break;
     }
 
   return pNode;
 }

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

virtual

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

Returns: string representing a double value

Reimplemented from CEvaluationNode.

Definition at line 270 of file CEvaluationNodeNumber.cpp.

References CEvaluationNode::getValue().

 {
   std::ostringstream out;
   out <<  std::setprecision(std::numeric_limits<double>::digits10 + 2) <<  std::fixed  << getValue();
   return out.str();
 }

std::string CEvaluationNodeNumber::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 258 of file CEvaluationNodeNumber.cpp.

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

 {
   std::ostringstream out;
 
   //or use mValue instead?
   out << "<mn>" << mData << "</mn>" << std::endl;
 
   return out.str();
 }

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

virtual

Create a new ASTNode corresponding to this NumberNode.

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

Reimplemented from CEvaluationNode.

Definition at line 211 of file CEvaluationNodeNumber.cpp.

References DOUBLE, ENOTATION, CEvaluationNode::getType(), CEvaluationNode::getValue(), INTEGER, INVALID, CCopasiNode< std::string >::mData, RATIONALE, strToDouble(), and CEvaluationNode::subType().

 {
   SubType subType = (SubType)CEvaluationNode::subType(this->getType());
   ASTNode* node = new ASTNode();
   double num1;
   double num2;
   const char * end;
   const char * str = mData.c_str();
 
   switch (subType)
     {
       case DOUBLE:
         node->setType(AST_REAL);
         node->setValue(this->getValue());
         break;
 
       case INTEGER:
         node->setType(AST_INTEGER);
         node->setValue((long)this->getValue());
         break;
 
       case ENOTATION:
         node->setType(AST_REAL_E);
         num2 = floor(log10(this->getValue()));
         num1 = pow(10.0, log10(this->getValue()) - num2);
         node->setValue(num1, (long)num2);
         break;
 
       case RATIONALE:
         node->setType(AST_RATIONAL);
         str++; // Skip the '('
         num1 = strToDouble(str, &end);
         end++; // Skip the '/'
         num2 = strToDouble(end, NULL);
         node->setValue((long)num1, (long)num2);
         break;
 
       case INVALID:
         break;
     }
 
   return node;
 }

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

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation