The class for handling a chemical kinetic function. More...

#include <CFunction.h>

Inheritance diagram for CFunction:

Collaboration diagram for CFunction:

Public Member Functions
bool	addVariable (const std::string &name, CFunctionParameter::Role usage=CFunctionParameter::VARIABLE, const CFunctionParameter::DataType &type=CFunctionParameter::FLOAT64)

virtual const C_FLOAT64 &	calcValue (const CCallParameters< C_FLOAT64 > &callParameters)

	CFunction (const std::string &name="NoName", const CCopasiContainer *pParent=NULL, const Type &type=Function)

	CFunction (const CFunction &src, const CCopasiContainer *pParent=NULL)

CFunction *	createCopy () const

void	createListOfParametersForMathML (std::vector< std::vector< std::string > > &env)

virtual bool	dependsOn (const C_FLOAT64 *parameter, const CCallParameters< C_FLOAT64 > &callParameters) const

const std::string &	getKey () const

const std::string &	getSBMLId () const

virtual size_t	getVariableIndex (const std::string &name) const

CFunctionParameters &	getVariables ()

const CFunctionParameters &	getVariables () const

virtual const C_FLOAT64 &	getVariableValue (const size_t &index) const

const TriLogic &	isReversible () const

bool	isSuitable (const size_t noSubstrates, const size_t noProducts, const TriLogic reversible)

virtual void	load (CReadConfig &configBuffer, CReadConfig::Mode mode=CReadConfig::SEARCH)

bool	operator== (const CFunction &rhs) const

virtual bool	setInfix (const std::string &infix)

virtual bool	setInfix (const std::string &infix, bool compile)

void	setReversible (const TriLogic &reversible)

void	setSBMLId (const std::string &id)

std::pair< CFunction , CFunction >	splitFunction (const CEvaluationNode *node, const std::string &name1, const std::string &name2) const

virtual void	writeMathML (std::ostream &out, size_t l=0) const

virtual std::string	writeMathML (const std::vector< std::vector< std::string > > &variables, bool expand=true, bool fullExpand=true) const

virtual	~CFunction ()

Public Member Functions inherited from CEvaluationTree
bool	calls (std::set< std::string > &list) const

	CEvaluationTree (const std::string &name="NoName", const CCopasiContainer *pParent=NULL, const Type &type=Function)

	CEvaluationTree (const CEvaluationTree &src, const CCopasiContainer *pParent=NULL)

virtual bool	compile ()

bool	dependsOnTree (const std::string &name) const

CCopasiObject::DataObjectSet	getDeletedObjects () const

std::string::size_type	getErrorPosition () const

const std::string &	getInfix () const

const std::vector < CEvaluationNode * > &	getNodeList () const

CEvaluationNode *	getRoot ()

const CEvaluationNode *	getRoot () const

const CEvaluationTree::Type &	getType () const

bool	hasCircularDependency () const

bool	hasDiscontinuity () const

bool	isBoolean () const

bool	isUsable () const

bool	operator== (const CEvaluationTree &rhs) const

virtual bool	setRoot (CEvaluationNode *pRootNode)

bool	setTree (const ASTNode &pRootNode)

virtual ASTNode *	toAST (const CCopasiDataModel *pDataModel) const

bool	updateTree ()

virtual	~CEvaluationTree ()

Public Member Functions inherited from CCopasiContainer
virtual bool	add (CCopasiObject *pObject, const bool &adopt=true)

	CCopasiContainer (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=CCopasiObject::Container)

	CCopasiContainer (const CCopasiContainer &src, const CCopasiContainer *pParent=NULL)

virtual std::string	getChildObjectUnits (const CCopasiObject *pObject) const

virtual const CObjectInterface *	getObject (const CCopasiObjectName &cn) const

virtual const objectMap &	getObjects () const

virtual std::string	getUnits () const

virtual const CCopasiObject *	getValueObject () const

virtual bool	remove (CCopasiObject *pObject)

virtual	~CCopasiContainer ()

Public Member Functions inherited from CCopasiObject
void	addDirectDependency (const CCopasiObject *pObject)

	CCopasiObject (const CCopasiObject &src, const CCopasiContainer *pParent=NULL)

void	clearDirectDependencies ()

void	clearRefresh ()

bool	dependsOn (DataObjectSet candidates, const DataObjectSet &context=DataObjectSet()) const

void	getAllDependencies (DataObjectSet &dependencies, const DataObjectSet &context) const

virtual CCopasiObjectName	getCN () const

virtual const DataObjectSet &	getDirectDependencies (const DataObjectSet &context=DataObjectSet()) const

CCopasiContainer *	getObjectAncestor (const std::string &type) const

CCopasiDataModel *	getObjectDataModel ()

const CCopasiDataModel *	getObjectDataModel () const

virtual std::string	getObjectDisplayName (bool regular=true, bool richtext=false) const

const std::string &	getObjectName () const

CCopasiContainer *	getObjectParent () const

const std::string &	getObjectType () const

virtual const CObjectInterface::ObjectSet &	getPrerequisites () const

virtual Refresh *	getRefresh () const

UpdateMethod *	getUpdateMethod () const

virtual void *	getValuePointer () const

bool	hasCircularDependencies (DataObjectSet &candidates, DataObjectSet &verified, const DataObjectSet &context) const

bool	hasUpdateMethod () const

bool	isArray () const

bool	isContainer () const

bool	isDataModel () const

