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);
}
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);
}
/**
* @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
L3FormulaFormatter_isGrouped (const ASTNode_t *parent, const ASTNode_t *child, const L3ParserSettings_t *settings)
{
int pp, cp;
int pt, ct;
int group = 0;
int parentmodulo = 0;
if (parent != NULL)
{
parentmodulo = isTranslatedModulo(parent);
if (parentmodulo || !L3FormulaFormatter_isFunction(parent, settings))
{
group = 1;
pp = getL3Precedence(parent);
cp = getL3Precedence(child);
if (pp < cp)
{
group = 0;
}
else if (pp == cp)
{
if (parentmodulo) {
//Always group: x * y % z -> (x * y) % z
group = 1;
}
/**
* Don't group only if i) child is the first on the list and ii) both parent and
* child are the same type, or if they
* should be associative operators (i.e. not AST_MINUS or
* AST_DIVIDE). That is, do not group a parent and left child
* that are either both AST_PLUS or both AST_TIMES operators, nor the logical operators
* that have the same precedence.
*/
if (ASTNode_getLeftChild(parent) == child)
{
pt = ASTNode_getType(parent);
ct = ASTNode_getType(child);
if (ASTNode_isLogical(parent) || ASTNode_isRelational(parent)) {
group = !(pt == ct);
}
else {
group = !((pt == ct) || (pt == AST_PLUS || pt == AST_TIMES));
}
}
}
else if (pp==7 && cp==6) {
//If the parent is 'power' and the child is 'unary not' or 'unary minus', we only need
// to group if the child is the *left* child: '(-x)^y', but 'x^-y'.
if (!(ASTNode_getLeftChild(parent) == child)) {
group = 0;
}
}
}
}
return group;
}
/**
* Formats the given ASTNode as an SBML L3 function name and appends the
* result to the given StringBuffer.
*/
void
L3FormulaFormatter_formatFunction (StringBuffer_t *sb, const ASTNode_t *node, const L3ParserSettings_t *settings)
{
ASTNodeType_t type = ASTNode_getType(node);
switch (type)
{
case AST_PLUS:
StringBuffer_append(sb, "plus");
break;
case AST_TIMES:
StringBuffer_append(sb, "times");
break;
case AST_MINUS:
StringBuffer_append(sb, "minus");
break;
case AST_DIVIDE:
StringBuffer_append(sb, "divide");
break;
case AST_POWER:
StringBuffer_append(sb, "pow");
break;
case AST_FUNCTION_LN:
StringBuffer_append(sb, "ln");
break;
default:
FormulaFormatter_formatFunction(sb, node);
break;
}
}
/**
* Formats the given ASTNode as an SBML L3 token and appends the result to
* the given StringBuffer.
*/
void
L3FormulaFormatter_format (StringBuffer_t *sb, const ASTNode_t *node, const L3ParserSettings_t *settings)
{
if (sb == NULL) return;
if (L3FormulaFormatter_isFunction(node, settings))
{
L3FormulaFormatter_formatFunction(sb, node, settings);
}
else if (ASTNode_isOperator(node) || ASTNode_getType(node) == AST_FUNCTION_POWER)
{
L3FormulaFormatter_formatOperator(sb, node);
}
else if (ASTNode_isLogical(node) || ASTNode_isRelational(node))
{
L3FormulaFormatter_formatLogicalRelational(sb, node);
}
else if (ASTNode_isRational(node))
{
L3FormulaFormatter_formatRational(sb, node, settings);
}
else if (ASTNode_isInteger(node))
{
L3FormulaFormatter_formatReal(sb, node, settings);
}
else if (ASTNode_isReal(node))
{
L3FormulaFormatter_formatReal(sb, node, settings);
}
else if ( !ASTNode_isUnknown(node) )
{
StringBuffer_append(sb, ASTNode_getName(node));
}
}
/**
* Since graphviz will interpret identical names as referring to
* the same node presentation-wise it is better if each function node
* has a unique name.
*
* Returns the name of the function with the name of the first child
* prepended
*
* THIS COULD BE DONE BETTER
*/
char *
FormulaGraphvizFormatter_FunctionGetUniqueName (const ASTNode_t *node)
{
char *s;
StringBuffer_t *p = StringBuffer_create(128);
ASTNodeType_t type = ASTNode_getType(node);
if (ASTNode_getNumChildren(node) != 0)
{
const char* name = ASTNode_getName(ASTNode_getChild(node,0));
if (name != NULL)
StringBuffer_append(p, name);
}
else
{
StringBuffer_append(p, "unknown");
}
switch (type)
{
case AST_FUNCTION_ARCCOS:
StringBuffer_append(p, "acos");
break;
case AST_FUNCTION_ARCSIN:
StringBuffer_append(p, "asin");
break;
case AST_FUNCTION_ARCTAN:
StringBuffer_append(p, "atan");
break;
case AST_FUNCTION_CEILING:
StringBuffer_append(p, "ceil");
break;
case AST_FUNCTION_LN:
StringBuffer_append(p, "log");
break;
case AST_FUNCTION_POWER:
StringBuffer_append(p, "pow");
break;
default:
if (ASTNode_getName(node) != NULL)
{
StringBuffer_append(p, ASTNode_getName(node));
}
break;
}
s = StringBuffer_toString(p);
free(p);
return s;
}
/**
* @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;
}
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);
}
/**
* Formats the given ASTNode as a directed graph function name and returns the
* result as a string.
*/
char *
FormulaGraphvizFormatter_formatFunction (const ASTNode_t *node)
{
char *s;
StringBuffer_t *p = StringBuffer_create(128);
ASTNodeType_t type = ASTNode_getType(node);
switch (type)
{
case AST_FUNCTION_ARCCOS:
s = "acos";
break;
case AST_FUNCTION_ARCSIN:
s = "asin";
break;
case AST_FUNCTION_ARCTAN:
s = "atan";
break;
case AST_FUNCTION_CEILING:
s = "ceil";
break;
case AST_FUNCTION_LN:
s = "log";
break;
case AST_FUNCTION_POWER:
s = "pow";
break;
default:
if (ASTNode_getName(node) == NULL)
{
StringBuffer_append(p, "unknown");
}
else
{
StringBuffer_append(p, ASTNode_getName(node));
}
s = StringBuffer_toString(p);
break;
}
free(p);
return s;
}
END_TEST
START_TEST (test_SBML_parseFormula_2)
{
ASTNode_t *r = SBML_parseFormula("2.1");
fail_unless( ASTNode_getType (r) == AST_REAL, NULL );
fail_unless( ASTNode_getReal (r) == 2.1, NULL );
fail_unless( ASTNode_getNumChildren(r) == 0, NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_1)
{
ASTNode_t *r = SBML_parseFormula("1");
fail_unless( ASTNode_getType (r) == AST_INTEGER, NULL );
fail_unless( ASTNode_getInteger (r) == 1, NULL );
fail_unless( ASTNode_getNumChildren(r) == 0, NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_negZero)
{
ASTNode_t *r = SBML_parseFormula("-0.0");
fail_unless( ASTNode_getType(r) == AST_REAL, NULL );
fail_unless( util_isNegZero(ASTNode_getReal(r)) == 1, NULL );
fail_unless( ASTNode_getNumChildren(r) == 0, NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_negInf)
{
ASTNode_t *r = SBML_parseFormula("-inf");
fail_unless( ASTNode_getType(r) == AST_REAL, NULL );
fail_unless( util_isInf(ASTNode_getReal(r)) == -1, NULL );
fail_unless( ASTNode_getNumChildren(r) == 0, NULL );
ASTNode_free(r);
}
END_TEST
START_TEST (test_SBML_parseFormula_13)
{
ASTNode_t *r = SBML_parseFormula("foo()");
fail_unless( ASTNode_getType(r) == AST_FUNCTION , NULL );
fail_unless( !strcmp(ASTNode_getName(r), "foo") , NULL );
fail_unless( ASTNode_getNumChildren(r) == 0 , NULL );
ASTNode_free(r);
}
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_3)
{
ASTNode_t *r = SBML_parseFormula("2.1e5");
fail_unless( ASTNode_getType (r) == AST_REAL_E, NULL );
fail_unless( ASTNode_getMantissa (r) == 2.1, NULL );
fail_unless( ASTNode_getExponent (r) == 5, NULL );
fail_unless( ASTNode_getNumChildren(r) == 0, NULL );
ASTNode_free(r);
}
void post_ev_alter_tree_structure(Model_t *m, ASTNode_t **node_p, ASTNode_t *parent, int child_order){
ASTNode_t *divide_node, *times_node;
ASTNode_t *compartment_node;
ASTNode_t *node, *next_node;
unsigned int i;
Species_t *sp;
node = *node_p;
for(i=0; i<ASTNode_getNumChildren(node); i++){
next_node = ASTNode_getChild(node, i);
post_ev_alter_tree_structure(m, &next_node, *node_p, i);
}
if(ASTNode_getType(node) == AST_NAME){
for(i=0; i<Model_getNumSpecies(m); i++){
sp = (Species_t*)ListOf_get(Model_getListOfSpecies(m), i);
if(strcmp(Species_getId(sp), ASTNode_getName(node)) == 0){
if(!Species_getHasOnlySubstanceUnits(sp) && Compartment_getSpatialDimensions(Model_getCompartmentById(m, Species_getCompartment(sp))) != 0){/* use val/comp in calculation */
divide_node = ASTNode_createWithType(AST_DIVIDE);
compartment_node = ASTNode_createWithType(AST_NAME);
ASTNode_setName(compartment_node, Compartment_getId(Model_getCompartmentById(m, Species_getCompartment(sp))));
ASTNode_addChild(divide_node, node);
ASTNode_addChild(divide_node, compartment_node);
if(parent != NULL){
ASTNode_replaceChild(parent, child_order, divide_node);
}else{
*node_p = divide_node;
}
node = *node_p;
break;
}else if(Species_getHasOnlySubstanceUnits(sp) && Species_isSetInitialConcentration(sp) && Compartment_getSpatialDimensions(Model_getCompartmentById(m, Species_getCompartment(sp))) != 0){/* use val*comp in calculation */
times_node = ASTNode_createWithType(AST_TIMES);
compartment_node = ASTNode_createWithType(AST_NAME);
ASTNode_setName(compartment_node, Compartment_getId(Model_getCompartmentById(m, Species_getCompartment(sp))));
ASTNode_addChild(times_node, node);
ASTNode_addChild(times_node, compartment_node);
if(parent != NULL){
ASTNode_replaceChild(parent, child_order, times_node);
}else{
*node_p = times_node;
}
node = *node_p;
break;
}
}
}
}
return;
}
/**
* Formats the given ASTNode as a real number and appends the result to
* the given StringBuffer.
*/
void
L3FormulaFormatter_formatReal (StringBuffer_t *sb, const ASTNode_t *node, const L3ParserSettings_t *settings)
{
double value = ASTNode_getReal(node);
int sign;
char * units;
if (ASTNode_isInteger(node)) {
value = ASTNode_getInteger(node);
}
if (util_isNaN(value))
{
StringBuffer_append(sb, "NaN");
}
else if ((sign = util_isInf(value)) != 0)
{
if (sign == -1)
{
StringBuffer_appendChar(sb, '-');
}
StringBuffer_append(sb, "INF");
}
else if (util_isNegZero(value))
{
StringBuffer_append(sb, "-0");
}
else
{
if (ASTNode_getType(node) == AST_REAL_E)
{
StringBuffer_appendExp(sb, value);
}
else
{
StringBuffer_appendReal(sb, value);
}
}
if (L3ParserSettings_getParseUnits(settings)) {
if (ASTNode_hasUnits(node)) {
StringBuffer_appendChar( sb, ' ');
units = ASTNode_getUnits(node);
StringBuffer_append( sb, units);
safe_free(units);
}
}
}
/**
* Formats the given ASTNode as an SBML L1 operator and appends the result
* to the given StringBuffer.
*/
void
L3FormulaFormatter_formatOperator (StringBuffer_t *sb, const ASTNode_t *node)
{
ASTNodeType_t type = ASTNode_getType(node);
if (type == AST_FUNCTION_POWER ||
type == AST_POWER) {
StringBuffer_appendChar(sb, '^');
}
else
{
StringBuffer_appendChar(sb, ' ');
StringBuffer_appendChar(sb, ASTNode_getCharacter(node));
StringBuffer_appendChar(sb, ' ');
}
}
/**
* Formats the given ASTNode as an SBML L1 operator and appends the result
* to the given StringBuffer.
*/
void
FormulaFormatter_formatOperator (StringBuffer_t *sb, const ASTNode_t *node)
{
ASTNodeType_t type = ASTNode_getType(node);
if (type != AST_POWER)
{
StringBuffer_appendChar(sb, ' ');
}
StringBuffer_appendChar(sb, ASTNode_getCharacter(node));
if (type != AST_POWER)
{
StringBuffer_appendChar(sb, ' ');
}
}
/**
* Formats the given ASTNode as an SBML L1 operator and appends the result
* to the given StringBuffer.
*/
void
L3FormulaFormatter_formatLogicalRelational (StringBuffer_t *sb, const ASTNode_t *node)
{
ASTNodeType_t type = ASTNode_getType(node);
StringBuffer_appendChar(sb, ' ');
switch(type)
{
case AST_LOGICAL_AND:
StringBuffer_append(sb, "&&");
break;
case AST_LOGICAL_OR:
StringBuffer_append(sb, "||");
break;
case AST_RELATIONAL_EQ:
StringBuffer_append(sb, "==");
break;
case AST_RELATIONAL_GEQ:
StringBuffer_append(sb, ">=");
break;
case AST_RELATIONAL_GT:
StringBuffer_append(sb, ">");
break;
case AST_RELATIONAL_LEQ:
StringBuffer_append(sb, "<=");
break;
case AST_RELATIONAL_LT:
StringBuffer_append(sb, "<");
break;
case AST_RELATIONAL_NEQ:
StringBuffer_append(sb, "!=");
break;
case AST_LOGICAL_NOT:
case AST_LOGICAL_XOR:
default:
//Should never be called for these cases; unary not is
// handled by checking unary not earlier; xor always
// claims that it's a function, and is caught with 'isFunction'
assert(0);
StringBuffer_append(sb, "!!");
break;
}
StringBuffer_appendChar(sb, ' ');
}
void pre_ev_alter_tree_structure(ASTNode_t **node_p, ASTNode_t *parent, int child_order, ASTNode_t *delay_math){
unsigned int i;
ASTNode_t *node, *next_node, *delay_node;
node = *node_p;
for(i=0; i<ASTNode_getNumChildren(node); i++){
next_node = ASTNode_getChild(node, i);
pre_ev_alter_tree_structure(&next_node, *node_p, i, delay_math);
}
if(ASTNode_getType(node) == AST_NAME){
delay_node = ASTNode_createWithType(AST_FUNCTION_DELAY);
ASTNode_addChild(delay_node, node);
ASTNode_addChild(delay_node, delay_math);
if(parent != NULL){
ASTNode_replaceChild(parent, child_order, delay_node);
}else{
*node_p = delay_node;
}
}
}
/**
* Formats the given ASTNode as a directed graph operator and returns the result
* as a string.
*/
char *
FormulaGraphvizFormatter_formatOperator (const ASTNode_t *node)
{
char *s;
ASTNodeType_t type = ASTNode_getType(node);
StringBuffer_t *p = StringBuffer_create(128);
switch (type)
{
case AST_TIMES:
s = "times";
break;
case AST_DIVIDE:
s = "divide";
break;
case AST_PLUS:
s = "plus";
break;
case AST_MINUS:
s = "minus";
break;
case AST_POWER:
s = "power";
break;
default:
StringBuffer_appendChar(p, ASTNode_getCharacter(node));
s = StringBuffer_toString(p);
break;
}
free(p);
return s;
}
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);
}
/**
* Formats the given ASTNode as an SBML L1 function name and appends the
* result to the given StringBuffer.
*/
void
FormulaFormatter_formatFunction (StringBuffer_t *sb, const ASTNode_t *node)
{
ASTNodeType_t type = ASTNode_getType(node);
switch (type)
{
case AST_FUNCTION_ARCCOS:
StringBuffer_append(sb, "acos");
break;
case AST_FUNCTION_ARCSIN:
StringBuffer_append(sb, "asin");
break;
case AST_FUNCTION_ARCTAN:
StringBuffer_append(sb, "atan");
break;
case AST_FUNCTION_CEILING:
StringBuffer_append(sb, "ceil");
break;
case AST_FUNCTION_LN:
StringBuffer_append(sb, "log");
break;
case AST_FUNCTION_POWER:
StringBuffer_append(sb, "pow");
break;
default:
StringBuffer_append(sb, ASTNode_getName(node));
break;
}
}
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;
}
/**
* Formats the given ASTNode as a real number and appends the result to
* the given StringBuffer.
*/
void
FormulaFormatter_formatReal (StringBuffer_t *sb, const ASTNode_t *node)
{
double value = ASTNode_getReal(node);
int sign;
if (util_isNaN(value))
{
StringBuffer_append(sb, "NaN");
}
else if ((sign = util_isInf(value)) != 0)
{
if (sign == -1)
{
StringBuffer_appendChar(sb, '-');
}
StringBuffer_append(sb, "INF");
}
else if (util_isNegZero(value))
{
StringBuffer_append(sb, "-0");
}
else
{
if (ASTNode_getType(node) == AST_REAL_E)
{
StringBuffer_appendExp(sb, value);
}
else
{
StringBuffer_appendReal(sb, value);
}
}
}
/**
* Since graphviz will interpret identical names as referring to
* the same node presentation-wise it is better if each function node
* has a unique name.
*
* Returns the name of the operator with the name of the first child
* prepended
*
* THIS COULD BE DONE BETTER
*/
char *
FormulaGraphvizFormatter_OperatorGetUniqueName (const ASTNode_t *node)
{
char *s;
char number[10];
StringBuffer_t *p = StringBuffer_create(128);
ASTNodeType_t type = ASTNode_getType(node);
if (FormulaGraphvizFormatter_isFunction(ASTNode_getChild(node,0))
|| ASTNode_isOperator(ASTNode_getChild(node,0)))
{
StringBuffer_append(p, "func");
}
else
{
if (ASTNode_isInteger(ASTNode_getChild(node, 0)))
{
sprintf(number, "%d", (int)ASTNode_getInteger(ASTNode_getChild(node, 0)));
StringBuffer_append(p, number);
}
else if (ASTNode_isReal(ASTNode_getChild(node, 0)))
{
sprintf(number, "%ld", ASTNode_getNumerator(ASTNode_getChild(node, 0)));
StringBuffer_append(p, number);
}
else
{
StringBuffer_append(p, ASTNode_getName(ASTNode_getChild(node,0)));
}
}
switch (type)
{
case AST_TIMES:
StringBuffer_append(p, "times");
break;
case AST_DIVIDE:
StringBuffer_append(p, "divide");
break;
case AST_PLUS:
StringBuffer_append(p, "plus");
break;
case AST_MINUS:
StringBuffer_append(p, "minus");
break;
case AST_POWER:
StringBuffer_append(p, "power");
break;
default:
StringBuffer_appendChar(p, ASTNode_getCharacter(node));
break;
}
s = StringBuffer_toString(p);
free(p);
return s;
}
void _prepare_reversible_fast_reaction(Model_t *m, myASTNode *myNode, myReaction *re, mySpecies *sp[], myParameter *param[], myCompartment *comp[], myReaction *re_whole[], double sim_time, double dt, double *time, myInitialAssignment *initAssign[], char *time_variant_target_id[], unsigned int num_of_time_variant_targets, timeVariantAssignments *timeVarAssign, char *target_id, int p_or_r, allocated_memory *mem){
ASTNode_t *minus_node, *zero_node, *final_eq_node;
myASTNode *eq_root_node;
int minus_sign;
if(myNode->left != NULL){
_prepare_reversible_fast_reaction(m, myNode->left, re, sp, param, comp, re_whole, sim_time, dt, time, initAssign, time_variant_target_id, num_of_time_variant_targets, timeVarAssign, target_id, p_or_r, mem);
}
if(myNode->right != NULL){
_prepare_reversible_fast_reaction(m, myNode->right, re, sp, param, comp, re_whole, sim_time, dt, time, initAssign, time_variant_target_id, num_of_time_variant_targets, timeVarAssign, target_id, p_or_r, mem);
}
if(ASTNode_getType(myNode->origin) == AST_NAME){
if(strcmp(ASTNode_getName(myNode->origin), target_id) == 0){
ASTNode_setType(myNode->origin, AST_INTEGER);
ASTNode_setInteger(myNode->origin, 1);
eq_root_node = myNode;
minus_sign = 1;
while(eq_root_node->parent != NULL){
if(ASTNode_getType(eq_root_node->parent->origin) != AST_TIMES
&& ASTNode_getType(eq_root_node->parent->origin) != AST_DIVIDE){
if(ASTNode_getType(eq_root_node->parent->origin) == AST_MINUS
&& eq_root_node->parent->right == eq_root_node){
minus_sign *= -1;
}
if(eq_root_node->parent->parent != NULL){
if(eq_root_node->parent->parent->left == eq_root_node->parent){
eq_root_node->parent->parent->left = eq_root_node;
}else{
eq_root_node->parent->parent->right = eq_root_node;
}
eq_root_node->parent = eq_root_node->parent->parent;
}else{
eq_root_node->parent = NULL;
break;
}
}else{
eq_root_node = eq_root_node->parent;
}
}
final_eq_node = eq_root_node->origin;
TRACE(("myASTNode is\n"));
check_myAST(eq_root_node);
ASTNode_recreate(eq_root_node, final_eq_node);
if(minus_sign == -1){
minus_node = ASTNode_createWithType(AST_MINUS);
zero_node = ASTNode_createWithType(AST_INTEGER);
ASTNode_setInteger(zero_node, 0);
ASTNode_addChild(minus_node, zero_node);
ASTNode_addChild(minus_node, final_eq_node);
final_eq_node = minus_node;
}
if(p_or_r == 0){/* products coefficient */
TRACE(("AST of product numerator is\n"));
check_AST(final_eq_node, NULL);
re->products_equili_numerator->math_length = get_equation(m, re->products_equili_numerator, sp, param, comp, re_whole, final_eq_node, 0, sim_time, dt, time, initAssign, time_variant_target_id, num_of_time_variant_targets, timeVarAssign, mem);
}else{/* reactants coefficient */
minus_node = ASTNode_createWithType(AST_MINUS);
zero_node = ASTNode_createWithType(AST_INTEGER);
ASTNode_setInteger(zero_node, 0);
ASTNode_addChild(minus_node, zero_node);
ASTNode_addChild(minus_node, final_eq_node);
final_eq_node = minus_node;
TRACE(("AST of reactant numerator is\n"));
check_AST(final_eq_node, NULL);
re->reactants_equili_numerator->math_length = get_equation(m, re->reactants_equili_numerator, sp, param, comp, re_whole, final_eq_node, 0, sim_time, dt, time, initAssign, time_variant_target_id, num_of_time_variant_targets, timeVarAssign, mem);
}
}
}
}
