24 # pragma warning (disable: 4786)
25 # pragma warning (disable: 4243)
27 # pragma warning (disable: 4355)
34 #include "sbml/math/ASTNode.h"
35 #include "sbml/Model.h"
59 #include "sbml/FunctionDefinition.h"
72 ASTNode*
create_expression(
const ASTNode* pSource,
const ListOfFunctionDefinitions* pFunctions)
88 if (pNode->getType() == AST_FUNCTION)
113 unsigned int iMax = pNode->getNumChildren();
114 ASTNode* pChild = NULL;
115 ASTNode* pNewChild = NULL;
119 pChild = pNode->getChild(i);
120 assert(pChild != NULL);
123 if (pNewChild == NULL)
130 pResult->addChild(pNewChild);
146 const FunctionDefinition * pFunctionDefinition = pFunctions->get(pCall->getName());
149 if (pFunctionDefinition == NULL)
return NULL;
152 unsigned int iMax = pFunctionDefinition->getNumArguments();
154 if (pFunctionDefinition != NULL && iMax == pCall->getNumChildren())
157 std::map<std::string, const ASTNode*> argumentMap;
162 argumentMap[pFunctionDefinition->getArgument(i)->getName()] = pCall->getChild(i);
167 pResult = pFunctionDefinition->getBody()->deepCopy();
169 assert(pTmpNode != NULL);
181 if (pNode->getType() == AST_NAME)
183 std::map<std::string, const ASTNode*>::const_iterator pos = argumentMap.find(pNode->getName());
185 if (pos == argumentMap.end())
191 pResult = pos->second->deepCopy();
199 unsigned int iMax = pNode->getNumChildren();
200 ASTNode* pChild = NULL;
201 ASTNode* pNewChild = NULL;
205 pChild = pNode->getChild(i);
206 assert(pChild != NULL);
208 assert(pNewChild != NULL);
209 pResult->addChild(pNewChild);
228 std::map<std::string, std::string> variableMap;
234 result = ((*pTmpLHS) == (*pTmpRHS));
259 if ((pChoice = dynamic_cast<CNormalChoice*>(pBase)) != NULL)
265 else if ((pLogicalChoice = dynamic_cast<CNormalChoiceLogical*>(pBase)) != NULL)
271 else if ((pFraction = dynamic_cast<CNormalFraction*>(pBase)) != NULL)
280 else if ((pFunction = dynamic_cast<CNormalFunction*>(pBase)) != NULL)
284 else if ((pGeneralPower = dynamic_cast<CNormalGeneralPower*>(pBase)) != NULL)
289 else if ((pItem = dynamic_cast<CNormalItem*>(pBase)) != NULL)
291 std::map<std::string, std::string>::iterator pos;
296 pos = variableMap.find(pItem->
getName());
298 if (pos != variableMap.end())
304 std::ostringstream ostrstr;
305 ostrstr <<
"variable";
308 ostrstr << variableMap.size() + 1;
309 variableMap[pItem->
getName()] = ostrstr.str();
318 else if ((pItemPower = dynamic_cast<CNormalItemPower*>(pBase)) != NULL)
322 else if ((pLogical = dynamic_cast<CNormalLogical*>(pBase)) != NULL)
325 CNormalLogical::ChoiceSetOfSets::const_iterator it = pLogical->
getChoices().begin(), endit = pLogical->
getChoices().end();
330 CNormalLogical::ChoiceSet::const_iterator innerit = (*it).first.begin(), innerendit = (*it).first.end();
332 while (innerit != innerendit)
336 tmpChoiceSet.insert(std::make_pair(pLogicalChoice, (*innerit).second));
340 tmpSet.insert(std::make_pair(tmpChoiceSet, (*it).second));
347 CNormalLogical::ItemSetOfSets::const_iterator it2 = pLogical->
getAndSets().begin(), endit2 = pLogical->
getAndSets().end();
349 while (it2 != endit2)
352 CNormalLogical::ItemSet::const_iterator innerit = (*it2).first.begin(), innerendit = (*it2).first.end();
354 while (innerit != innerendit)
358 tmpItemSet.insert(std::make_pair(pLogicalItem, (*innerit).second));
362 tmpSet2.insert(std::make_pair(tmpItemSet, (*it2).second));
369 else if ((pLogicalItem = dynamic_cast<CNormalLogicalItem*>(pBase)) != NULL)
374 else if ((pProduct = dynamic_cast<CNormalProduct*>(pBase)) != NULL)
376 std::set<CNormalItemPower*, compareItemPowers> tmpSet;
377 std::set<CNormalItemPower*, compareItemPowers>::const_iterator it = pProduct->
getItemPowers().begin(), endit = pProduct->
getItemPowers().end();
383 tmpSet.insert(pItemPower);
388 it = tmpSet.begin(), endit = tmpSet.end();
396 else if ((pSum = dynamic_cast<CNormalSum*>(pBase)) != NULL)
398 std::set<CNormalFraction*> tmpSet;
405 tmpSet.insert(pFraction);
410 it = tmpSet.begin(), endit = tmpSet.end();
418 std::set<CNormalProduct*, compareProducts> tmpSet2;
419 std::set<CNormalProduct*, compareProducts>::const_iterator it2 = pSum->
getProducts().begin(), endit2 = pSum->
getProducts().end();
421 while (it2 != endit2)
425 tmpSet2.insert(pProduct);
430 it2 = tmpSet2.begin(), endit2 = tmpSet2.end();
432 while (it2 != endit2)
455 if (dynamic_cast<CEvaluationNodeObject*>(&(*treeIt)))
458 delete pEvaluationNode;
459 pEvaluationNode = pVariableNode;
463 while (treeIt != NULL)
465 if (dynamic_cast<CEvaluationNodeObject*>(&(*treeIt)))
469 if ((*treeIt).getParent())
471 (*treeIt).getParent()->addChild(pVariableNode, &(*treeIt));
472 (*treeIt).getParent()->removeChild(&(*treeIt));
476 treeIt = pVariableNode;
483 if (pEvaluationNode != NULL)
487 delete pEvaluationNode;
507 if (dynamic_cast<CEvaluationNodeObject*>(&(*treeIt)))
510 delete pEvaluationNode;
511 pEvaluationNode = pVariableNode;
515 while (treeIt != NULL)
517 if (dynamic_cast<CEvaluationNodeObject*>(&(*treeIt)))
521 if ((*treeIt).getParent())
523 (*treeIt).getParent()->addChild(pVariableNode, &(*treeIt));
524 (*treeIt).getParent()->removeChild(&(*treeIt));
528 treeIt = pVariableNode;
535 if (pEvaluationNode != NULL)
539 delete pEvaluationNode;
554 pResult =
new ASTNode(AST_DIVIDE);
555 ASTNode* pTmpNode =
new ASTNode(AST_INTEGER);
556 pTmpNode->setValue(1);
557 pResult->addChild(pTmpNode);
558 pTmpNode =
new ASTNode(AST_FUNCTION_COS);
559 pTmpNode->addChild(pChild->deepCopy());
560 pResult->addChild(pTmpNode);
575 pResult =
new ASTNode(AST_DIVIDE);
576 ASTNode* pTmpNode =
new ASTNode(AST_INTEGER);
577 pTmpNode->setValue(1);
578 pResult->addChild(pTmpNode);
579 pTmpNode =
new ASTNode(AST_FUNCTION_SIN);
580 pTmpNode->addChild(pChild->deepCopy());
581 pResult->addChild(pTmpNode);
596 pResult =
new ASTNode(AST_DIVIDE);
597 ASTNode* pTmpNode =
new ASTNode(AST_FUNCTION_COS);
598 pTmpNode->addChild(pChild->deepCopy());
599 pResult->addChild(pTmpNode);
600 pTmpNode =
new ASTNode(AST_FUNCTION_SIN);
601 pTmpNode->addChild(pChild->deepCopy());
602 pResult->addChild(pTmpNode);
617 pResult =
new ASTNode(AST_DIVIDE);
618 ASTNode* pTmpNode =
new ASTNode(AST_MINUS);
619 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
620 pTmpNode2->addChild(pChild->deepCopy());
621 pTmpNode->addChild(pTmpNode2);
622 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
623 ASTNode* pTmpNode3 =
new ASTNode(AST_MINUS);
624 pTmpNode3->addChild(pChild->deepCopy());
625 pTmpNode2->addChild(pTmpNode3);
626 pTmpNode->addChild(pTmpNode2);
627 pResult->addChild(pTmpNode);
628 pTmpNode =
new ASTNode(AST_INTEGER);
629 pTmpNode->setValue(2);
630 pResult->addChild(pTmpNode);
645 pResult =
new ASTNode(AST_DIVIDE);
646 ASTNode* pTmpNode =
new ASTNode(AST_PLUS);
647 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
648 pTmpNode2->addChild(pChild->deepCopy());
649 pTmpNode->addChild(pTmpNode2);
650 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
651 ASTNode* pTmpNode3 =
new ASTNode(AST_MINUS);
652 pTmpNode3->addChild(pChild->deepCopy());
653 pTmpNode2->addChild(pTmpNode3);
654 pTmpNode->addChild(pTmpNode2);
655 pResult->addChild(pTmpNode);
656 pTmpNode =
new ASTNode(AST_INTEGER);
657 pTmpNode->setValue(2);
658 pResult->addChild(pTmpNode);
673 pResult =
new ASTNode(AST_DIVIDE);
674 ASTNode* pTmpNode =
new ASTNode(AST_MINUS);
675 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
676 pTmpNode2->addChild(pChild->deepCopy());
677 pTmpNode->addChild(pTmpNode2);
678 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
679 ASTNode* pTmpNode3 =
new ASTNode(AST_MINUS);
680 pTmpNode3->addChild(pChild->deepCopy());
681 pTmpNode2->addChild(pTmpNode3);
682 pTmpNode->addChild(pTmpNode2);
683 pResult->addChild(pTmpNode);
684 pTmpNode =
new ASTNode(AST_PLUS);
685 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
686 pTmpNode2->addChild(pChild->deepCopy());
687 pTmpNode->addChild(pTmpNode2);
688 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
689 pTmpNode3 =
new ASTNode(AST_MINUS);
690 pTmpNode3->addChild(pChild->deepCopy());
691 pTmpNode2->addChild(pTmpNode3);
692 pTmpNode->addChild(pTmpNode2);
693 pResult->addChild(pTmpNode);
708 pResult =
new ASTNode(AST_DIVIDE);
709 ASTNode* pTmpNode =
new ASTNode(AST_INTEGER);
710 pTmpNode->setValue(2);
711 pResult->addChild(pTmpNode);
712 pTmpNode =
new ASTNode(AST_PLUS);
713 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
714 pTmpNode2->addChild(pChild->deepCopy());
715 pTmpNode->addChild(pTmpNode2);
716 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
717 ASTNode* pTmpNode3 =
new ASTNode(AST_MINUS);
718 pTmpNode3->addChild(pChild->deepCopy());
719 pTmpNode2->addChild(pTmpNode3);
720 pTmpNode->addChild(pTmpNode2);
721 pResult->addChild(pTmpNode);
736 pResult =
new ASTNode(AST_DIVIDE);
737 ASTNode* pTmpNode =
new ASTNode(AST_INTEGER);
738 pTmpNode->setValue(2);
739 pResult->addChild(pTmpNode);
740 pTmpNode =
new ASTNode(AST_MINUS);
741 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
742 pTmpNode2->addChild(pChild->deepCopy());
743 pTmpNode->addChild(pTmpNode2);
744 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
745 ASTNode* pTmpNode3 =
new ASTNode(AST_MINUS);
746 pTmpNode3->addChild(pChild->deepCopy());
747 pTmpNode2->addChild(pTmpNode3);
748 pTmpNode->addChild(pTmpNode2);
749 pResult->addChild(pTmpNode);
764 pResult =
new ASTNode(AST_DIVIDE);
765 ASTNode* pTmpNode =
new ASTNode(AST_PLUS);
766 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
767 pTmpNode2->addChild(pChild->deepCopy());
768 pTmpNode->addChild(pTmpNode2);
769 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
770 ASTNode* pTmpNode3 =
new ASTNode(AST_MINUS);
771 pTmpNode3->addChild(pChild->deepCopy());
772 pTmpNode2->addChild(pTmpNode3);
773 pTmpNode->addChild(pTmpNode2);
774 pResult->addChild(pTmpNode);
775 pTmpNode =
new ASTNode(AST_MINUS);
776 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
777 pTmpNode2->addChild(pChild->deepCopy());
778 pTmpNode->addChild(pTmpNode2);
779 pTmpNode2 =
new ASTNode(AST_FUNCTION_EXP);
780 pTmpNode3 =
new ASTNode(AST_MINUS);
781 pTmpNode3->addChild(pChild->deepCopy());
782 pTmpNode2->addChild(pTmpNode3);
783 pTmpNode->addChild(pTmpNode2);
784 pResult->addChild(pTmpNode);
799 pResult =
new ASTNode(AST_FUNCTION_LOG);
800 ASTNode* pTmpNode =
new ASTNode(AST_PLUS);
801 pTmpNode->addChild(pChild->deepCopy());
802 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_POWER);
803 ASTNode* pTmpNode3 =
new ASTNode(AST_PLUS);
804 ASTNode* pTmpNode4 =
new ASTNode(AST_FUNCTION_POWER);
805 pTmpNode4->addChild(pChild->deepCopy());
806 ASTNode* pTmpNode5 =
new ASTNode(AST_INTEGER);
807 pTmpNode5->setValue(2);
808 pTmpNode4->addChild(pTmpNode5);
809 pTmpNode3->addChild(pTmpNode4);
810 pTmpNode4 =
new ASTNode(AST_INTEGER);
811 pTmpNode4->setValue(1);
812 pTmpNode3->addChild(pTmpNode4);
813 pTmpNode2->addChild(pTmpNode3);
814 pTmpNode3 =
new ASTNode(AST_REAL);
815 pTmpNode3->setValue(0.5);
816 pTmpNode2->addChild(pTmpNode3);
817 pTmpNode->addChild(pTmpNode2);
818 pResult->addChild(pTmpNode);
833 pResult =
new ASTNode(AST_FUNCTION_LOG);
834 ASTNode* pTmpNode =
new ASTNode(AST_PLUS);
835 pTmpNode->addChild(pChild->deepCopy());
836 ASTNode* pTmpNode2 =
new ASTNode(AST_TIMES);
837 ASTNode* pTmpNode3 =
new ASTNode(AST_FUNCTION_POWER);
838 ASTNode* pTmpNode4 =
new ASTNode(AST_MINUS);
839 pTmpNode4->addChild(pChild->deepCopy());
840 ASTNode* pTmpNode5 =
new ASTNode(AST_INTEGER);
841 pTmpNode5->setValue(1);
842 pTmpNode4->addChild(pTmpNode5);
843 pTmpNode3->addChild(pTmpNode4);
844 pTmpNode4 =
new ASTNode(AST_REAL);
845 pTmpNode4->setValue(0.5);
846 pTmpNode3->addChild(pTmpNode4);
847 pTmpNode2->addChild(pTmpNode3);
848 pTmpNode3 =
new ASTNode(AST_FUNCTION_POWER);
849 pTmpNode4 =
new ASTNode(AST_PLUS);
850 pTmpNode4->addChild(pChild->deepCopy());
851 pTmpNode5 =
new ASTNode(AST_INTEGER);
852 pTmpNode5->setValue(1);
853 pTmpNode4->addChild(pTmpNode5);
854 pTmpNode3->addChild(pTmpNode4);
855 pTmpNode4 =
new ASTNode(AST_REAL);
856 pTmpNode4->setValue(0.5);
857 pTmpNode3->addChild(pTmpNode4);
858 pTmpNode2->addChild(pTmpNode3);
859 pTmpNode->addChild(pTmpNode2);
860 pResult->addChild(pTmpNode);
875 pResult =
new ASTNode(AST_TIMES);
876 ASTNode* pTmpNode =
new ASTNode(AST_RATIONAL);
877 pTmpNode->setValue((
long)1, (
long)2);
878 pResult->addChild(pTmpNode);
879 pTmpNode =
new ASTNode(AST_MINUS);
880 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_LOG);
881 ASTNode* pTmpNode3 =
new ASTNode(AST_PLUS);
882 ASTNode* pTmpNode4 =
new ASTNode(AST_INTEGER);
883 pTmpNode4->setValue(1);;
884 pTmpNode3->addChild(pTmpNode4);
885 pTmpNode3->addChild(pChild->deepCopy());
886 pTmpNode2->addChild(pTmpNode3);
887 pTmpNode->addChild(pTmpNode2);
888 pTmpNode2 =
new ASTNode(AST_FUNCTION_LOG);
889 pTmpNode3 =
new ASTNode(AST_MINUS);
890 pTmpNode4 =
new ASTNode(AST_INTEGER);
891 pTmpNode4->setValue(1);;
892 pTmpNode3->addChild(pTmpNode4);
893 pTmpNode3->addChild(pChild->deepCopy());
894 pTmpNode2->addChild(pTmpNode3);
895 pTmpNode->addChild(pTmpNode2);
896 pResult->addChild(pTmpNode);
911 pResult =
new ASTNode(AST_FUNCTION_LOG);
912 ASTNode* pTmpNode =
new ASTNode(AST_PLUS);
913 ASTNode* pTmpNode2 =
new ASTNode(AST_TIMES);
914 ASTNode* pTmpNode3 =
new ASTNode(AST_FUNCTION_POWER);
915 ASTNode* pTmpNode4 =
new ASTNode(AST_MINUS);
916 ASTNode* pTmpNode5 =
new ASTNode(AST_DIVIDE);
917 ASTNode* pTmpNode6 =
new ASTNode(AST_INTEGER);
918 pTmpNode6->setValue(1);
919 pTmpNode5->addChild(pTmpNode6);
920 pTmpNode5->addChild(pChild->deepCopy());
921 pTmpNode4->addChild(pTmpNode5);
922 pTmpNode5 =
new ASTNode(AST_INTEGER);
923 pTmpNode5->setValue(1);
924 pTmpNode4->addChild(pTmpNode5);
925 pTmpNode3->addChild(pTmpNode4);
926 pTmpNode4 =
new ASTNode(AST_REAL);
927 pTmpNode4->setValue(0.5);
928 pTmpNode3->addChild(pTmpNode4);
929 pTmpNode2->addChild(pTmpNode3);
930 pTmpNode3 =
new ASTNode(AST_FUNCTION_POWER);
931 pTmpNode4 =
new ASTNode(AST_PLUS);
932 pTmpNode5 =
new ASTNode(AST_INTEGER);
933 pTmpNode5->setValue(1);
934 pTmpNode4->addChild(pTmpNode5);
935 pTmpNode5 =
new ASTNode(AST_DIVIDE);
936 pTmpNode6 =
new ASTNode(AST_INTEGER);
937 pTmpNode6->setValue(1);
938 pTmpNode5->addChild(pTmpNode6);
939 pTmpNode5->addChild(pChild->deepCopy());
940 pTmpNode4->addChild(pTmpNode5);
941 pTmpNode3->addChild(pTmpNode4);
942 pTmpNode4 =
new ASTNode(AST_REAL);
943 pTmpNode4->setValue(0.5);
944 pTmpNode3->addChild(pTmpNode4);
945 pTmpNode2->addChild(pTmpNode3);
946 pTmpNode->addChild(pTmpNode2);
947 pTmpNode2 =
new ASTNode(AST_DIVIDE);
948 pTmpNode3 =
new ASTNode(AST_INTEGER);
949 pTmpNode3->setValue(1);
950 pTmpNode2->addChild(pTmpNode3);
951 pTmpNode2->addChild(pChild->deepCopy());
952 pTmpNode->addChild(pTmpNode2);
953 pResult->addChild(pTmpNode);
968 pResult =
new ASTNode(AST_FUNCTION_LOG);
969 ASTNode* pTmpNode =
new ASTNode(AST_PLUS);
970 ASTNode* pTmpNode2 =
new ASTNode(AST_FUNCTION_POWER);
971 ASTNode* pTmpNode3 =
new ASTNode(AST_PLUS);
972 ASTNode* pTmpNode4 =
new ASTNode(AST_INTEGER);
973 pTmpNode4->setValue(1);
974 pTmpNode3->addChild(pTmpNode4);
975 pTmpNode4 =
new ASTNode(AST_DIVIDE);
976 ASTNode* pTmpNode5 =
new ASTNode(AST_INTEGER);
977 pTmpNode5->setValue(1);
978 pTmpNode4->addChild(pTmpNode5);
979 pTmpNode5 =
new ASTNode(AST_FUNCTION_POWER);
980 pTmpNode5->addChild(pChild->deepCopy());
981 ASTNode* pTmpNode6 =
new ASTNode(AST_INTEGER);
982 pTmpNode6->setValue(2);
983 pTmpNode5->addChild(pTmpNode6);
984 pTmpNode4->addChild(pTmpNode5);
985 pTmpNode3->addChild(pTmpNode4);
986 pTmpNode2->addChild(pTmpNode3);
987 pTmpNode->addChild(pTmpNode2);
988 pTmpNode2 =
new ASTNode(AST_DIVIDE);
989 pTmpNode3 =
new ASTNode(AST_INTEGER);
990 pTmpNode3->setValue(1);
991 pTmpNode2->addChild(pTmpNode3);
992 pTmpNode2->addChild(pChild->deepCopy());
993 pTmpNode->addChild(pTmpNode2);
994 pResult->addChild(pTmpNode);
1014 if (pResult == NULL)
1033 std::vector<CEvaluationNode*> v;
1038 while (pChild != NULL)
1042 if (pNewChild == NULL)
1072 assert(pFunctionDefinition != NULL);
1074 unsigned int i, iMax = functionParameters.
size();
1076 std::map<std::string, const CEvaluationNode*> argumentMap;
1082 assert(pChild != NULL);
1083 argumentMap[functionParameters[i]->
getObjectName()] = pChild;
1091 assert(pTmpNode != NULL);
1093 assert(pChild == NULL);
1104 if (dynamic_cast<const CEvaluationNodeVariable*>(pNode) != NULL)
1106 std::map<std::string, const CEvaluationNode*>::const_iterator pos = argumentMap.find(pNode->
getData());
1108 if (pos != argumentMap.end())
1110 pResult = pos->second->copyBranch();
1116 std::vector<CEvaluationNode*> v;
1121 while (pChild != NULL)
1124 assert(pNewChild != NULL);
1143 if (pNumerator != NULL && pNumerator->
getFractions().empty())
1159 if (fabs(factor1 + 1.0) < 1e-23 && fabs(factor2 - 1.0) < 1e-23)
1162 pSubstrates = *(++(pNumerator->
getProducts().begin()));
1164 else if (fabs(factor1 - 1.0) < 1e-23 && fabs(factor2 + 1.0) < 1e-23)
1167 pProducts = *(++(pNumerator->
getProducts().begin()));
1170 if (pProducts != NULL)
1181 if (fabs((*pNumerator->
getProducts().begin())->getFactor() - 1.0) < 1e-23)
1191 if (result ==
true && pSubstrates != NULL)
1223 if (pModel != NULL && pProduct != NULL && elements.
size() > 0)
1227 const CMetab* pMetab = NULL;
1229 assert(pDatamodel != NULL);
1230 std::vector<CCopasiContainer*> listOfContainers;
1231 listOfContainers.push_back(const_cast<CModel*>(pModel));
1234 std::vector<const CCopasiObject*> tmpObjects;
1235 const std::set<CNormalItemPower*, compareItemPowers >& itemPowers = pProduct->
getItemPowers();
1236 std::set <CNormalItemPower*, compareItemPowers >::const_iterator iit = itemPowers.begin(), iendit = itemPowers.end();
1238 while (iit != iendit && result !=
false)
1247 pItem =
dynamic_cast<const CNormalItem*
>(&(*iit)->getItem());
1251 std::string cn = pItem->
getName();
1254 if (pObject != NULL)
1259 assert(pObject != NULL);
1262 pMetab =
dynamic_cast<const CMetab*
>(pObject);
1268 while (tmpVIt != tmpVEndit)
1271 if (pMetab == (*tmpVIt)->getMetabolite() && fabs((*tmpVIt)->getMultiplicity() - (*iit)->getExp()) < 1e-23)
1284 if (fabs((*iit)->getExp() - 1.0) < 1e-23)
1286 tmpObjects.push_back(pObject);
1313 if (tmpV.
size() == 0 && tmpObjects.size() == 1)
1316 if (!(dynamic_cast<const CModelValue*>(tmpObjects[0]) || dynamic_cast<const CCopasiParameter*>(tmpObjects[0])))
CNormalSum & getNumerator()
ASTNode * replace_ARCTANH(const ASTNode *pChild)
CEvaluationNode * copyBranch() const
ASTNode * replace_COT(const ASTNode *pChild)
Header file of class CModelEntity and CModelValue.
ChoiceSetOfSets & getChoices()
CCopasiNode< Data > * getSibling()
static CNormalFraction * normAndSimplifyReptdly(const CEvaluationTree *tree0, unsigned int depth=0)
const std::string & getObjectName() const
CEvaluationNode * copyNode(CEvaluationNode *child1, CEvaluationNode *child2) const
static void cleanSetOfSets(TemplateSetOfSets< TYPE > &s)
virtual size_t size() const
const CNormalFraction & getTrueExpression() const
ASTNode * replace_COTH(const ASTNode *pChild)
CNormalFraction & getLeft()
bool setName(const std::string &name)
ASTNode * expand_function_call(const ASTNode *pCall, const ListOfFunctionDefinitions *pFunctions)
CNormalFraction & getLeft()
bool are_equal(const CNormalFraction *pLHS, const CNormalFraction *pRHS)
const CNormalLogical & getCondition() const
ASTNode * replace_variable_names(const ASTNode *pNode, const std::map< std::string, const ASTNode * > &argumentMap)
ASTNode * replace_ARCCSCH(const ASTNode *pChild)
ASTNode * replace_SEC(const ASTNode *pChild)
static CEvaluationNode * fromAST(const ASTNode *pASTNode)
ASTNode * replace_CSCH(const ASTNode *pChild)
ASTNode * replace_ARCSECH(const ASTNode *pChild)
const CNormalFraction & getFalseExpression() const
ASTNode * replace_COSH(const ASTNode *pChild)
const CCopasiVector< CChemEqElement > & getProducts() const
const std::set< CNormalFraction * > & getFractions() const
const Type & getType() const
virtual const Data & getData() const
CNormalFraction * create_simplified_normalform(const ASTNode *pSource)
void setAndSets(const ItemSetOfSets &set)
virtual bool addChild(CCopasiNode< Data > *pChild, CCopasiNode< Data > *pAfter=NULL)
CNormalSum & getDenominator()
const bool & getReversibility() const
const std::set< CNormalItemPower *, compareItemPowers > & getItemPowers() const
bool contains_necessary_mass_action_elements(const CCopasiVector< CChemEqElement > &elements, const CNormalProduct *pProduct, const CModel *pModel)
void setChoices(const ChoiceSetOfSets &set)
CNormalFraction & getRight()
const CCopasiVector< CChemEqElement > & getSubstrates() const
void setFractions(const std::set< CNormalFraction * > &set)
ASTNode * replace_TANH(const ASTNode *pChild)
virtual void remove(const size_t &index)
bool is_mass_action(const CNormalFraction *pFrac, const CModel *pModel, const CChemEq *pChemEq)
bool checkDenominatorOne() const
ASTNode * replace_SECH(const ASTNode *pChild)
ASTNode * replace_SINH(const ASTNode *pChild)
void setItemPowers(const std::set< CNormalItemPower *, compareItemPowers > &set)
static ASTNode * shallowCopy(const ASTNode *pOrig)
ASTNode * create_expression(const ASTNode *pSource, const ListOfFunctionDefinitions *pFunctions)
CNormalFraction * createNormalRepresentation(const CEvaluationNode *node)
ASTNode * replace_ARCCOSH(const ASTNode *pChild)
void setProducts(const std::set< CNormalProduct *, compareProducts > &set)
The class for handling a chemical kinetic function.
const std::string getName() const
virtual const Data & getData() const
ASTNode * replace_CSC(const ASTNode *pChild)
CNormalFraction * create_normalform(const ASTNode *pSource)
ASTNode * expand_function_calls(const ASTNode *pNode, const ListOfFunctionDefinitions *pFunctions)
CCopasiNode< Data > * getChild()
void normalize_variable_names(CNormalBase *pBase, std::map< std::string, std::string > &variableMap)
CFunction * findFunction(const std::string &functionName)
CCopasiObject * ObjectFromName(const std::vector< CCopasiContainer * > &listOfContainer, const CCopasiObjectName &CN) const
ASTNode * replace_ARCSINH(const ASTNode *pChild)
CEvaluationNode * getRoot()
CNormalFraction & getFraction()
const std::set< CNormalProduct *, compareProducts > & getProducts() const
CFunctionParameters & getVariables()
CCopasiContainer * getObjectParent() const
CNormalFraction & getRight()
ItemSetOfSets & getAndSets()