bool	isMatrix () const

bool	isNameVector () const

bool	isNonUniqueName () const

virtual bool	isPrerequisiteForContext (const CObjectInterface *pObject, const CMath::SimulationContextFlag &context, const CObjectInterface::ObjectSet &changedObjects) const

bool	isReference () const

bool	isRoot () const

bool	isSeparator () const

bool	isStaticString () const

bool	isValueBool () const

bool	isValueDbl () const

bool	isValueInt () const

bool	isValueInt64 () const

bool	isValueString () const

bool	isVector () const

virtual bool	mustBeDeleted (const DataObjectSet &deletedObjects) const

virtual void	print (std::ostream *ostream) const

void	removeDirectDependency (const CCopasiObject *pObject)

void	setDirectDependencies (const DataObjectSet &directDependencies)

bool	setObjectName (const std::string &name)

virtual bool	setObjectParent (const CCopasiContainer *pParent)

void	setObjectValue (const C_FLOAT64 &value)

void	setObjectValue (const C_INT32 &value)

void	setObjectValue (const bool &value)

template<class CType >
void	setRefresh (CType pType, void(CType::method)(void))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_FLOAT64 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const C_INT32 &))

template<class CType >
void	setUpdateMethod (CType pType, void(CType::method)(const bool &))

virtual	~CCopasiObject ()

Public Member Functions inherited from CObjectInterface
	CObjectInterface ()

virtual	~CObjectInterface ()

Public Member Functions inherited from CAnnotation
bool	addUnsupportedAnnotation (const std::string &name, const std::string &xml)

	CAnnotation ()

	CAnnotation (const CAnnotation &src)

const std::string &	getMiriamAnnotation () const

const std::string &	getNotes () const

UnsupportedAnnotation &	getUnsupportedAnnotations ()

const UnsupportedAnnotation &	getUnsupportedAnnotations () const

bool	operator== (const CAnnotation &rhs) const

bool	removeUnsupportedAnnotation (const std::string &name)

bool	replaceUnsupportedAnnotation (const std::string &name, const std::string &xml)

void	setMiriamAnnotation (const std::string &miriamAnnotation, const std::string &newId, const std::string &oldId)

void	setNotes (const std::string &notes)

virtual	~CAnnotation ()

Static Public Member Functions
static bool	completeFunctionList (std::vector< CFunction * > &list, const size_t &added=0)

Static Public Member Functions inherited from CEvaluationTree
static CEvaluationTree *	copy (const CEvaluationTree &src)

static CEvaluationTree *	create (CEvaluationTree::Type type)

static CEvaluationNode *	fromAST (const ASTNode *pASTNode)

Static Public Member Functions inherited from CCopasiObject
static std::vector< Refresh * >	buildUpdateSequence (const DataObjectSet &objects, const DataObjectSet &uptoDateObjects, const DataObjectSet &context=DataObjectSet())

static void	setRenameHandler (CRenameHandler *rh)

Static Public Member Functions inherited from CAnnotation
static CAnnotation *	castObject (CCopasiObject *pObject)

static const CAnnotation *	castObject (const CCopasiObject *pObject)

Protected Member Functions
bool	initVariables ()

Protected Member Functions inherited from CEvaluationTree
void	buildCalculationSequence ()

void	calculate ()

bool	compileNodes ()

bool	parse ()

void	setType (const CEvaluationTree::Type &type)

Protected Member Functions inherited from CCopasiContainer
template<class CType >
CCopasiObject *	addMatrixReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addObjectReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

template<class CType >
CCopasiObject *	addVectorReference (const std::string &name, CType &reference, const unsigned C_INT32 &flag=0)

void	initObjects ()

Protected Member Functions inherited from CCopasiObject
	CCopasiObject ()

	CCopasiObject (const std::string &name, const CCopasiContainer *pParent=NULL, const std::string &type="CN", const unsigned C_INT32 &flag=0)

Private Attributes
CCallParameters< C_FLOAT64 > ::const_iterator	mCallParametersBegin

TriLogic	mReversible

std::string	mSBMLId

CFunctionParameters	mVariables

Friends
std::ostream &	operator<< (std::ostream &os, const CFunction &f)

Additional Inherited Members
Public Types inherited from CEvaluationTree
enum	Type { Function = 0, MassAction, PreDefined, UserDefined, Expression, MathExpression }

Public Types inherited from CCopasiContainer
typedef std::multimap < std::string, CCopasiObject * >	objectMap

Public Types inherited from CCopasiObject
typedef std::set< const CCopasiObject * >	DataObjectSet

typedef std::vector< Refresh * >	DataUpdateSequence

Public Types inherited from CObjectInterface
typedef std::set< const CObjectInterface * >	ObjectSet

typedef std::vector < CObjectInterface * >	UpdateSequence

Public Types inherited from CAnnotation
typedef std::map< std::string, std::string >	UnsupportedAnnotation

Static Public Attributes inherited from CEvaluationTree
static const std::string	TypeName []

static const char *	XMLType []

Static Public Attributes inherited from CCopasiContainer
static const std::vector < CCopasiContainer * >	EmptyList

Protected Types inherited from CCopasiObject
enum	Flag { Container = 0x1, Vector = 0x2, Matrix = 0x4, NameVector = 0x8, Reference = 0x10, ValueBool = 0x20, ValueInt = 0x40, ValueInt64 = 0x80, ValueDbl = 0x100, NonUniqueName = 0x200, StaticString = 0x400, ValueString = 0x800, Separator = 0x1000, ModelEntity = 0x2000, Array = 0x4000, DataModel = 0x8000, Root = 0x10000, Gui = 0x20000 }

