public double Execute(MathParserTermResult term, params object[] parameters)
{
Double.TryParse(
term.Term, System.Globalization.NumberStyles.AllowDecimalPoint,
System.Globalization.NumberFormatInfo.InvariantInfo,
out var number);
return(number);
}
public List <MathParserTermResult> Parse(string expression, bool allowParameters = false)
{
var terms = new List <MathParserTermResult>();
if (String.IsNullOrWhiteSpace(expression))
{
throw new ArgumentNullException("Expression cannot be empty!");
}
var i = 0;
while (i < expression.Length)
{
MathParserTermResult term = null;
if (Char.IsDigit(expression[i]))
{
term = new NumberTermParser().Parse(expression, i);
}
else
if (OperatorTermParser.IsOperator(expression[i]))
{
term = new OperatorTermParser().Parse(expression, i);
}
else
if (Char.IsLetter(expression[i]))
{
term = new FunctionOrConstTermParser().Parse(expression, i);
}
else
if (SubExpressionTermParser.IsOpenParenthesis(expression[i]))
{
term = new SubExpressionTermParser().Parse(expression, i);
}
else
if (allowParameters && expression[i] == ',')
{
i++;
continue;
}
if (term != null)
{
i = term.EndPos;
terms.Add(term);
}
else
{
throw new InvalidOperationException($"Wrong character '{expression[i]}' at [{i}]!");
}
}
return(terms);
}
public MathParserTermValidationResult Validate(MathParserTermResult term)
{
var result = new MathParserTermValidationResult();
if (!IsOperator(term.Term[0]))
{
result.AddError($"'{term.Term}' was not recognized as valid operator!");
}
return(result);
}
public MathParserTermValidationResult Validate(MathParserTermResult term)
{
var result = new MathParserTermValidationResult();
if (!_context.CheckConst(term.Term))
{
result.AddError($"Const with name {term.Term} was not declared!");
}
return(result);
}
public MathParserTermValidationResult Validate(MathParserTermResult term)
{
var result = new MathParserTermValidationResult();
var parameters = (term as ComplexMathParserResult).NumberOfParams;
var expectedParameters = _context.GetFunction(term.Term).ParamsNumber;
if (parameters != expectedParameters)
{
result.AddError($"Function {term.Term} expects {expectedParameters} but got {parameters}!");
}
return(result);
}
public MathParserTermValidationResult Validate(MathParserTermResult term)
{
var result = new MathParserTermValidationResult();
if (String.IsNullOrWhiteSpace(term.Term))
{
result.AddError("Term should not be empty!");
}
if (!Double.TryParse(term.Term, System.Globalization.NumberStyles.AllowDecimalPoint, System.Globalization.NumberFormatInfo.InvariantInfo, out var number))
{
result.AddError($"Cannot convert {term.Term} to number!");
}
return(result);
}
public double Execute(MathParserTermResult term, params object[] parameters)
{
if (parameters.Length != 1)
{
throw new InvalidOperationException("Operator needs at least 1 parameters to execute!");
}
var stack = parameters[0] as Stack <double>;
if (stack.Count < 2)
{
throw new InvalidOperationException($"Operator '{term.Term}' needs 2 parameters to execute!");
}
var number1 = stack.Pop();
var number2 = stack.Pop();
switch (term.Term)
{
case "+":
return(number1 + number2);
case "-":
return(number2 - number1);
case "*":
return(number1 * number2);
case "/":
return(number2 / number1);
case "^":
return(Math.Pow(number2, number1));
default:
throw new InvalidOperationException("Probably wrong operation has been applied!");
}
}
public double Execute(MathParserTermResult term, params object[] parameters)
{
if (parameters.Length != 1)
{
throw new InvalidOperationException("Function needs at least 1 parameters to execute!");
}
var stack = parameters[0] as Stack <double>;
var descriptor = _context.GetFunction(term.Term);
var i = descriptor.ParamsNumber;
object[] functionParams = new object[descriptor.ParamsNumber];
while (i > 0)
{
if (stack.TryPop(out var number))
{
functionParams[--i] = number;
}
}
return((double)descriptor.Function.DynamicInvoke(functionParams));
}
public double Execute(MathParserTermResult term, params object[] parameters)
{
return(_context.GetConst(term.Term));
}
