END_TEST
START_TEST (test_SBML_parseFormula_12)
{
ASTNode_t *r = SBML_parseFormula("2 * foo^bar + 3.0");
ASTNode_t *c;
fail_unless( ASTNode_getType (r) == AST_PLUS, NULL );
fail_unless( ASTNode_getCharacter (r) == '+', NULL );
fail_unless( ASTNode_getNumChildren(r) == 2 , NULL );
c = ASTNode_getLeftChild(r);
fail_unless( ASTNode_getType (c) == AST_TIMES, NULL );
fail_unless( ASTNode_getCharacter (c) == '*', NULL );
fail_unless( ASTNode_getNumChildren(c) == 2 , NULL );
c = ASTNode_getRightChild(r);
fail_unless( ASTNode_getType (c) == AST_REAL, NULL );
fail_unless( ASTNode_getReal (c) == 3.0, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0 , NULL );
c = ASTNode_getLeftChild( ASTNode_getLeftChild(r) );
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 2, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild( ASTNode_getLeftChild(r) );
fail_unless( ASTNode_getType (c) == AST_POWER, NULL );
fail_unless( ASTNode_getCharacter (c) == '^', NULL );
fail_unless( ASTNode_getNumChildren(c) == 2 , NULL );
c = ASTNode_getLeftChild( ASTNode_getRightChild( ASTNode_getLeftChild(r) ) );
fail_unless( ASTNode_getType(c) == AST_NAME , NULL );
fail_unless( !strcmp(ASTNode_getName(c), "foo") , NULL );
fail_unless( ASTNode_getNumChildren(c) == 0 , NULL );
c = ASTNode_getRightChild( ASTNode_getRightChild( ASTNode_getLeftChild(r) ) );
fail_unless( ASTNode_getType(c) == AST_NAME , NULL );
fail_unless( !strcmp(ASTNode_getName(c), "bar") , NULL );
fail_unless( ASTNode_getNumChildren(c) == 0 , NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_15)
{
ASTNode_t *r = SBML_parseFormula("foo(1, bar)");
ASTNode_t *c;
fail_unless( ASTNode_getType(r) == AST_FUNCTION , NULL );
fail_unless( !strcmp(ASTNode_getName(r), "foo") , NULL );
fail_unless( ASTNode_getNumChildren(r) == 2 , NULL );
c = ASTNode_getLeftChild(r);
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 1, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild(r);
fail_unless( ASTNode_getType(c) == AST_NAME , NULL );
fail_unless( !strcmp(ASTNode_getName(c), "bar") , NULL );
fail_unless( ASTNode_getNumChildren(c) == 0 , NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_6)
{
ASTNode_t *r = SBML_parseFormula("1 + 2");
ASTNode_t *c;
fail_unless( ASTNode_getType (r) == AST_PLUS, NULL );
fail_unless( ASTNode_getCharacter (r) == '+', NULL );
fail_unless( ASTNode_getNumChildren(r) == 2 , NULL );
c = ASTNode_getLeftChild(r);
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 1, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild(r);
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 2, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
ASTNode_free(r);
}
/**
* Visits the given ASTNode, translating the piecewise function
* to the much simpler 'x % y' format.
*/
void
L3FormulaFormatter_visitModulo ( const ASTNode_t *parent,
const ASTNode_t *node,
StringBuffer_t *sb,
const L3ParserSettings_t *settings )
{
unsigned int group = L3FormulaFormatter_isGrouped(parent, node, settings);
const ASTNode_t* subnode = ASTNode_getLeftChild(node);
if (group)
{
StringBuffer_appendChar(sb, '(');
}
//Get x and y from the first child of the piecewise function,
// then the first child of that (times), and the first child
// of that (minus).
L3FormulaFormatter_visit ( subnode, ASTNode_getLeftChild(subnode), sb, settings);
StringBuffer_appendChar(sb, ' ');
StringBuffer_appendChar(sb, '%');
StringBuffer_appendChar(sb, ' ');
subnode = ASTNode_getRightChild(subnode);
L3FormulaFormatter_visit ( node, ASTNode_getLeftChild(subnode), sb, settings);
if (group)
{
StringBuffer_appendChar(sb, ')');
}
}
END_TEST
START_TEST (test_SBML_parseFormula_11)
{
ASTNode_t *r = SBML_parseFormula("1 - -foo / 3");
ASTNode_t *c;
fail_unless( ASTNode_getType (r) == AST_MINUS, NULL );
fail_unless( ASTNode_getCharacter (r) == '-', NULL );
fail_unless( ASTNode_getNumChildren(r) == 2 , NULL );
c = ASTNode_getLeftChild(r);
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 1, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild(r);
fail_unless( ASTNode_getType (c) == AST_DIVIDE, NULL );
fail_unless( ASTNode_getCharacter (c) == '/', NULL );
fail_unless( ASTNode_getNumChildren(c) == 2, NULL );
c = ASTNode_getLeftChild( ASTNode_getRightChild(r) );
fail_unless( ASTNode_getType (c) == AST_MINUS, NULL );
fail_unless( ASTNode_getCharacter (c) == '-', NULL );
fail_unless( ASTNode_getNumChildren(c) == 1 , NULL );
c = ASTNode_getLeftChild( ASTNode_getLeftChild( ASTNode_getRightChild(r) ) );
fail_unless( ASTNode_getType(c) == AST_NAME , NULL );
fail_unless( !strcmp(ASTNode_getName(c), "foo") , NULL );
fail_unless( ASTNode_getNumChildren(c) == 0 , NULL );
c = ASTNode_getRightChild( ASTNode_getRightChild(r) );
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 3, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_10)
{
ASTNode_t *r = SBML_parseFormula("1 + -2e100 / 3");
ASTNode_t *c;
fail_unless( ASTNode_getType (r) == AST_PLUS, NULL );
fail_unless( ASTNode_getCharacter (r) == '+', NULL );
fail_unless( ASTNode_getNumChildren(r) == 2 , NULL );
c = ASTNode_getLeftChild(r);
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 1, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild(r);
fail_unless( ASTNode_getType (c) == AST_DIVIDE, NULL );
fail_unless( ASTNode_getCharacter (c) == '/', NULL );
fail_unless( ASTNode_getNumChildren(c) == 2 , NULL );
c = ASTNode_getLeftChild(c);
fail_unless( ASTNode_getType (c) == AST_REAL_E, NULL );
fail_unless( ASTNode_getMantissa (c) == -2, NULL );
fail_unless( ASTNode_getExponent (c) == 100, NULL );
fail_unless( ASTNode_getReal (c) == -2e+100, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild( ASTNode_getRightChild(r) );
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 3, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_8)
{
ASTNode_t *r = SBML_parseFormula("(1 - 2) * 3");
ASTNode_t *c;
fail_unless( ASTNode_getType (r) == AST_TIMES, NULL );
fail_unless( ASTNode_getCharacter (r) == '*', NULL );
fail_unless( ASTNode_getNumChildren(r) == 2 , NULL );
c = ASTNode_getLeftChild(r);
fail_unless( ASTNode_getType (c) == AST_MINUS, NULL );
fail_unless( ASTNode_getCharacter (c) == '-', NULL );
fail_unless( ASTNode_getNumChildren(c) == 2, NULL );
c = ASTNode_getRightChild(r);
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 3, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getLeftChild( ASTNode_getLeftChild(r) );
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 1, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
c = ASTNode_getRightChild( ASTNode_getLeftChild(r) );
fail_unless( ASTNode_getType (c) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (c) == 2, NULL );
fail_unless( ASTNode_getNumChildren(c) == 0, NULL );
ASTNode_free(r);
}
/**
* Visits the given ASTNode and continues the inorder traversal.
* Writes the function as a directed graph and appends the result
* to the StringBuffer.
*/
void
FormulaGraphvizFormatter_visitOther (const ASTNode_t *parent,
const ASTNode_t *node,
StringBuffer_t *sb )
{
unsigned int numChildren = ASTNode_getNumChildren(node);
char *name;
char *uniqueName;
if (numChildren > 0)
{
uniqueName = FormulaGraphvizFormatter_getUniqueName(node);
name = FormulaGraphvizFormatter_format(node);
StringBuffer_append(sb, uniqueName);
StringBuffer_append(sb, " [shape=box, label=");
StringBuffer_append(sb, name);
StringBuffer_append(sb, "];\n");
FormulaGraphvizFormatter_visit( node, ASTNode_getLeftChild(node), sb );
}
if (parent != NULL)
{
name = FormulaGraphvizFormatter_getUniqueName(node);
uniqueName = FormulaGraphvizFormatter_getUniqueName(parent);
if(strcmp(name, uniqueName))
{
StringBuffer_append(sb, uniqueName);
StringBuffer_append(sb, " -> ");
StringBuffer_append(sb, name);
StringBuffer_append(sb, ";\n");
}
}
if (numChildren > 1)
{
FormulaGraphvizFormatter_visit( node, ASTNode_getRightChild(node), sb );
}
}
/**
* @return true (non-zero) if the given child ASTNode should be grouped
* (with parenthesis), false (0) otherwise.
*
* A node should be group if it is not an argument to a function and
* either:
*
* - The parent node has higher precedence than the child, or
*
* - If parent node has equal precedence with the child and the child is
* to the right. In this case, operator associativity and right-most
* AST derivation enforce the grouping.
*/
int
FormulaFormatter_isGrouped (const ASTNode_t *parent, const ASTNode_t *child)
{
int pp, cp;
int pt, ct;
int group = 0;
if (parent != NULL)
{
if (!FormulaFormatter_isFunction(parent))
{
pp = ASTNode_getPrecedence(parent);
cp = ASTNode_getPrecedence(child);
if (pp > cp)
{
group = 1;
}
else if (pp == cp)
{
/**
* Group only if i) child is to the right and ii) both parent and
* child are either not the same, or if they are the same, they
* should be non-associative operators (i.e. AST_MINUS or
* AST_DIVIDE). That is, do not group a parent and right child
* that are either both AST_PLUS or both AST_TIMES operators.
*/
if (ASTNode_getRightChild(parent) == child)
{
pt = ASTNode_getType(parent);
ct = ASTNode_getType(child);
group = ((pt != ct) || (pt == AST_MINUS || pt == AST_DIVIDE));
}
}
}
}
return group;
}
void alg_alter_tree_structure(ASTNode_t **node_p, ASTNode_t *parent, int child_order) {
ASTNode_t *node, *left, *right;
ASTNode_t *times_node, *one_node;
node = *node_p;
if((left=ASTNode_getLeftChild(node)) != NULL) {
alg_alter_tree_structure(&left, node, 0);
}
if((right=ASTNode_getRightChild(node)) != NULL) {
alg_alter_tree_structure(&right, node, 1);
}
if(ASTNode_getType(node) == AST_NAME) {
times_node = ASTNode_createWithType(AST_TIMES);
one_node = ASTNode_createWithType(AST_INTEGER);
ASTNode_setInteger(one_node, 1);
ASTNode_addChild(times_node, one_node);
ASTNode_addChild(times_node, node);
if(parent != NULL) {
ASTNode_replaceChild(parent, child_order, times_node);
} else {
*node_p = times_node;
}
}
return;
}
END_TEST
START_TEST (test_FormulaFormatter_isGrouped)
{
ASTNode_t *p = ASTNode_create();
ASTNode_t *c;
/** Empty parent, p is the root of the tree. **/
fail_unless( FormulaFormatter_isGrouped(NULL, p) == 0, NULL );
ASTNode_free(p);
/** "1 + 2 * 3" **/
p = SBML_parseFormula("1 + 2 * 3");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
/** "(1 + 2) * 3" **/
p = SBML_parseFormula("(1 + 2) * 3");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 1, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
/**
* "1 + (2 * 3)":
*
* In this case, explicit grouping is not needed due to operator
* precedence rules.
*/
p = SBML_parseFormula("1 + (2 * 3)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
/**
* "foo(1 + 2, 2 * 3)":
*
* The parent node foo has higher precedence than its children, but
* grouping is not nescessary since foo is a function.
*/
p = SBML_parseFormula("foo(1 + 2, 2 * 3)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
/**
* "(a / b) * c":
*
* In this case, explicit grouping is not needed due to associativity
* rules.
*/
p = SBML_parseFormula("(a / b) * c");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
/**
* "a / (b * c)":
*
* In this case, explicit grouping is needed. The operators / and * have
* the same precedence, but the parenthesis modifies the associativity.
*/
p = SBML_parseFormula("a / (b * c)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 1, NULL );
ASTNode_free(p);
/**
* "a - (b - c)":
*
* Rainer Machne reported that the above parsed correctly, but was not
* formatted correctly.
*
* The bug was in FormulaFormatter_isGrouped(). While it was correctly
* handling parent and child ASTNodes of the same precedence, it was not
* handling the special subcase where parent and child nodes were the
* same operator. For grouping, this only matters for the subtraction
* and division operators, as they are not associative.
*
* An exhaustive set of eight tests follow.
*/
p = SBML_parseFormula("a - (b - c)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 1, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a - b - c");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a + (b + c)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a + b + c");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a * (b * c)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a * b * c");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a / (b / c)");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 1, NULL );
ASTNode_free(p);
p = SBML_parseFormula("a / b / c");
c = ASTNode_getLeftChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
c = ASTNode_getRightChild(p);
fail_unless( FormulaFormatter_isGrouped(p, c) == 0, NULL );
ASTNode_free(p);
}
void printReactions(Model_t *m, FILE *f)
{
int i,j,k;
Reaction_t *r;
SpeciesReference_t *sref;
KineticLaw_t *kl;
Rule_t *rl;
AssignmentRule_t *asr;
AlgebraicRule_t *alr;
RateRule_t *rr;
Event_t *e;
EventAssignment_t *ea;
Parameter_t *p;
FunctionDefinition_t *fd;
SBMLTypeCode_t type;
const ASTNode_t *math;
math = NULL;
fprintf(f, "\n");
for(i=0;i<Model_getNumParameters(m);i++){
if(i==0)
fprintf(f, "# Global parameters:\n");
p = Model_getParameter(m,i);
if(Parameter_isSetId(p))
fprintf(f, "%s ", Parameter_getId(p));
if(Parameter_isSetName(p))
fprintf(f, "(%s) ", Parameter_getName(p));
if(Parameter_isSetValue(p))
fprintf(f, "= %g; ", Parameter_getValue(p));
if(Parameter_isSetUnits(p))
fprintf(f, "[%s]; ", Parameter_getUnits(p));
if(!Parameter_getConstant(p))
fprintf(f, "(variable);");
fprintf(f, "\n");
if ( i==Model_getNumParameters(m)-1 )
fprintf(f, "\n");
}
fprintf(f, "# Reactions:\n");
for ( i=0; i<Model_getNumReactions(m); i++ ) {
r = Model_getReaction(m,i);
fprintf(f, "%s: %s",
Reaction_isSetName(r) ? Reaction_getName(r) : Reaction_getId(r),
Reaction_getFast(r) ? "(fast)" : "");
for ( k=0; k<Reaction_getNumReactants(r); k++ ) {
sref = Reaction_getReactant(r,k);
if ( SpeciesReference_isSetStoichiometryMath(sref) )
fprintf(f, "%s ",
SBML_formulaToString(\
SpeciesReference_getStoichiometryMath(sref)));
else
if ( SpeciesReference_getStoichiometry(sref) != 1. )
fprintf(f, "%g ", SpeciesReference_getStoichiometry(sref));
fprintf(f, "%s", SpeciesReference_getSpecies(sref));
if(k+1<Reaction_getNumReactants(r))
fprintf(f, "%s", " + ");
}
fprintf(f, "%s", Reaction_getReversible(r) ? " <-> " : " -> ");
for ( k=0; k<Reaction_getNumProducts(r); k++ ) {
sref = Reaction_getProduct(r,k);
if ( SpeciesReference_isSetStoichiometryMath(sref) )
fprintf(f, "%s ",
SBML_formulaToString(\
SpeciesReference_getStoichiometryMath(sref)));
else
if ( SpeciesReference_getStoichiometry(sref) != 1. )
fprintf(f, "%g ", SpeciesReference_getStoichiometry(sref));
fprintf(f, "%s", SpeciesReference_getSpecies(sref));
if(k+1<Reaction_getNumProducts(r))
fprintf(f, "%s", " + ");
}
fprintf(f, "; ");
if(Reaction_isSetKineticLaw(r)){
kl = Reaction_getKineticLaw(r);
math = KineticLaw_getMath(kl);
fprintf(f, "%s;", SBML_formulaToString(math));
for(k=0;k<KineticLaw_getNumParameters(kl);k++){
p = KineticLaw_getParameter(kl,k);
fprintf(f, " %s", Parameter_getId(p));
if(Parameter_isSetName(p))
fprintf(f, " (%s)", Parameter_getName(p));
if(Parameter_isSetValue(p))
fprintf(f, " = %g", Parameter_getValue(p));
if(Parameter_isSetUnits(p))
fprintf(f, " [%s]", Parameter_getUnits(p));
if ( !Parameter_getConstant(p) )
fprintf(f, " (variable)");
fprintf(f, ";");
}
/* fprintf(f, "\n"); */
}else
fprintf(f, "# no rate law is set for this reaction.");
fprintf(f, "\n");
}
for(i=0;i<Model_getNumRules(m);i++){
rl = Model_getRule(m,i);
if ( i == 0 ) {
fprintf(f, "# Rules:\n");
}
type = SBase_getTypeCode((SBase_t *)rl);
if ( type == SBML_RATE_RULE ) {
rr = (RateRule_t *) rl;
fprintf(f, " rateRule: d%s/dt = ", RateRule_getVariable(rr));
}
if ( type == SBML_ALGEBRAIC_RULE ) {
alr = (AlgebraicRule_t *) rl;
fprintf(f, " algebraicRule: 0 = ");
}
if ( type == SBML_ASSIGNMENT_RULE ) {
asr = (AssignmentRule_t *) rl;
fprintf(f, " assignmentRule (%s): %s = ",
RuleType_toString(AssignmentRule_getType(asr)),
AssignmentRule_getVariable(asr));
}
if(!Rule_isSetMath(rl)){
if(Rule_isSetFormula(rl)){
Rule_setMathFromFormula(rl);
}
}
if(Rule_isSetMath(rl))
fprintf(f, "%s\n", SBML_formulaToString(Rule_getMath(rl)));
}
fprintf(f, "\n");
for(i=0;i<Model_getNumEvents(m);i++){
if(i==0)
fprintf(f, "# Events:\n");
e = Model_getEvent(m,i);
if(Event_isSetId(e))
fprintf(f, "%s: ", Event_getId(e));
if(Event_isSetName(e))
fprintf(f, "(%s) ", Event_getName(e));
if(Event_isSetTrigger(e)) {
math = Event_getTrigger(e);
fprintf(f, "trigger: %s\n", SBML_formulaToString(math));
}
if(Event_isSetDelay(e))
fprintf(f, "delay: %s;\n", SBML_formulaToString(Event_getDelay(e)));
if(Event_isSetTimeUnits(e))
fprintf(f, "time Units: %s;\n", Event_getTimeUnits(e));
for(k=0;k<Event_getNumEventAssignments(e);k++){
ea = Event_getEventAssignment(e,k);
if(EventAssignment_isSetVariable(ea))
fprintf(f, " event: %s = %s;\n",
EventAssignment_getVariable(ea),
EventAssignment_isSetMath(ea) ?
SBML_formulaToString(EventAssignment_getMath(ea)) :
"# no math set;\n");
}
if(i==Model_getNumEvents(m)-1)
fprintf(f, "\n");
}
for ( i=0; i<Model_getNumFunctionDefinitions(m); i++ ) {
if ( i==0 ) fprintf(f, "# Functions:\n");
fd = Model_getFunctionDefinition(m,i);
if ( FunctionDefinition_isSetName(fd) )
fprintf(f, "%s: ", FunctionDefinition_getName(fd));
if(FunctionDefinition_isSetId(fd) && FunctionDefinition_isSetMath(fd)){
fprintf(f, "%s( ", FunctionDefinition_getId(fd));
math = FunctionDefinition_getMath(fd);
for(j=0;j<ASTNode_getNumChildren(math)-1;j++){
fprintf(f, "%s", SBML_formulaToString(ASTNode_getChild(math, j)));
if(j<ASTNode_getNumChildren(math)-2)
fprintf(f, ", ");
if(j==ASTNode_getNumChildren(math)-2)
fprintf(f, ") = ");
}
fprintf(f, "%s;", SBML_formulaToString(ASTNode_getRightChild(math)));
}
fprintf(f, "\n");
}
}
void ev_alter_tree_structure(Model_t *m, ASTNode_t **node_p, ASTNode_t *parent, int child_order, copied_AST *cp_AST){
ASTNode_t *zero_node;
ASTNode_t *node, *next_node;
ASTNode_t *pc_eq, *pc_cd, *times_node, *and_node, *not_node;
unsigned int i, j;
int p;
ASTNode_t *arg_node_list[MAX_ARG_NUM];
unsigned int arg_node_num;
FunctionDefinition_t *fd;
ASTNode_t *fd_arg;
ASTNode_t *fd_body;
node = *node_p;
for(i=0; i<ASTNode_getNumChildren(node); i++){
next_node = ASTNode_getChild(node, i);
if(ASTNode_getNumChildren(node) == 1 && ASTNode_getType(node) == AST_MINUS){
zero_node = ASTNode_create();
ASTNode_setType(zero_node, AST_REAL);
ASTNode_setReal(zero_node, 0);
ASTNode_replaceChild(node, 0, zero_node);
ASTNode_addChild(*node_p, next_node);
}else{
ev_alter_tree_structure(m, &next_node, *node_p, i, cp_AST);
}
}
if(ASTNode_getType(node) == AST_FUNCTION){
arg_node_num = ASTNode_getNumChildren(node);
for(i=0; i<arg_node_num; i++){
arg_node_list[i] = ASTNode_getChild(node, i);
}
for(i=0; i<Model_getNumFunctionDefinitions(m); i++){
fd = (FunctionDefinition_t*)ListOf_get(Model_getListOfFunctionDefinitions(m), i);
fd_body = (ASTNode_t*)FunctionDefinition_getBody(fd);
if(strcmp(FunctionDefinition_getId(fd), ASTNode_getName(node)) == 0){
fd_body = ASTNode_deepCopy(fd_body);
cp_AST->ast[cp_AST->num_of_copied_AST++] = fd_body;
for(j=0; j<FunctionDefinition_getNumArguments(fd); j++){
fd_arg = (ASTNode_t*)FunctionDefinition_getArgument(fd, j);
ASTNode_replaceArgument(fd_body, (char*)ASTNode_getName(fd_arg), arg_node_list[j]);
}
/* check_AST(fd_body, NULL); */
if(parent != NULL){
ASTNode_replaceChild(parent, child_order, fd_body);
}else{
*node_p = fd_body;
}
node = *node_p;
break;
}
}
}
if(ASTNode_getType(node) == AST_FUNCTION_PIECEWISE){
ASTNode_setType(node, AST_PLUS);
ASTNode_setName(node, NULL);
times_node = ASTNode_createWithType(AST_TIMES);
pc_eq = ASTNode_getRightChild(node);
ASTNode_addChild(times_node, pc_eq);
if(ASTNode_getNumChildren(node) > 3){
and_node = ASTNode_createWithType(AST_LOGICAL_AND);
ASTNode_addChild(times_node, and_node);
for(p=(int)ASTNode_getNumChildren(node)-2; p >= 1; p = p-2){
pc_cd = ASTNode_getChild(node, p);
not_node = ASTNode_createWithType(AST_LOGICAL_NOT);
ASTNode_addChild(not_node, pc_cd);
ASTNode_addChild(and_node, not_node);
}
ASTNode_reduceToBinary(and_node);
}else{
pc_cd = ASTNode_getChild(node, 1);
not_node = ASTNode_createWithType(AST_LOGICAL_NOT);
ASTNode_addChild(not_node, pc_cd);
ASTNode_addChild(times_node, not_node);
}
ASTNode_replaceChild(node, ASTNode_getNumChildren(node)-1, times_node);
for(p=ASTNode_getNumChildren(node)-2; p >= 1; p = p-2){
times_node = ASTNode_createWithType(AST_TIMES);
pc_eq = ASTNode_getChild(node, p-1);
pc_cd = ASTNode_getChild(node, p);
ASTNode_addChild(times_node, pc_eq);
ASTNode_addChild(times_node, ASTNode_deepCopy(pc_cd));
ASTNode_removeChild(node, p);
ASTNode_replaceChild(node ,p-1, times_node);
}
ASTNode_reduceToBinary(node);
}
return;
}