Protected Attributes inherited from CEvaluationTree
std::vector< CEvaluationNode * >	mCalculationSequence

std::string	mInfix

std::vector< CEvaluationNode * > *	mpNodeList

CEvaluationNode *	mpRoot

CEvaluationTree::Type	mType

bool	mUsable

C_FLOAT64	mValue

Protected Attributes inherited from CCopasiContainer
objectMap	mObjects

Protected Attributes inherited from CAnnotation
std::string	mKey

Static Protected Attributes inherited from CCopasiObject
static CRenameHandler *	smpRenameHandler = NULL

Detailed Description

The class for handling a chemical kinetic function.

This class is designed to handle all about a given chemical kinetic function from editing and displaying (with help of MathML) the function to calculating the function value.

Definition at line 29 of file CFunction.h.

Constructor & Destructor Documentation

CFunction::CFunction	(	const std::string &	name = `"NoName"`,
		const CCopasiContainer *	pParent = `NULL`,
		const Type &	type = `Function`
	)

Default constructor

Parameters

const	std::string & name (default: "NoName")
const	CEvaluationTree::Type & type (default: Function)
const	CCopasiContainer * pParent (default: NULL)

Definition at line 25 of file CFunction.cpp.

References CKeyFactory::add(), CCopasiRootContainer::getKeyFactory(), and CAnnotation::mKey.

Referenced by createCopy(), and splitFunction().

                                                       :
   CEvaluationTree(name, pParent, type),
   CAnnotation(),
   mSBMLId(""),
   mVariables("Function Parameters", this),
   mCallParametersBegin(),
   mReversible(TriUnspecified)
 {
   mKey = CCopasiRootContainer::getKeyFactory()->add("Function", this);
 }

CFunction::CFunction	(	const CFunction &	src,
		const CCopasiContainer *	pParent = `NULL`
	)

Copy constructor

Parameters

const	CFunction & src
const	CCopasiContainer * pParent (default: NULL)

Definition at line 38 of file CFunction.cpp.

References CKeyFactory::add(), CEvaluationTree::compile(), CCopasiRootContainer::getKeyFactory(), CAnnotation::getMiriamAnnotation(), CAnnotation::mKey, and CAnnotation::setMiriamAnnotation().

                                                       :
   CEvaluationTree(src, pParent),
   CAnnotation(src),
   mSBMLId(src.mSBMLId),
   mVariables(src.mVariables, this),
   mCallParametersBegin(src.mCallParametersBegin),
   mReversible(src.mReversible)
 {
   mKey = CCopasiRootContainer::getKeyFactory()->add("Function", this);
 
   setMiriamAnnotation(src.getMiriamAnnotation(), mKey, src.mKey);
   compile();
 }

CFunction::~CFunction ( )

virtual

Destructor

Definition at line 53 of file CFunction.cpp.

References CCopasiRootContainer::getKeyFactory(), CAnnotation::mKey, and CKeyFactory::remove().

 {
   CCopasiRootContainer::getKeyFactory()->remove(mKey);
 }

Member Function Documentation

bool CFunction::addVariable	(	const std::string &	name,
		CFunctionParameter::Role	usage = `CFunctionParameter::VARIABLE`,
		const CFunctionParameter::DataType &	type = `CFunctionParameter::FLOAT64`
	)

Function to add the description of a variable.

Parameters

const	string & name
const	string & usage (Default: VARIABLE)
const	CFunctionParameters::DataType & type (Default: value)

Returns: bool success

Definition at line 154 of file CFunction.cpp.

References CFunctionParameters::add(), and mVariables.

Referenced by SBMLImporter::createCFunctionFromFunctionTree(), and CReaction::setFunctionFromExpressionTree().

157 {return mVariables.add(name, type, usage);}

CFunction::mVariables

CFunctionParameters mVariables

Definition: CFunction.h:210

CFunctionParameters::add

void add(const CFunctionParameter &parameter)

Definition: CFunctionParameters.cpp:54

const C_FLOAT64 & CFunction::calcValue ( const CCallParameters< C_FLOAT64 > & callParameters )

virtual

Function to calculate the value of the function

Parameters

const CCallParameters<C_FLOAT64> & callParameters

Returns: const C_FLOAT64 & result

Reimplemented in CMassAction.

Definition at line 159 of file CFunction.cpp.

References CCallParameters< Type >::begin(), CEvaluationTree::calculate(), mCallParametersBegin, and CEvaluationTree::mValue.

Referenced by CEvaluationNodeCall::calculate(), CReaction::calculate(), CReaction::calculatePartialDerivative(), and main().

 {
   mCallParametersBegin = callParameters.begin();
 
   calculate();
 
   return mValue;
 }

bool CFunction::completeFunctionList	(	std::vector< CFunction * > &	list,
		const size_t &	added = `0`
	)

static

Complete the list of evaluation tree such that all called trees are includes.

Parameters

std::vector<	CFunction * > & list
const	size_t & added (Default: list.size())

Returns: bool success

Definition at line 303 of file CFunction.cpp.

