CEvaluationNodeConstant Class Reference

#include <CEvaluationNodeConstant.h>

Inheritance diagram for CEvaluationNodeConstant:

Collaboration diagram for CEvaluationNodeConstant:

Public Types
enum	SubType {   INVALID = 0x00FFFFFF, PI = 0x00000000, EXPONENTIALE = 0x00000001, TRUE = 0x00000002,   FALSE = 0x00000003, _INFINITY = 0x00000004, _NaN = 0x00000005 }
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
	CEvaluationNodeConstant (const SubType &subType, const Data &data)
	CEvaluationNodeConstant (const CEvaluationNodeConstant &src)
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	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 bool	isBoolean () const
virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const
virtual	~CEvaluationNodeConstant ()
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	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 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
	CEvaluationNodeConstant ()

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 Constants used in an evaluation trees

Definition at line 32 of file CEvaluationNodeConstant.h.

Member Enumeration Documentation

enum CEvaluationNodeConstant::SubType

Enumeration of possible node types.

Enumerator
INVALID
PI
EXPONENTIALE
TRUE
FALSE
_INFINITY
_NaN

Definition at line 38 of file CEvaluationNodeConstant.h.

  {
    INVALID = 0x00FFFFFF,
    PI = 0x00000000,
    EXPONENTIALE = 0x00000001,

#ifdef TRUE
# undef TRUE
#endif
    TRUE = 0x00000002,

#ifdef FALSE
# undef FALSE
#endif
    FALSE = 0x00000003,

    _INFINITY = 0x00000004,
    _NaN = 0x00000005
  };

Constructor & Destructor Documentation

CEvaluationNodeConstant::CEvaluationNodeConstant ( )

private

Default constructor

Definition at line 28 of file CEvaluationNodeConstant.cpp.

References CEvaluationNode::mPrecedence, and PRECEDENCE_NUMBER.

Referenced by fromAST().

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

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

Default constructor

Parameters

const	SubType & subType
const	Data & data

Definition at line 32 of file CEvaluationNodeConstant.cpp.

References _INFINITY, _NaN, EXPONENTIALE, FALSE, CEvaluationNode::mPrecedence, CEvaluationNode::mValue, PI, PRECEDENCE_NUMBER, and TRUE.

                      :
  CEvaluationNode((Type)(CEvaluationNode::CONSTANT | subType), data)
{
  switch ((SubType) subType)
    {
      case PI:
        mValue = M_PI;
        break;

      case EXPONENTIALE:
        mValue = M_E;
        break;

      case TRUE:
        mValue = 1.0;
        break;

      case FALSE:
        mValue = 0.0;
        break;

      case _INFINITY:
        mValue = std::numeric_limits<C_FLOAT64>::infinity();
        break;

      case _NaN:
        mValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
        break;

      default:
        mValue = std::numeric_limits<C_FLOAT64>::quiet_NaN();
        break;
    }

  mPrecedence = PRECEDENCE_NUMBER;
}

CEvaluationNodeConstant::CEvaluationNodeConstant

(

const CEvaluationNodeConstant &

src

)

Copy constructor

Parameters

const

CEvaluationNodeConstant & src

Definition at line 70 of file CEvaluationNodeConstant.cpp.

                                                                                   :
  CEvaluationNode(src)
{}

CEvaluationNodeConstant::~CEvaluationNodeConstant ( )

virtual

Destructor

Definition at line 74 of file CEvaluationNodeConstant.cpp.

{}

Member Function Documentation

CEvaluationNode * CEvaluationNodeConstant::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 180 of file CEvaluationNodeConstant.cpp.

References CEvaluationNodeConstant(), EXPONENTIALE, FALSE, INVALID, PI, CEvaluationNode::subType(), and TRUE.

Referenced by CEvaluationTree::fromAST().

{
  assert(pASTNode->getNumChildren() == children.size());
  assert(children.size() == 0);

  SubType subType;
  std::string data = "";

  switch (pASTNode->getType())
    {
      case AST_CONSTANT_E:
        subType = EXPONENTIALE;
        data = "EXPONENTIALE";
        break;

      case AST_CONSTANT_PI:
        subType = PI;
        data = "PI";
        break;

      case AST_CONSTANT_TRUE:
        subType = TRUE;
        data = "TRUE";
        break;

      case AST_CONSTANT_FALSE:
        subType = FALSE;
        data = "FALSE";
        break;

      default:
        subType = INVALID;
        break;
    }

  return new CEvaluationNodeConstant(subType, data);
}

std::string CEvaluationNodeConstant::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 118 of file CEvaluationNodeConstant.cpp.

References _INFINITY, _NaN, EXPONENTIALE, FALSE, CEvaluationNode::getType(), CEvaluationNode::mValue, PI, CEvaluationNode::subType(), and TRUE.

