public ParseError EvaluateExpression(string expression, List<VariableInfo> variables,
out double result)
{
if(string.IsNullOrEmpty(expression)) {
throw new ArgumentNullException("Expression was not defined.");
}
// ------------------------------------------------------- */
result = 0;
try {
MathParser parser = new MathParser();
// Add the received variables before starting the evaluation.
foreach(VariableInfo varInfo in variables) {
parser.Variables.Add(varInfo.Name, varInfo.Value);
}
// Parse and evalute the received expression.
InitializeParser(parser);
parser.BuildExpression(expression);
result = parser.Evaluate();
}
catch(ParseException pe) {
return pe.Error;
}
catch(Exception e) {
return new ParseError(TargetType.Other, string.Empty);
}
return new ParseError(TargetType.None, string.Empty);
}
public override double Evaluate(MathParser parser)
{
return Math.Atan(parser.Pop());
}
public override double Evaluate(MathParser parser)
{
double newBase = parser.Pop();
return Math.Log(parser.Pop(), newBase);
}
public abstract double Evaluate(MathParser parser);
public override double Evaluate(MathParser parser)
{
double a = parser.Pop();
double b = parser.Pop();
return a + b;
}
public override double Evaluate(MathParser parser)
{
double a = parser.Pop();
double b = parser.Pop();
return Math.Pow(b, a);
}
public List<OperatorInfo> GetAvailableOperators()
{
List<OperatorInfo> list = new List<OperatorInfo>();
MathParser parser = new MathParser();
InitializeParser(parser);
foreach(KeyValuePair<char, MathOperator> kvp in parser.Operators) {
list.Add(new OperatorInfo() { HelpString = kvp.Value.HelpString,
Symbol = kvp.Key });
}
return list;
}
public List<FunctionInfo> GetAvailableFunctions()
{
List<FunctionInfo> list = new List<FunctionInfo>();
MathParser parser = new MathParser();
InitializeParser(parser);
foreach(KeyValuePair<string, MathFunction> kvp in parser.Functions) {
list.Add(new FunctionInfo() { HelpString = kvp.Value.HelpString,
Name = kvp.Key });
}
return list;
}
private void InitializeParser(MathParser parser)
{
// Add the available operators.
parser.AddOperator(new AddOperator());
parser.AddOperator(new SubstractOperator());
parser.AddOperator(new MultiplyOperator());
parser.AddOperator(new DivideOperator());
parser.AddOperator(new ExponentialOperator());
// Add the available functions.
parser.AddFunction(new SinFunction());
parser.AddFunction(new CosFunction());
parser.AddFunction(new TanFunction());
parser.AddFunction(new AtanFunction());
parser.AddFunction(new AbsFunction());
parser.AddFunction(new MinFunction());
parser.AddFunction(new MaxFunction());
parser.AddFunction(new SqrtFunction());
parser.AddFunction(new LogFunction());
parser.AddFunction(new LnFunction());
parser.AddFunction(new Log10Function());
parser.AddFunction(new SignFunction());
parser.AddFunction(new CeilFunction());
parser.AddFunction(new FloorFunction());
// Add the available constants.
parser.AddVariable("PI", Math.PI);
parser.AddVariable("E", Math.E);
}
public List<VariableInfo> GetAvailableVariables()
{
List<VariableInfo> list = new List<VariableInfo>();
MathParser parser = new MathParser();
InitializeParser(parser);
foreach(KeyValuePair<string, double> kvp in parser.Variables) {
list.Add(new VariableInfo() { Value = kvp.Value,
Name = kvp.Key });
}
return list;
}