References C_INVALID_INDEX, CEvaluationNode::CALL, CCopasiRootContainer::getFunctionList(), CCopasiVectorN< CType >::getIndex(), CEvaluationTree::getNodeList(), and CFunctionDB::loadedFunctions().

Referenced by CFunctionDB::getUsedFunctions().

 {
   unsigned Added = 0;
 
   size_t i, imax = list.size();
   size_t Index;
 
   CEvaluationTree * pTree;
   std::vector< CEvaluationNode * >::const_iterator it;
   std::vector< CEvaluationNode * >::const_iterator end;
 
   CCopasiVectorN< CFunction > & Functions =
     CCopasiRootContainer::getFunctionList()->loadedFunctions();
 
   for (i = (added) ? imax - added : 0; i < imax; i++)
     {
       pTree = list[i];
 
       for (it = pTree->getNodeList().begin(), end = pTree->getNodeList().end(); it != end; ++it)
         {
           if (((*it)->getType() & 0xFF000000) == CEvaluationNode::CALL &&
               (Index = Functions.getIndex((*it)->getData())) != C_INVALID_INDEX &&
               list.end() == std::find(list.begin(), list.end(), Functions[Index]))
             {
               list.push_back(Functions[Index]);
               Added++;
             }
         }
     }
 
   if (Added)
     return completeFunctionList(list, Added);
   else
     return true;
 }

CFunction * CFunction::createCopy ( ) const

Function to duplicate itself

Definition at line 428 of file CFunction.cpp.

References CFunction(), CEvaluationNode::copyBranch(), CEvaluationTree::mpRoot, mReversible, and CEvaluationTree::setRoot().

 {
   CFunction* newFunction = new CFunction();
 
   //newFunction->mVariables = this->mVariables; //WRONG! only shallow copy!!
   newFunction->mReversible = this->mReversible;
 
   if (this->mpRoot)
     newFunction->setRoot(this->mpRoot->copyBranch());
 
   //newFunction->mInfix = newFunction->mpRoot->getInfix();
 
   return newFunction;
 }

void CFunction::createListOfParametersForMathML ( std::vector< std::vector< std::string > > & env )

Function to create a list of the names of the function parameters in MathML format. This list can be passed as the env argument to the writeMathML() method.

Parameters

std::vector<std::vector<std::string> > & env

Definition at line 340 of file CFunction.cpp.

References CMathMl::fixName(), CCopasiObject::getObjectName(), getVariables(), and CFunctionParameters::size().

Referenced by CQExpressionWidget::writeMathML().

 {
   size_t i, imax = getVariables().size();
 
   env.clear();
   env.resize(imax);
 
   for (i = 0; i < imax; ++i)
     {
       env[i].push_back("<mi>" + CMathMl::fixName(getVariables()[i]->getObjectName()) + "</mi>");
     }
 }

bool CFunction::dependsOn	(	const C_FLOAT64 *	parameter,
		const CCallParameters< C_FLOAT64 > &	callParameters
	)		const

virtual

Function to return whether it depends on the given parameter

Parameters

const	void * parameter
const	CCallParameters<C_FLOAT64> & callParameters
bool	dependsOn

Reimplemented in CMassAction.

Definition at line 168 of file CFunction.cpp.

References CCallParameters< Type >::begin(), and CCallParameters< Type >::end().

Referenced by CReaction::calculatePartialDerivative().

 {
   CCallParameters<C_FLOAT64>::const_iterator it = callParameters.begin();
   CCallParameters<C_FLOAT64>::const_iterator end = callParameters.end();
 
   while (it != end && parameter != it->value) it++;
 
   if (it != end)
     return true;
   else
     return false;
 }

const std::string & CFunction::getKey ( ) const

virtual

Retrieves the key of the EvaluationTree

Returns: const std::string & key

Reimplemented from CAnnotation.

Definition at line 58 of file CFunction.cpp.

References CAnnotation::getKey().

Referenced by CCopasiXMLParser::FunctionElement::end(), CODEExporterC::exportSingleFunction(), SBMLImporter::importMIRIAM(), CQFunctionDM::insertRows(), CODEExporterC::KineticFunction2ODEmember(), CODEExporterC::preprocess(), CCopasiXML::saveFunctionList(), CCopasiXML::saveModel(), CODEExporterC::setExportNameOfFunction(), FunctionWidget1::slotBtnNew(), ReactionsWidget1::slotGotoFunction(), ReactionsWidget1::slotNewFunction(), and CSBMLExporter::updateMIRIAMAnnotation().

 {
   return CAnnotation::getKey();
 }

const std::string & CFunction::getSBMLId ( ) const

Returns a reference to the SBML Id.

Definition at line 68 of file CFunction.cpp.

References mSBMLId.

Referenced by CSBMLExporter::collectIds(), SBMLImporter::createCFunctionFromFunctionDefinition(), SBMLImporter::createCModelFromSBMLDocument(), CCopasiXML::saveFunctionList(), CSBMLExporter::setFunctionSBMLIds(), and CEvaluationNodeCall::toAST().

 {
   return this->mSBMLId;
 }

size_t CFunction::getVariableIndex ( const std::string & name ) const

virtual

Function to retrieve the index to the value of the named variable.

Parameters

const std::string & name

Returns: size_t index

Reimplemented from CEvaluationTree.

Definition at line 133 of file CFunction.cpp.

References CFunctionParameters::findParameterByName(), and mVariables.