{
  std::ostringstream DisplayString;
  std::string data = "";

  SubType subType = (SubType)CEvaluationNode::subType(this->getType());

  switch (subType)
    {
      case PI:
        data = "PI";
        break;

      case EXPONENTIALE:
      case TRUE:
      case FALSE:
      case _INFINITY:
      case _NaN:
        DisplayString << mValue;
        data = DisplayString.str();
        break;

      default:
        data = "@";
        break;
    }

  return data;
}

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

virtual

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

Returns

const Data & value

Reimplemented from CEvaluationNode.

Definition at line 77 of file CEvaluationNodeConstant.cpp.

References _INFINITY, _NaN, EXPONENTIALE, FALSE, CEvaluationNode::getType(), PI, CEvaluationNode::subType(), and TRUE.

{
  std::string data = "";

  SubType subType = (SubType)CEvaluationNode::subType(this->getType());

  switch (subType)
    {
      case PI:
        data = "PI";
        break;

      case EXPONENTIALE:
        data = "EXPONENTIALE";
        break;

      case TRUE:
        data = "TRUE";
        break;

      case FALSE:
        data = "FALSE";
        break;

      case _INFINITY:
        data = "INFINITY";
        break;

      case _NaN:
        data = "NaN";
        break;

      default:
        data = "@";
        break;
    }

  return data;
}

std::string CEvaluationNodeConstant::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 273 of file CEvaluationNodeConstant.cpp.

References _INFINITY, _NaN, EXPONENTIALE, FALSE, CEvaluationNode::getType(), PI, CEvaluationNode::subType(), and TRUE.

{
  std::ostringstream out;

  std::string data = "";

  switch ((SubType)CEvaluationNode::subType(this->getType()))
    {
      case PI:
        data = "π";
        break;

      case EXPONENTIALE:
        data = "e";
        break;

      case TRUE:
        data = "true";
        break;

      case FALSE:
        data = "false";
        break;

      case _INFINITY:
        data = "∞";
        break;

      case _NaN:
        data = "NaN";
        break;

      default:
        data = "@";
        break;
    }

  out << "<mi>" << data << "</mi>" << std::endl;

  return out.str();
}

std::string CEvaluationNodeConstant::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 149 of file CEvaluationNodeConstant.cpp.

References _INFINITY, _NaN, EXPONENTIALE, FALSE, CEvaluationNode::getType(), CEvaluationNode::mValue, PI, CEvaluationNode::subType(), and TRUE.

{
  std::ostringstream DisplayString;
  std::string data = "";

  SubType subType = (SubType) CEvaluationNode::subType(this->getType());

  switch (subType)
    {
      case PI:
        data = "pi";
        break;

      case EXPONENTIALE:
      case TRUE:
      case FALSE:
      case _INFINITY:
      case _NaN:
        DisplayString << mValue;
        data = DisplayString.str();
        break;

      default:
        data = "@"; //TODO
        break;
    }

  return data;
}

bool CEvaluationNodeConstant::isBoolean ( ) const

virtual

Check whether the result is Boolean

Returns

bool isBoolean

Reimplemented from CEvaluationNode.

Definition at line 219 of file CEvaluationNodeConstant.cpp.

References FALSE, CEvaluationNode::mType, CEvaluationNode::subType(), and TRUE.

{
  switch ((SubType) CEvaluationNode::subType(mType))
    {
      case TRUE:
      case FALSE:
        return true;

      default:
        return false;
    }
}

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

virtual

Create a new ASTNode corresponding to this ConstantNode.

Returns

ASTNode* return a pointer to the newly created node;

Reimplemented from CEvaluationNode.

Definition at line 232 of file CEvaluationNodeConstant.cpp.

References _INFINITY, _NaN, EXPONENTIALE, FALSE, CEvaluationNode::getType(), INVALID, PI, CEvaluationNode::subType(), and TRUE.

{
  SubType subType = (SubType)CEvaluationNode::subType(this->getType());
  ASTNode* node = new ASTNode();

  switch (subType)
    {
      case PI:
        node->setType(AST_CONSTANT_PI);
        break;

      case EXPONENTIALE:
        node->setType(AST_CONSTANT_E);
        break;

      case TRUE:
        node->setType(AST_CONSTANT_TRUE);
        break;

      case FALSE:
        node->setType(AST_CONSTANT_FALSE);
        break;

      case _INFINITY:
        node->setType(AST_REAL);
        node->setValue(std::numeric_limits<C_FLOAT64>::infinity());
        break;

      case _NaN:
      case INVALID:
        node->setType(AST_REAL);
        node->setValue(std::numeric_limits<C_FLOAT64>::quiet_NaN());
        break;
    }

  return node;
}

---

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

• CEvaluationNodeConstant.h
• CEvaluationNodeConstant.cpp