public void EvaluateComputesTheValue()
{
var parser = new ParzEngine(
toLevelTokens: tokens => tokens
.AggregateByQuotationMarks(LambdaDefaults.QuotationMarks)
.ToLevelTokens(),
separators: LambdaDefaults
.QuotationMarks
.Concat(FuncDefaults.FunctionSeparators)
.Concat(Defaults.Separators),
tokenFactory: new AggregateTokenFactory(
new ConstantNumberParser(),
new OperatorParser(),
new OpenerParser(),
new CloserParser(),
new SeparatorParser(),
new FunctionParser("avg", "sum", "min", "max"),
new LambdaExpressionParser(),
new VariableParser()),
nodeConverter: new AggregateNodeConverter(
new OpenerNodeConverter(),
new BinaryOperatorNodeConverter(),
new UnaryOperatorNodeConverter(),
new FunctionNodeConverter(),
new ConstantNumberNodeConverter(),
new VariableNodeConverter(),
new LambdaExpressionNodeConverter()));
var expression = "1 + 3 / 5 +(52/3 + (-5))+56 * min(4, 3, 6 * 2 ,7) + min(0 + max(1, min(2, min(3, 4))))";
var result = parser.Parse(expression);
var decimalResult = Evaluate(result);
Assert.Equal(183.93333333333333333333333333m, decimalResult);
}
public void Test5()
{
var equalsOperator = new[] { "==" };
var exponentialOperator = new[] { "^" };
var extraOpeners = new[] { "<" };
var extraClosers = new[] { ">" };
var parser = new ParzEngine(
toLevelTokens: tokens => tokens
.AggregateByQuotationMarks(LambdaDefaults.QuotationMarks)
.ToLevelTokens(
Defaults.Openers.Concat(extraOpeners),
Defaults.Closers.Concat(extraClosers)),
separators: FuncDefaults
.FunctionSeparators
.Concat(LambdaDefaults.LambdaSeparators)
.Concat(equalsOperator)
.Concat(exponentialOperator)
.Concat(Defaults.Separators)
.Concat(extraOpeners)
.Concat(extraClosers),
tokenFactory: new AggregateTokenFactory(
new ConstantNumberParser(),
new OperatorParser(Defaults.OperatorSymbols
.Concat(equalsOperator)
.Concat(exponentialOperator)),
new OpenerParser(Defaults.Openers
.Concat(extraOpeners)),
new CloserParser(Defaults.Closers
.Concat(extraClosers)),
new SeparatorParser(),
new FunctionParser("avg", "sum", "min", "max"),
new LambdaExpressionParser(),
new VariableParser()),
nodeConverter: new AggregateNodeConverter(
new OpenerNodeConverter(),
new BinaryOperatorNodeConverter(Defaults.Operators
.AddEntry(equalsOperator.First(), -1)
.AddEntry(exponentialOperator.Single(), 2)
.ToDictionary(Defaults.StringEqualityComparer)),
new UnaryOperatorNodeConverter(),
new FunctionNodeConverter(),
new ConstantNumberNodeConverter(),
new VariableNodeConverter(),
new LambdaExpressionNodeConverter()));
//var expression = "min(avg('t => t.Money >= 500'), allValues) ^ 2";
//var expression = "(5+4)*max(4,-1-5.3435345,'t => cenas',sum(4.323,5,dasdasd,5,ddd,4))";
var expression = "(5+4)*max(4,-1-5.3435345,'t => a.Coisas == \"cenas\"',sum(4.323,5,dasdasd,5,ddd,4))";
//var expression = "(5+4)*max(--3----5)+max(4,-1-5.3435345,'t => cenas',sum(asd+4.32*3,5,dasdasd,5,ddd,4))";
//var expression = "((5+4)*(--3----5))-4--1-5.3435345+(4.32*3-5+4)+(4---(4*3)*--5)";
//var expression = "(5+4)*max(--3----5)+max(4,-1-5.3435345,avg(3,57,8),sum(4.32*3,5,4))";
//var expression = "(5+4)*sum(5,8*avg(4,5,-------6,7),9,15)";
var result = parser.Parse(expression);
var variableNames = result
.GetAll <VariableNode>()
.Select(t => t.Symbol)
.ToList();
var values = new Dictionary <string, int>
{
{ "dasdasd", 69 },
{ "ddd", 42 }
};
var replaced = result
.ReplaceNodes <VariableNode>(t => new ConstantNumberNode(values[t.Symbol]))
.ReplaceNodes <LambdaExpressionNode>(t => new NodeArrayNode(new INode[]
{
new ConstantNumberNode(5m),
new ConstantNumberNode(900m),
new ConstantNumberNode(8m),
}));
var root = new Root <string>(replaced, "banana");
var lel = JsonConvert.SerializeObject(root);
var resultDecimal = Evaluate(root.RootNode);
var asObj = JsonConvert.DeserializeObject <Root <string> >(lel);
}