Referenced by CODEExporter::exportKineticFunction(), and CODEExporter::exportSingleFunction().

 {
   CFunctionParameter::DataType VariableType;
   return mVariables.findParameterByName(name, VariableType);
 }

CFunctionParameters & CFunction::getVariables ( )

Function to retrive the definition of the parameters

Returns: CFunctionParameters & variables

Definition at line 148 of file CFunction.cpp.

References mVariables.

Referenced by SBMLImporter::areEqualFunctions(), CFunctionAnalyzer::checkKineticFunction(), CEvaluationNodeCall::compile(), FunctionWidget1::copyFunctionContentsToFunction(), SBMLImporter::createCReactionFromReaction(), SBMLImporter::createExpressionFromFunction(), CSBMLExporter::createKineticExpression(), createListOfParametersForMathML(), CKinFunction::createParameters(), SBMLImporter::doMapping(), CCopasiXMLParser::ListOfParameterDescriptionsElement::end(), CCopasiXMLParser::FunctionElement::end(), CFunctionAnalyzer::evaluateNode(), expand_function_call(), CODEExporter::exportKineticFunction(), CODEExporterC::exportSingleFunction(), SBMLImporter::findCorrespondingFunction(), CFindDimensions::findDimensions(), FunctionWidget1::functionParametersChanged(), CReactionInterface::getDeletedParameters(), CReactionInterface::initFromReaction(), CReactionInterface::initMapping(), FunctionWidget1::loadParameterTable(), FunctionWidget1::loadUsageTable(), CCopasiXML::saveFunctionList(), SBMLImporter::setCorrectUsage(), CReaction::setFunction(), CReaction::setFunctionFromExpressionTree(), CMassAction::setInfix(), CFindDimensions::setupDimensions(), FunctionWidget1::slotTableValueChanged(), splitFunction(), CCopasiXMLParser::ParameterDescriptionElement::start(), test_compare_utilities::test_copasi_function_expansion(), test000078::test_l2v4_import_unordered_functions(), CReaction::variable2object(), CReactionInterface::writeBackToReaction(), and writeMathML().

149 {return mVariables;}

CFunction::mVariables

CFunctionParameters mVariables

Definition: CFunction.h:210

const CFunctionParameters & CFunction::getVariables ( ) const

Function to retrive the definition of the parameters

Returns: const CFunctionParameters & variables

Definition at line 151 of file CFunction.cpp.

References mVariables.

152 {return mVariables;}

CFunction::mVariables

CFunctionParameters mVariables

Definition: CFunction.h:210

const C_FLOAT64 & CFunction::getVariableValue ( const size_t & index ) const

virtual

Function to retrieve the value of the indexed variable.

Note this function is only usable during calcValue, since the values of the call parameters are only defined during that time.

Parameters

const size_t & index

Returns: const C_FLOAT64 & variableValue

Reimplemented from CEvaluationTree.

Definition at line 139 of file CFunction.cpp.

References mCallParametersBegin.

140 {return *(mCallParametersBegin + index)->value;}

CFunction::mCallParametersBegin

CCallParameters< C_FLOAT64 >::const_iterator mCallParametersBegin

Definition: CFunction.h:215

bool CFunction::initVariables ( )

protected

Function to initialize the parameters

Returns: bool success

Definition at line 219 of file CFunction.cpp.

References CFunctionParameters::add(), C_INVALID_INDEX, CFunctionParameters::findParameterByName(), CFunctionParameter::FLOAT64, CCopasiObject::getObjectName(), CEvaluationTree::mInfix, CEvaluationTree::mpNodeList, mVariables, CFunctionParameters::remove(), CFunctionParameters::size(), CEvaluationNode::type(), CEvaluationNode::VARIABLE, and CFunctionParameter::VARIABLE.

Referenced by setInfix(), and splitFunction().

 {
   if (mpNodeList == NULL && mInfix != "") return false;
 
   CFunctionParameters NewVariables;
 
   if (mInfix != "")
     {
       //first add all variables to the existing list
       std::vector< CEvaluationNode * >::iterator it = mpNodeList->begin();
       std::vector< CEvaluationNode * >::iterator end = mpNodeList->end();
 
       for (; it != end; ++it)
         if (CEvaluationNode::type((*it)->getType()) == CEvaluationNode::VARIABLE)
           {
             mVariables.add((*it)->getData(),
                            CFunctionParameter::FLOAT64,
                            CFunctionParameter::VARIABLE);
             NewVariables.add((*it)->getData(),
                              CFunctionParameter::FLOAT64,
                              CFunctionParameter::VARIABLE);
           }
     }
 
   //now remove all variables that are not in the tree anymore
   CFunctionParameter::DataType Type;
   size_t i;
 
   for (i = mVariables.size() - 1; i != C_INVALID_INDEX; i--)
     if (NewVariables.findParameterByName(mVariables[i]->getObjectName(), Type) == C_INVALID_INDEX)
       mVariables.remove(mVariables[i]->getObjectName());
 
   return true;
 }

const TriLogic & CFunction::isReversible ( ) const

Function to retrieve whether it is reversible.

Definition at line 145 of file CFunction.cpp.

References mReversible.

Referenced by CMassAction::calcValue(), CFunctionAnalyzer::checkKineticFunction(), CModelAnalyzer::checkReaction(), CSBMLExporter::createKineticExpression(), CSBMLExporter::createKineticLaw(), CMassAction::dependsOn(), CODEExporter::exportKineticFunction(), isSuitable(), CODEExporterC::KineticFunction2ODEmember(), FunctionWidget1::loadFromFunction(), CCopasiXML::saveFunctionList(), FunctionWidget1::saveToFunction(), CReaction::setFunctionFromExpressionTree(), CMassAction::setInfix(), and CMassAction::writeMathML().

