private void button1_Click(object sender, EventArgs e)
{
var parsedFunc = new ParsedFunction();
parsedFunc.StringToParse = " ";
parsedFunc.VariableNames = new List <string> {
"x", "y", "z"
};
parsedFunc.ParameterNames = new List <string> {
"p1", "p2"
};
parsedFunc.ParameterValues = new[] { 0.0, 0.0 };
var errorData = new FuncParserErrorData();
parsedFunc.Parse(errorData);
if (errorData.ErrorNumber == errNumber.err_OK)
{
MessageBox.Show(this, "That wasn't supposed to happen");
}
else
{
MessageBox.Show(this, $"Error is on purpose. The error is {errorData.ErrorNumber}");
}
}
private void ParseFunctions(string fileContents)
{
MatchCollection matches = FUNCTION_REGEX.Matches(fileContents);
// Report on each match.
foreach (Match match in matches)
{
// group[0] is the whole mathed string
// group[1] is filled with "native " (yes with spaces) if the function is a native function
bool isNative = match.Groups[1].Length != 0;
// group[2] is the return type
// there are cases where a return statement function call with 0 parameters is parsed as a function
// skip these false positives
string returnType = match.Groups[2].Value;
if (returnType == "return")
{
continue;
}
// group[3] is the function name
string name = match.Groups[3].Value;
// group[4] contains all the parameters in the form
// (type name, type name, type name, ...)
string allParameters = match.Groups[4].Value.Trim();
ParsedFunction function = new ParsedFunction(isNative, returnType, name, allParameters);
functions.Add(function);
}
}
public ExplicitFormulaParser(IEnumerable <string> variableNames, IEnumerable <string> parameterNames, ParsedFunction parserFunction)
{
_parserFunc = parserFunction;
_parserFunc.SetVariableNames(variableNames.ToList());
_parserFunc.SetParameterNames(parameterNames.ToList());
_parserFunc.LogicalNumericMixAllowed = true;
_parserFunc.LogicOperatorsAllowed = true;
_parserFunc.SimplifyParametersAllowed = true;
}
public void should_return_correct_value_when_partly_simplified(string stringToParse, double expectedValue)
{
var partlySimplifiedParsedFunction = new ParsedFunction();
partlySimplifiedParsedFunction.UpdateFrom(sut);
partlySimplifiedParsedFunction.StringToParse = stringToParse;
partlySimplifiedParsedFunction.SetParametersNotToSimplify(new[] { "p1" });
partlySimplifiedParsedFunction.CalcExpression(_arguments).ShouldBeEqualTo(expectedValue);
}
public void should_return_correct_value_when_not_simplified(string stringToParse, double expectedValue)
{
var notSimplifiedParsedFunction = new ParsedFunction();
notSimplifiedParsedFunction.UpdateFrom(sut);
notSimplifiedParsedFunction.SimplifyParametersAllowed = false;
notSimplifiedParsedFunction.StringToParse = stringToParse;
notSimplifiedParsedFunction.CalcExpression(_arguments).ShouldBeEqualTo(expectedValue);
}
// override object.Equals
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
ParsedFunction other = (ParsedFunction)obj;
return(this.Name == other.Name);
}
static void Test3()
{
var pf = new ParsedFunction();
var stringsToParse = new[] { "1e-3", "1.25e-4", "-2.2e-2", "1e+3", "1.25e+2", "-2.2e+2" };
foreach (var stringToParse in stringsToParse)
{
pf.StringToParse = stringToParse;
pf.Parse();
var d = pf.CalcExpression(null);
Console.WriteLine($"f({stringToParse}) = {d}");
}
}
protected override void Context()
{
_parsedFunction = new ParsedFunction();
_variableNames = new List <string> {
_var1, _var2
};
_parameterNames = new List <string> {
_par1, _par2
};
_variableValues = new[] { 1.0, 2.0 };
_parameterValues = new[] { 3.0, 4.0 };
sut = new ExplicitFormulaParser(_variableNames, _parameterNames, _parsedFunction);
}
static void Test1()
{
var startTime = DateTime.UtcNow;
const int NUMBER_ITERATIONS = 100;
const int NUMBER_VARIABLES = 100;
var variableNames = new List <string>();
var variableValues = new List <double>();
var stringToParse = "";
for (var variableIdx = 1; variableIdx <= NUMBER_VARIABLES; variableIdx++)
{
var variable = $"V{variableIdx}";
variableNames.Add(variable);
stringToParse += variable + (variableIdx < NUMBER_VARIABLES ? "+" : "");
variableValues.Add(variableIdx);
}
for (var iterationIdx = 0; iterationIdx < NUMBER_ITERATIONS; iterationIdx++)
{
var pf = new ParsedFunction();
pf.SetVariableNames(variableNames);
pf.StringToParse = stringToParse;
//pf.Parse();
var xmlString = pf.GetXMLString();
double value = pf.CalcExpression(variableValues);
pf = null;
}
var endTime = DateTime.UtcNow;
TimeSpan timeDiff = endTime - startTime;
Console.WriteLine($"Duration = {timeDiff.TotalSeconds} seconds");
// Console.WriteLine($"{value}\n{xmlString}\n");
}
static void Test2()
{
double p1 = 1, p2 = 2, p3 = 3, x = 3, y = 4;
var pf = new ParsedFunction();
var caseSensitive = pf.CaseSensitive;
pf.CaseSensitive = !caseSensitive;
caseSensitive = pf.CaseSensitive;
Console.WriteLine($"CaseSensitive={caseSensitive}");
pf.SetVariableNames(new[] { "x", "y" });
pf.SetParameterNames(new[] { "p1", "p2", "p3" });
pf.SetParameterValues(new[] { p1, p2, p3 });
pf.SetParametersNotToSimplify(new[] { "p3" });
pf.SimplifyParametersAllowed = true;
pf.LogicOperatorsAllowed = false;
pf.LogicalNumericMixAllowed = false;
pf.ComparisonTolerance = 0.1;
pf.StringToParse = "2*p1+3*p2+p3+x*y";
var stringToParse = pf.StringToParse;
pf.Parse();
Console.WriteLine("Parse: OK");
var value = pf.CalcExpression(new[] { x, y });
Console.WriteLine($"p1={p1} p2={p2} p3={p3} x={x} y={y}\n");
Console.WriteLine($"{stringToParse} = {value}\n");
var xmlString = pf.GetXMLString();
Console.WriteLine($"{xmlString}\n");
pf = null;
pf = new ParsedFunction();
pf.SetVariableNames(new[] { "x", "y" });
pf.StringToParse = "x+t";
pf.Parse();
}
public virtual string evaluate(bool wrapStringFunctionResults)
{
string rtnResult = null;
// Get the left operand.
string leftResultString = null;
double?leftResultDouble = null;
if (leftOperand is ExpressionTree)
{
leftResultString = ((ExpressionTree)leftOperand).evaluate(wrapStringFunctionResults);
try
{
leftResultDouble = Convert.ToDouble(leftResultString);
leftResultString = null;
}
catch (System.FormatException)
{
leftResultDouble = null;
}
}
else if (leftOperand is ExpressionOperand)
{
ExpressionOperand leftExpressionOperand = (ExpressionOperand)leftOperand;
leftResultString = leftExpressionOperand.Value;
leftResultString = evaluator.replaceVariables(leftResultString);
if (!evaluator.isExpressionString(leftResultString))
{
try
{
leftResultDouble = Convert.ToDouble(leftResultString);
leftResultString = null;
}
catch (System.FormatException nfe)
{
throw new EvaluationException("Expression is invalid.", nfe);
}
if (leftExpressionOperand.UnaryOperator != null)
{
leftResultDouble = new double?(leftExpressionOperand.UnaryOperator.evaluate(leftResultDouble.Value));
}
}
else
{
if (leftExpressionOperand.UnaryOperator != null)
{
throw new EvaluationException("Invalid operand for " + "unary operator.");
}
}
}
else if (leftOperand is ParsedFunction)
{
ParsedFunction parsedFunction = (ParsedFunction)leftOperand;
Function function = parsedFunction.Function;
string arguments = parsedFunction.Arguments;
arguments = evaluator.replaceVariables(arguments);
if (evaluator.ProcessNestedFunctions)
{
arguments = evaluator.processNestedFunctions(arguments);
}
try
{
FunctionResult functionResult = function.execute(evaluator, arguments);
leftResultString = functionResult.Result;
if (functionResult.Type == FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC)
{
double?resultDouble = Convert.ToDouble(leftResultString);
if (parsedFunction.UnaryOperator != null)
{
resultDouble = new double?(parsedFunction.UnaryOperator.evaluate(resultDouble.Value));
}
// Get the final result.
leftResultString = resultDouble.ToString();
}
else if (functionResult.Type == FunctionConstants.FUNCTION_RESULT_TYPE_STRING)
{
// The result must be a string result.
if (wrapStringFunctionResults)
{
leftResultString = evaluator.QuoteCharacter + leftResultString + evaluator.QuoteCharacter;
}
if (parsedFunction.UnaryOperator != null)
{
throw new EvaluationException("Invalid operand for " + "unary operator.");
}
}
}
catch (FunctionException fe)
{
throw new EvaluationException(fe.Message, fe);
}
if (!evaluator.isExpressionString(leftResultString))
{
try
{
leftResultDouble = Convert.ToDouble(leftResultString);
leftResultString = null;
}
catch (System.FormatException nfe)
{
throw new EvaluationException("Expression is invalid.", nfe);
}
}
}
else
{
if (leftOperand != null)
{
throw new EvaluationException("Expression is invalid.");
}
}
// Get the right operand.
string rightResultString = null;
double?rightResultDouble = null;
if (rightOperand is ExpressionTree)
{
rightResultString = ((ExpressionTree)rightOperand).evaluate(wrapStringFunctionResults);
try
{
rightResultDouble = Convert.ToDouble(rightResultString);
rightResultString = null;
}
catch (System.FormatException)
{
rightResultDouble = null;
}
}
else if (rightOperand is ExpressionOperand)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final ExpressionOperand rightExpressionOperand = (ExpressionOperand) rightOperand;
ExpressionOperand rightExpressionOperand = (ExpressionOperand)rightOperand;
rightResultString = ((ExpressionOperand)rightOperand).Value;
rightResultString = evaluator.replaceVariables(rightResultString);
// Check if the operand is a string or not. If it not a string,
// then it must be a number.
if (!evaluator.isExpressionString(rightResultString))
{
try
{
rightResultDouble = Convert.ToDouble(rightResultString);
rightResultString = null;
}
catch (System.FormatException nfe)
{
throw new EvaluationException("Expression is invalid.", nfe);
}
if (rightExpressionOperand.UnaryOperator != null)
{
rightResultDouble = new double?(rightExpressionOperand.UnaryOperator.evaluate(rightResultDouble.Value));
}
}
else
{
if (rightExpressionOperand.UnaryOperator != null)
{
throw new EvaluationException("Invalid operand for " + "unary operator.");
}
}
}
else if (rightOperand is ParsedFunction)
{
ParsedFunction parsedFunction = (ParsedFunction)rightOperand;
Function function = parsedFunction.Function;
string arguments = parsedFunction.Arguments;
arguments = evaluator.replaceVariables(arguments);
if (evaluator.ProcessNestedFunctions)
{
arguments = evaluator.processNestedFunctions(arguments);
}
try
{
FunctionResult functionResult = function.execute(evaluator, arguments);
rightResultString = functionResult.Result;
if (functionResult.Type == FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC)
{
double?resultDouble = Convert.ToDouble(rightResultString);
// Process a unary operator if one exists.
if (parsedFunction.UnaryOperator != null)
{
resultDouble = new double?(parsedFunction.UnaryOperator.evaluate(resultDouble.Value));
}
// Get the final result.
rightResultString = resultDouble.ToString();
}
else if (functionResult.Type == FunctionConstants.FUNCTION_RESULT_TYPE_STRING)
{
// The result must be a string result.
if (wrapStringFunctionResults)
{
rightResultString = evaluator.QuoteCharacter + rightResultString + evaluator.QuoteCharacter;
}
if (parsedFunction.UnaryOperator != null)
{
throw new EvaluationException("Invalid operand for " + "unary operator.");
}
}
}
catch (FunctionException fe)
{
throw new EvaluationException(fe.Message, fe);
}
if (!evaluator.isExpressionString(rightResultString))
{
try
{
rightResultDouble = Convert.ToDouble(rightResultString);
rightResultString = null;
}
catch (System.FormatException nfe)
{
throw new EvaluationException("Expression is invalid.", nfe);
}
}
}
else if (rightOperand == null)
{
// Do nothing.
}
else
{
throw new EvaluationException("Expression is invalid.");
}
// Evaluate the the expression.
if (leftResultDouble != null && rightResultDouble != null)
{
double doubleResult = @operator.evaluate(leftResultDouble.Value, rightResultDouble.Value);
if (UnaryOperator != null)
{
doubleResult = UnaryOperator.evaluate(doubleResult);
}
rtnResult = (new double?(doubleResult)).ToString();
}
else if (!string.ReferenceEquals(leftResultString, null) && !string.ReferenceEquals(rightResultString, null))
{
rtnResult = @operator.evaluate(leftResultString, rightResultString);
}
else if (leftResultDouble != null && rightResultDouble == null)
{
double doubleResult = -1;
if (unaryOperator != null)
{
doubleResult = unaryOperator.evaluate(leftResultDouble.Value);
}
else
{
// Do not allow numeric (left) and
// string (right) to be evaluated together.
throw new EvaluationException("Expression is invalid.");
}
rtnResult = (new double?(doubleResult)).ToString();
}
else
{
throw new EvaluationException("Expression is invalid.");
}
return(rtnResult);
}
private string getResult(Stack operatorStack, Stack operandStack, bool wrapStringFunctionResults)
{
// The result to return.
string resultString = null;
// Process the rest of the operators left on the stack.
while (operatorStack.Count > 0)
{
processTree(operandStack, operatorStack);
}
if (operandStack.Count != 1)
{
throw new EvaluationException("Expression is invalid.");
}
object finalOperand = operandStack.Pop();
// Check if the final operand is a tree.
if (finalOperand is ExpressionTree)
{
// Get the final result.
resultString = ((ExpressionTree)finalOperand).evaluate(wrapStringFunctionResults);
}
// Check if the final operand is an operand.
else if (finalOperand is ExpressionOperand)
{
ExpressionOperand resultExpressionOperand = (ExpressionOperand)finalOperand;
resultString = ((ExpressionOperand)finalOperand).Value;
resultString = replaceVariables(resultString);
// Check if the operand is a string or not. If it not a string,
// then it must be a number.
if (!isExpressionString(resultString))
{
double?resultDouble = null;
try
{
resultDouble = Convert.ToDouble(resultString);
}
catch (Exception e)
{
throw new EvaluationException("Expression is invalid.", e);
}
// Process a unary operator if one exists.
if (resultExpressionOperand.UnaryOperator != null)
{
resultDouble = new double?(resultExpressionOperand.UnaryOperator.evaluate(resultDouble.Value));
}
// Get the final result.
resultString = resultDouble.ToString();
}
else
{
if (resultExpressionOperand.UnaryOperator != null)
{
throw new EvaluationException("Invalid operand for " + "unary operator.");
}
}
}
else if (finalOperand is ParsedFunction)
{
ParsedFunction parsedFunction = (ParsedFunction)finalOperand;
Function function = parsedFunction.Function;
string arguments = parsedFunction.Arguments;
if (processNestedFunctions_Renamed)
{
arguments = processNestedFunctions(arguments);
}
arguments = replaceVariables(arguments);
// Get the final result.
try
{
FunctionResult functionResult = function.execute(this, arguments);
resultString = functionResult.Result;
if (functionResult.Type == FunctionConstants.FUNCTION_RESULT_TYPE_NUMERIC)
{
double?resultDouble = Convert.ToDouble(resultString);
// Process a unary operator if one exists.
if (parsedFunction.UnaryOperator != null)
{
resultDouble = new double?(parsedFunction.UnaryOperator.evaluate(resultDouble.Value));
}
// Get the final result.
resultString = resultDouble.ToString();
}
else if (functionResult.Type == FunctionConstants.FUNCTION_RESULT_TYPE_STRING)
{
// The result must be a string result.
if (wrapStringFunctionResults)
{
resultString = quoteCharacter + resultString + quoteCharacter;
}
if (parsedFunction.UnaryOperator != null)
{
throw new EvaluationException("Invalid operand for " + "unary operator.");
}
}
}
catch (FunctionException fe)
{
throw new EvaluationException(fe.Message, fe);
}
}
else
{
throw new EvaluationException("Expression is invalid.");
}
return(resultString);
}
private NextOperator processFunction(string expression, int operatorIndex, Stack operandStack)
{
int parenthesisCount = 1;
NextOperator nextOperator = null;
int nextOperatorIndex = operatorIndex;
// Loop until we find the function's closing parentheses.
while (parenthesisCount > 0)
{
nextOperator = getNextOperator(expression, nextOperatorIndex + 1, null);
if (nextOperator == null)
{
throw new EvaluationException("Function is not closed.");
}
else if (nextOperator.Operator is OpenParenthesesOperator)
{
parenthesisCount++;
}
else if (nextOperator.Operator is ClosedParenthesesOperator)
{
parenthesisCount--;
}
// Get the next operator index.
nextOperatorIndex = nextOperator.Index;
}
string arguments = expression.Substring(operatorIndex + 1, nextOperatorIndex - (operatorIndex + 1));
// Pop the function name from the stack.
ExpressionOperand operand = (ExpressionOperand)operandStack.Pop();
Operator unaryOperator = operand.UnaryOperator;
string functionName = operand.Value;
// Validate that the function name is valid.
try
{
isValidName(functionName);
}
catch (System.ArgumentException iae)
{
throw new EvaluationException("Invalid function name of \"" + functionName + "\".", iae);
}
// Get the function object.
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final net.sourceforge.jeval.function.Function function = (net.sourceforge.jeval.function.Function) functions.get(functionName);
Function function = (Function)functions[functionName];
if (function == null)
{
throw new EvaluationException("A function is not defined (index=" + operatorIndex + ").");
}
ParsedFunction parsedFunction = new ParsedFunction(function, arguments, unaryOperator);
operandStack.Push(parsedFunction);
return(nextOperator);
}
private void ParseFunctions(string fileContents)
{
MatchCollection matches = FUNCTION_REGEX.Matches(fileContents);
// Report on each match.
foreach (Match match in matches)
{
// group[0] is the whole mathed string
// group[1] is filled with "native " (yes with spaces) if the function is a native function
bool isNative = match.Groups[1].Length != 0;
// group[2] is the return type
// there are cases where a return statement function call with 0 parameters is parsed as a function
// skip these false positives
string returnType = match.Groups[2].Value;
if (returnType == "return")
{
continue;
}
// group[3] is the function name
string name = match.Groups[3].Value;
// group[4] contains all the parameters in the form
// (type name, type name, type name, ...)
string allParameters = match.Groups[4].Value.Trim();
ParsedFunction function = new ParsedFunction(isNative, returnType, name, allParameters);
functions.Add(function);
}
}