public FormulaParser(Reader.SBMLReader reader, String formula, Model model)
{
this.formula = formula;
this.reader = reader;
this.model = model;
model.InterrogateModelForMissingIDs();
// Init the collection list
this.formulaSpecies = new List<Species>();
this.formulaParameters = new List<Parameter>();
this.formulaUnknownEntities = new List<UnknownEntity>();
// Init the operators
this.init();
this.formulaTree = this.makeFormulaTree(formula, false);
}
public FormulaParser(Reader.SBMLReader reader, String formula)
{
this.formula = formula;
this.reader = reader;
// Init the collection list
this.formulaSpecies = new List<Species>();
this.formulaParameters = new List<Parameter>();
this.formulaUnknownEntities = new List<UnknownEntity>();
// Init the operators
this.init();
// Make the formula tree
this.formulaTree = this.makeFormulaTree(formula, false);
// no Model, so can't look up ID references
// (mainly for testing purposes)
}
/// <summary>
/// Constructor that includes an experiment and simulation reference which is used for formulas with aggregate functions
/// that use references to cell definitions, groups and species
/// </summary>
/// <param name="reader">
/// A <see cref="Reader.SBMLReader"/>
/// </param>
/// <param name="formula">
/// A <see cref="String"/>
/// </param>
/// <param name="model">
/// A <see cref="Model"/>
/// </param>
/// <param name="experiment">
/// A <see cref="Experiment"/>
/// </param>
/// <param name="simulation">
/// A <see cref="Simulation"/>
/// </param>
public FormulaParser(Reader.SBMLReader reader, String formula, Model model, Experiment experiment, Simulation simulation)
{
this.formula = formula;
this.reader = reader;
model.InterrogateModelForMissingIDs();
//create model list
this.models = new List<Model>();
models.Add(model);
// Init the collection list
this.formulaSpecies = new List<Species>();
this.formulaParameters = new List<Parameter>();
this.formulaUnknownEntities = new List<UnknownEntity>();
// Init the operators
this.init();
this.experiment = experiment;
this.simulation = simulation;
this.formulaTree = this.makeFormulaTree(formula, true);
}
private MathTree joinTrees(InnerNode op, LeafNode leaf1)
{
MathTree math = new MathTree(op, leaf1);
return math;
}
private MathTree joinTrees(InnerNode op, MathTree subtree1)
{
MathNode root1 = subtree1.root;
MathTree math = new MathTree(op, root1);
return math;
}
private MathTree joinTrees(InnerNode op, MathTree subtree1, MathTree subtree2)
{
MathNode root1 = subtree1.root;
MathNode root2 = subtree2.root;
// create new tree with op as the root, and root1, root2
// as the two child nodes
MathTree math = new MathTree(op, root2, root1);
return math;
}
private MathTree makeFormulaTree(String formula, bool aggregateVariables)
{
// Approximate regexp of tokens
// Fix - 06/03/2008 - Dorchard
// First clause from: [a-zA-Z_]+
// to: [a-zA-Z][a-zA-Z0-9_]*
// Allows variables with numbers but which must start with at least one letter
Regex formulaRegexp;
if (aggregateVariables)
{
formulaRegexp = new Regex("([a-zA-Z_][a-zA-Z0-9_.]*)|([0-9]+([.][0-9]+)?)|([0-9]+)|[+-/*^| \t]|[()]");
}
else
{
formulaRegexp = new Regex("([a-zA-Z_][a-zA-Z0-9_]*)|([0-9]+([.][0-9]+)?)|([0-9]+)|[+-/*^| \t]|[()]");
}
foreach(Match match in formulaRegexp.Matches(formula))
{
// Get the matched token
String token = match.ToString();
//System.Console.WriteLine(token);
// Look at idtable
//foreach (Object o in model.IdTable.Keys)
//{
// System.Console.WriteLine(o.ToString()+" - "+model.IdTable[o].ToString());
//}
if (token == " ")
{
// just whitespace, ignore
continue;
}
// If we are parsing a formula that takes aggregate variables
if (aggregateVariables && !token.Contains("."))
{
// Create aggreaget node first
AggregateReferenceNode operand = new AggregateReferenceNode(this.experiment, this.simulation);
if (!TryParseAggregateSpecies(operand, token))
{
if (!TryParseAggregateGroup(operand, token))
{
if(TryParseAggregateCellDefinition(operand, token))
{
// Just a cell def
operandStack.Push(operand);
continue;
}
}
else
{
// Just a group
operandStack.Push(operand);
continue;
}
}
else
{
// Just species
operandStack.Push(operand);
continue;
}
}
// if token is a number
// or a name that will evaluate to a number (in ID table)
// push to operand stack
double d = 0.0d;
if (double.TryParse(token, out d)) {
NumberLeafNode operand = new NumberLeafNode();
operand.AddData(token);
operandStack.Push(operand);
}
// some kind of split reference
else if (aggregateVariables && token.Contains("."))
{
// Create aggreaget node first
AggregateReferenceNode operand = new AggregateReferenceNode(this.experiment, this.simulation);
string[] tokens = token.Split('.');
if(tokens.Length==1)
{
System.Console.WriteLine("Parse error in formula - "+formula+" at token - "+token);
}
else if (tokens.Length==2)
{
// Try a group
if (!TryParseAggregateGroup(operand, tokens[0]))
{
// Try a celldef
if (!TryParseAggregateCellDefinition(operand, tokens[0]))
{
// If this failed then error
System.Console.WriteLine("Parse error in formula - CellDefinition/Group not found: "+tokens[0]);
}
else
{
// Starts with a celldef, could be a group of celldef
if (!TryParseAggregateGroup(operand, tokens[1]))
{
// must be a species
if (TryParseAggregateSpecies(operand, tokens[1]))
{
// CellDef.Species
operandStack.Push(operand);
}
else
{
// Fail
System.Console.WriteLine("Parse error in formula - Species not found: "+tokens[1]);
}
}
else
{
// Was a group, ok
// CellDef.Group
operandStack.Push(operand);
}
}
}
else
{
// Starts with a group
// Must therefore be a species
if (TryParseAggregateSpecies(operand, tokens[1]))
{
// Group.Species
operandStack.Push(operand);
}
else
{
// Fail
System.Console.WriteLine("Parse error in formula - Species not found: "+tokens[1]);
}
}
}
else if (tokens.Length==3)
{
// should be CellDef.Group.Species
if (TryParseAggregateCellDefinition(operand, tokens[0]))
{
if (TryParseAggregateGroup(operand, tokens[1]))
{
if (TryParseAggregateSpecies(operand, tokens[2]))
{
operandStack.Push(operand);
}
else
{
System.Console.WriteLine("Parse error in formula - Species not found: "+tokens[2]);
}
}
else
{
System.Console.WriteLine("Parse error in formula - Group not found: "+tokens[1]);
}
}
else
{
System.Console.WriteLine("Parse error in formula - CellDef not found: "+tokens[0]);
}
}
else
{
// Too many periods
System.Console.WriteLine("Parse error in formula - "+formula+" at token - "+token);
}
}
else if ((model != null) && (model.idExists(token)))
{
ReferenceLeafNode operand = new ReferenceLeafNode();
operand.AddData(token, model);
operandStack.Push(operand);
if (operand.data is Parameter)
{
this.formulaParameters.Add((Parameter)operand.data);
}
if (operand.data is Species)
{
this.formulaSpecies.Add((Species)operand.data);
}
}
else if (reader.unaryMathOperatorsLookup.ContainsKey(token))
{
// function call, push to stack
InnerNode functionNode = new InnerNode(reader.unaryMathOperatorsLookup[token]);
operatorStack.Push(functionNode);
// Cannot be user-defined FunctionDefinition, because
// string formulae and FunctionDefinitions are in
// mutually exclusive SBML Levels.
}
else if (reader.binaryMathOperatorsLookup.ContainsKey(token) && !opPrecedence.ContainsKey(token))
{
// function call, push to stack
InnerNode functionNode = new InnerNode(reader.binaryMathOperatorsLookup[token]);
operatorStack.Push(functionNode);
}
else if (opPrecedence.ContainsKey(token))
{
// While there is an operator on the top of the stack
while (operatorStack.Count>0 && operatorStack.Peek() is InnerNode)
{
InnerNode op2 = (InnerNode)operatorStack.Peek();
int op2Precedence = (int)opPrecedence[op2.data];
int tokenPrecedence = (int)opPrecedence[token];
if (op2Precedence > tokenPrecedence)
{
// pop, build new subtree, push to operand stack
operatorStack.Pop();
buildNewSubtree(op2);
}
else
{
break;
}
}
// create token as new OperatorNode
if (reader.binaryMathOperatorsLookup.ContainsKey(token))
{
BinaryMathOperators op = reader.binaryMathOperatorsLookup[token];
InnerNode opToken = new InnerNode(op);
// push token to operator stack
operatorStack.Push(opToken);
}
else if (reader.unaryMathOperatorsLookup.ContainsKey(token))
{
UnaryMathOperators op = reader.unaryMathOperatorsLookup[token];
InnerNode opToken = new InnerNode(op);
// push token to operator stack
operatorStack.Push(opToken);
}
else
{
// <todo> raise parse exception </todo>
}
}
else if (token == "(")
{
operatorStack.Push(token);
}
else if (token == ")")
{
while (operatorStack.Count>0 && !((operatorStack.Peek() is string) && ((string)operatorStack.Peek())=="("))
{
// pop operator, build new subtree, push to operand stack
InnerNode op = (InnerNode)operatorStack.Pop();
buildNewSubtree(op);
}
// remove the "(" from the stack
Object o = operatorStack.Pop();
// check if top of stack is a function call
// if so, pop, build new subtree, push to operand stack
if (operatorStack.Count>0 && (reader.unaryMathOperatorsLookup.ContainsValue((UnaryMathOperators)(((InnerNode)(operatorStack.Peek())).data)) ||
reader.binaryMathOperatorsLookup.ContainsValue((BinaryMathOperators)(((InnerNode)(operatorStack.Peek())).data))))
{
InnerNode op = (InnerNode)operatorStack.Pop();
buildNewSubtree(op);
}
}
else
{
Regex checkAlpha = new Regex("[a-zA-Z_][a-zA-Z0-9_.]*");
Match matchAlpha = checkAlpha.Match(token);
// Approximate test of unknown token
if (!matchAlpha.Success)
{
// Likely some unknown or badly formatted symbols
// No recognition - parse error
// <todo>Raise exception?</todo>
System.Console.WriteLine("Parse error in formula - " + formula + " at token - " + token);
}
else
{
// Potentially an unknown ID try and add as an unknown identifier and try to continue parsing
ReferenceLeafNode operand = new ReferenceLeafNode();
operand.data = new UnknownEntity();
operand.data.ID = token;
operandStack.Push(operand);
this.formulaUnknownEntities.Add((UnknownEntity)operand.data);
System.Console.WriteLine("Unknown entity in formula - " + token);
}
}
}
// We have now reached the end of the tokens.
// Pop the rest of the operators.
while (operatorStack.Count>0)
{
InnerNode op = (InnerNode)operatorStack.Pop();
buildNewSubtree(op);
}
// No more operators.
MathTree math;
// if we just have a leaf node on the stack convert it to a mathtree
if (operandStack.Peek() is LeafNode)
{
math = new MathTree();
math.root = (LeafNode)operandStack.Pop();
}
else
{
math = (MathTree)operandStack.Pop();
}
// debug();
return math;
}
/// <summary>
/// Constructor that includes an experiment and simulation reference which is used for formulas with aggregate functions
/// that use references to cell definitions, groups and species and also a list of all models used
/// </summary>
/// <param name="reader">
/// A <see cref="Reader.SBMLReader"/>
/// </param>
/// <param name="formula">
/// A <see cref="String"/>
/// </param>
/// <param name="models">
/// A <see cref="List`1"/>
/// </param>
/// <param name="experiment">
/// A <see cref="Experiment"/>
/// </param>
/// <param name="simulation">
/// A <see cref="Simulation"/>
/// </param>
public FormulaParser(Reader.SBMLReader reader, String formula, List<Model> models, Experiment experiment, Simulation simulation)
{
this.formula = formula;
this.reader = reader;
this.models = models;
foreach (Model model in models)
{
model.InterrogateModelForMissingIDs();
}
// Init the operators
this.init();
this.experiment = experiment;
this.simulation = simulation;
this.formulaTree = this.makeFormulaTree(formula, true);
}
public new void AddProperties(MathTree stoichiometryMath)
{
this.math = stoichiometryMath;
}
public void AddProperties(MathTree math)
{
this.math = math;
}