146 {return mReversible;}

CFunction::mReversible

TriLogic mReversible

Definition: CFunction.h:220

bool CFunction::isSuitable	(	const size_t	noSubstrates,
		const size_t	noProducts,
		const TriLogic	reversible
	)

Function to determine whether it is suitable for a reaction with the given number of substrates and products and reversibility

Definition at line 254 of file CFunction.cpp.

References C_INVALID_INDEX, CFunctionParameters::getNumberOfParametersByUsage(), isReversible(), CFunctionParameters::isVector(), mVariables, CFunctionParameter::PRODUCT, CFunctionParameter::SUBSTRATE, TriTrue, TriUnspecified, and CFunctionParameter::VARIABLE.

Referenced by SBMLImporter::createCReactionFromReaction(), and CFunctionDB::suitableFunctions().

 {
   // A function which in neither restricted to reversible nor to irreversible reactions is always suitable
   // independent from the number of substrates or products
   if (isReversible() == TriUnspecified)
     return true;
 
   //first reversibility:
   if (reversible != isReversible())
     return false;
 
   //check substrates
   if (mVariables.isVector(CFunctionParameter::SUBSTRATE))
     {
       if (noSubstrates == 0 || noSubstrates == C_INVALID_INDEX)
         return false;
     }
   else //is no vector
     {
       if (mVariables.getNumberOfParametersByUsage(CFunctionParameter::SUBSTRATE) != noSubstrates &&
           noSubstrates != C_INVALID_INDEX)
         return false;
     }
 
   //check products
   if (reversible == TriTrue)
     {
       if (mVariables.isVector(CFunctionParameter::PRODUCT))
         {
           if (noProducts == 0 || noProducts == C_INVALID_INDEX)
             return false;
         }
       else //is no vector
         {
           if (mVariables.getNumberOfParametersByUsage(CFunctionParameter::PRODUCT) != noProducts &&
               noProducts != C_INVALID_INDEX)
             return false;
         }
     }
 
   //no VARIABLE variables allowed for kinetic functions
   if (mVariables.getNumberOfParametersByUsage(CFunctionParameter::VARIABLE) != 0)
     return false;
 
   return true;
 }

void CFunction::load	(	CReadConfig &	configBuffer,
		CReadConfig::Mode	mode = `CReadConfig::SEARCH`
	)

virtual

Function to load an object with data coming from a CReadConfig object. (CReadConfig object reads an input stream)

Parameters

CReadConfig &	configBuffer
CReadConfig::Mode	mode (default: CReadConfig::SEARCH)

Returns: Fail

Definition at line 182 of file CFunction.cpp.

References C_INT32, fatalError, CReadConfig::getVariable(), mReversible, CReadConfig::SEARCH, setInfix(), CCopasiObject::setObjectName(), CEvaluationTree::setType(), and CEvaluationTree::UserDefined.

Referenced by CFunctionDB::load().

 {
   //  cleanup();
 
   C_INT32 Type;
 
   mode = CReadConfig::SEARCH;
   configBuffer.getVariable("User-defined", "C_INT32", &Type, mode);
 
   switch (Type)
     {
       case 1:
         setType(UserDefined);
         break;
 
       default:
         fatalError();
         break;
     }
 
   configBuffer.getVariable("Reversible", "C_INT32", &mReversible);
 
   mode = CReadConfig::SEARCH;
 
   std::string tmp;
   configBuffer.getVariable("FunctionName", "string", &tmp, mode);
   setObjectName(tmp);
 
   configBuffer.getVariable("Description", "string", &tmp);
   setInfix(tmp);
 
   // For older file version the parameters have to be build from information
   // dependend on the function type. Luckilly, only user defined functions are
   // the only ones occuring in those files.
 }

bool CFunction::operator== ( const CFunction & rhs ) const

Comparison operator

Parameters

const CFunction & rhs

Returns: bool equal

Definition at line 119 of file CFunction.cpp.

References mVariables.

 {
   if (!(*static_cast< const CEvaluationTree * >(this) == rhs))
     return false;
 
   if (!(*static_cast< const CAnnotation * >(this) == rhs))
     return false;
 
   if (!(mVariables == rhs.mVariables))
     return false;
 
   return true;
 }

bool CFunction::setInfix ( const std::string & infix )

virtual

Function to set the infix description of the tree and compile it.

Parameters

const std::string & infix

Returns: bool success

Reimplemented from CEvaluationTree.

Reimplemented in CMassAction.

Definition at line 73 of file CFunction.cpp.

Referenced by CMathEventN::CTrigger::allocate(), FunctionWidget1::copyFunctionContentsToFunction(), CKinFunction::createParameters(), CCopasiXMLParser::FunctionElement::end(), SBMLImporter::importFunctionDefinitions(), CCopasiRootContainer::initializeChildren(), load(), CMassAction::setInfix(), FunctionWidget1::slotFcnDescriptionChanged(), test000058::test_bug1025_10(), test000058::test_bug1025_5(), test000059::test_unique_id_17(), test000059::test_unique_id_18(), test000059::test_unique_id_19(), test000059::test_unique_id_20(), test000059::test_unique_id_21(), and test000059::test_unique_id_21_2().

 {
   return setInfix(infix, true);
 }

bool CFunction::setInfix	(	const std::string &	infix,
		bool	compile
	)

virtual

Function to set the infix description of the tree and (optionally) compile it.

Parameters

const	std::string & infix
bool	compile, boolean indicating whether the expression ought to be compiled

Returns: bool success

Definition at line 78 of file CFunction.cpp.

References CEvaluationNode::CALL, CEvaluationTree::compileNodes(), CEvaluationNode::DELAY, CEvaluationNodeCall::EXPRESSION, initVariables(), CEvaluationTree::mpNodeList, CEvaluationNode::OBJECT, CEvaluationTree::setInfix(), CEvaluationNode::subType(), and CEvaluationNode::type().

 {
   if (!CEvaluationTree::setInfix(infix)) return false;
 
   if (mpNodeList == NULL) return true;
 
   // We need to check that the function does not contain any objects, calls to expression
   // or delay nodes.
   std::vector< CEvaluationNode * >::const_iterator it = mpNodeList->begin();
   std::vector< CEvaluationNode * >::const_iterator end = mpNodeList->end();
 
   for (; it != end; ++it)
     {
       switch (CEvaluationNode::type((*it)->getType()))
         {
           case CEvaluationNode::OBJECT:
           case CEvaluationNode::DELAY:
             return false;
             break;
 
           case CEvaluationNode::CALL:
 
             if ((CEvaluationNodeCall::SubType) CEvaluationNode::subType((*it)->getType()) == CEvaluationNodeCall::EXPRESSION)
               {
                 return false;
               }
 
             break;
 
           default:
             break;
         }
     }
 
   if (!initVariables()) return false;
 
   if (compile) compileNodes();
 
   return true;
 }

void CFunction::setReversible ( const TriLogic & reversible )

Function to set whether it is reversible.

Definition at line 142 of file CFunction.cpp.

References mReversible.

Referenced by SBMLImporter::createCReactionFromReaction(), FunctionWidget1::saveToFunction(), CReaction::setFunctionFromExpressionTree(), CMassAction::setInfix(), and CCopasiXMLParser::FunctionElement::start().

143 {mReversible = reversible;}

CFunction::mReversible

TriLogic mReversible

Definition: CFunction.h:220

void CFunction::setSBMLId ( const std::string & id )

Sets the SBMLId.

Definition at line 63 of file CFunction.cpp.

References mSBMLId.

Referenced by SBMLImporter::createCFunctionFromFunctionDefinition(), SBMLImporter::createCModelFromSBMLDocument(), CSBMLExporter::setFunctionSBMLIds(), and CCopasiXMLParser::SBMLMapElement::start().

 {
   this->mSBMLId = id;
 }

std::pair< CFunction , CFunction > CFunction::splitFunction	(	const CEvaluationNode *	node,
		const std::string &	name1,
		const std::string &	name2
	)		const

Function to split

Parameters

const	CEvaluationNode* node
const	std::string & name1
const	std::string & name2

Definition at line 445 of file CFunction.cpp.

References CFunction(), CEvaluationTree::compile(), CFunctionAnalyzer::constructCallParameters(), CEvaluationNode::findTopMinus(), getVariables(), initVariables(), CFunctionParameter::MODIFIER, CEvaluationTree::mpRoot, mReversible, mVariables, CFunctionParameter::PRODUCT, CCopasiObject::setObjectName(), CEvaluationTree::setRoot(), CFunctionParameters::size(), CEvaluationNode::splitBranch(), CFunctionParameter::SUBSTRATE, TriFalse, and TriTrue.

Referenced by CFunctionAnalyzer::checkKineticFunction(), and CModel::convert2NonReversible().

 {
   if (!this->mpRoot) return std::pair<CFunction *, CFunction *>((CFunction*)NULL, (CFunction*)NULL);
 
   if (this->mReversible != TriTrue) return std::pair<CFunction *, CFunction *>((CFunction*)NULL, (CFunction*)NULL);
 
   //create 2 new functions
   CFunction* newFunction1 = new CFunction();
   newFunction1->setObjectName(name1);
 
   CFunction* newFunction2 = new CFunction();
   newFunction2->setObjectName(name2);
 
   //when searching for a split point we need to analyze subtrees. For
   //doing this a representation of the call parameters in the format
   //used by CFunctionAnalyzer is needed.
   std::vector<CFunctionAnalyzer::CValue> callParameters;
   CFunctionAnalyzer::constructCallParameters(this->getVariables(), callParameters, true);
   // find the split point
   const CEvaluationNode* splitnode = this->mpRoot->findTopMinus(callParameters);
 
   if (!splitnode) return std::pair<CFunction *, CFunction *>((CFunction*)NULL, (CFunction*)NULL);
 
   //create the 2 split trees
   CEvaluationNode* tmpRoots1 = this->mpRoot->splitBranch(splitnode, true); //left side
   CEvaluationNode* tmpRoots2 = this->mpRoot->splitBranch(splitnode, false); //right side
 
   if (tmpRoots1)
     newFunction1->setRoot(tmpRoots1);
 
   if (tmpRoots2)
     newFunction2->setRoot(tmpRoots2);
 
   newFunction1->mVariables = this->mVariables; //copy the parameter list
   newFunction1->initVariables(); //remove unused parameters
   newFunction1->mReversible = TriFalse;
 
   newFunction2->mVariables = this->mVariables; //copy the parameter list
   newFunction2->initVariables(); //remove unused parameters
   newFunction2->mReversible = TriFalse;
 
   //update the roles
   size_t i, imax;
 
   imax = newFunction1->mVariables.size();
 
   for (i = 0; i < imax; ++i)
     {
       if (newFunction1->mVariables[i]->getUsage() == CFunctionParameter::PRODUCT)
         newFunction1->mVariables[i]->setUsage(CFunctionParameter::MODIFIER);
     }
 
   imax = newFunction2->mVariables.size();
 
   for (i = 0; i < imax; ++i)
     {
       if (newFunction2->mVariables[i]->getUsage() == CFunctionParameter::PRODUCT)
         newFunction2->mVariables[i]->setUsage(CFunctionParameter::SUBSTRATE);
       else if (newFunction2->mVariables[i]->getUsage() == CFunctionParameter::SUBSTRATE)
         newFunction2->mVariables[i]->setUsage(CFunctionParameter::MODIFIER);
     }
 
   newFunction1->compile();
   newFunction2->compile();
   return std::pair<CFunction *, CFunction *>(newFunction1, newFunction2);
 }

void CFunction::writeMathML	(	std::ostream &	out,
		size_t	l = `0`
	)		const

virtual

This is an overloaded member function, provided for convenience. It behaves essentially like the above function.

Parameters

std::ostream	& out
size_t	l

Definition at line 389 of file CFunction.cpp.

References CMathMl::fixName(), CCopasiObject::getObjectName(), getVariables(), CFunctionParameters::size(), and SPC.

Referenced by CEvaluationNodeCall::getMMLString(), CQExpressionWidget::writeMathML(), and CMMLOutput::writeRHS().

 {
   //out << "<math>" << std::endl;
 
   out << SPC(l) << "<mrow>" << std::endl;
   out << SPC(l + 1) << CMathMl::fixName(getObjectName()) << std::endl;
   out << SPC(l + 1) << "<mfenced>" << std::endl;
 
   size_t i, imax = getVariables().size();
 
   for (i = 0; i < imax; ++i)
     {
       out << SPC(l + 2) << "<mi>" << CMathMl::fixName(getVariables()[i]->getObjectName()) << "</mi>" << std::endl;
     }
 
   out << SPC(l + 1) << "</mfenced>" << std::endl;
   out << SPC(l) << "</mrow>" << std::endl;
 
   //out << "</math>" << std::endl;
 }

std::string CFunction::writeMathML	(	const std::vector< std::vector< std::string > > &	variables,
		bool	expand = `true`,
		bool	fullExpand = `true`
	)		const

virtual

Function to write the mathematical formula in format of MathML.

Parameters

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

Returns: std::string

Reimplemented in CMassAction.

Definition at line 354 of file CFunction.cpp.

References CEvaluationNode::buildMMLString(), CMathMl::fixName(), CCopasiObject::getObjectName(), and CEvaluationTree::mpRoot.

 {
   std::ostringstream out;
 
   if (expand && mpRoot)
     {
       bool flag = false; //TODO include check if parentheses are necessary
 
       if (flag) out << "<mfenced>" << std::endl;
 
       out << mpRoot->buildMMLString(fullExpand, variables);
 
       if (flag) out << "</mfenced>" << std::endl;
     }
   else //no expand
     {
       out << "<mrow>" << std::endl;
       out << CMathMl::fixName(getObjectName()) << std::endl;
       out << "<mfenced>" << std::endl;
 
       size_t i, imax = variables.size();
 
       for (i = 0; i < imax; ++i)
         {
           out << variables[i][0] << std::endl;
         }
 
       out << "</mfenced>" << std::endl;
       out << "</mrow>" << std::endl;
     }
 
   return out.str();
 }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	os,
		const CFunction &	f
	)

friend

Insert operator

Definition at line 410 of file CFunction.cpp.

 {
   os << "CFunction: " << f.getObjectName() << "   ";
 
   if (f.mReversible == TriUnspecified)
     os << "(general)";
   else if (f.mReversible == TriFalse)
     os << "(irreversible)";
   else
     os << "(reversible)";
 
   os << std::endl;
   os << f.mVariables;
   os << f.getInfix() << std::endl;
 
   return os;
 }

Member Data Documentation

CCallParameters< C_FLOAT64 >::const_iterator CFunction::mCallParametersBegin

private

A pointer to the call parameters during calculation.

Definition at line 215 of file CFunction.h.

Referenced by calcValue(), and getVariableValue().

TriLogic CFunction::mReversible

private

Whether the function is reversible

Definition at line 220 of file CFunction.h.

Referenced by createCopy(), isReversible(), load(), operator<<(), setReversible(), and splitFunction().

std::string CFunction::mSBMLId

private

The id of the corresponding function in an SBML file. This value is either set upon importing an SBML file, or when the object is first exported to an SBML file.

Definition at line 203 of file CFunction.h.

Referenced by getSBMLId(), and setSBMLId().

CFunctionParameters CFunction::mVariables

private

The description of the variables of the function. It describes which variables need to be passed to the function for evaluation and its eventual type.

Definition at line 210 of file CFunction.h.

Referenced by addVariable(), getVariableIndex(), getVariables(), initVariables(), isSuitable(), operator<<(), operator==(), and splitFunction().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation