public static ExpressionVariable CreateExpressionVariable(int ruleVariableId)
{
ExpressionVariable expressionVariable = new ExpressionVariable();
expressionVariable.RuleVariableId = ruleVariableId;
return(expressionVariable);
}
IExpression ParsePrimary()
{
IExpression result;
var lex = _lexicalScanner.Current;
switch (lex.Type)
{
case LexicalScanResultType.Numeric:
result = new ExpressionLiteral(lex.Value);
break;
case LexicalScanResultType.Variable:
result = new ExpressionVariable(lex.Value);
break;
case LexicalScanResultType.BracketOpen:
result = ParseExpression();
if (_lexicalScanner.Current == null)
{
throw new IndexOutOfRangeException();
}
else if (_lexicalScanner.Current.Type != LexicalScanResultType.BracketClose)
{
throw new NotSupportedException($"Not expected expression {_lexicalScanner.Current.Value}, expected ')'");
}
break;
case LexicalScanResultType.Function:
var name = _lexicalScanner.Current.Value;
var args = new List <IExpression>();
while (_lexicalScanner.Current != null && _lexicalScanner.Current.Type != LexicalScanResultType.BracketClose)
{
args.Add(ParseExpression());
}
_lexicalScanner.Next();
result = new ExpressionFunction(name, args);
break;
default:
throw new NotImplementedException();
}
_lexicalScanner.Next();
return(result);
}
private static Expression CreateExpression(Container container)
{
var expression = ExpressionBinaryOperation.CreateExpressionBinaryOperation(
ExpressionBinaryOperator.And,
ExpressionBinaryOperation.CreateExpressionBinaryOperation(
ExpressionBinaryOperator.Or,
ExpressionVariable.CreateExpressionVariable(CreateRuleVariable(container)),
ExpressionVariable.CreateExpressionVariable(CreateRuleVariable(container))
),
ExpressionUnaryOperation.CreateExpressionUnaryOperation(
ExpressionUnaryOperator.Not,
ExpressionVariable.CreateExpressionVariable(CreateRuleVariable(container))
)
);
return(expression);
}
public static void Main(string[] args)
{
Uri serviceUri = new Uri("http://localhost:38054");
var container = new Container(serviceUri);
var firstRuleVariableId = CreateRuleVariable(container);
var secondRuleVariableId = CreateRuleVariable(container);
var thirdRuleVariableId = CreateRuleVariable(container);
var expression = ExpressionBinaryOperation.CreateExpressionBinaryOperation(
ExpressionBinaryOperator.And,
ExpressionBinaryOperation.CreateExpressionBinaryOperation(
ExpressionBinaryOperator.Or,
ExpressionVariable.CreateExpressionVariable(firstRuleVariableId),
ExpressionVariable.CreateExpressionVariable(secondRuleVariableId)
),
ExpressionUnaryOperation.CreateExpressionUnaryOperation(
ExpressionUnaryOperator.Not,
ExpressionVariable.CreateExpressionVariable(thirdRuleVariableId)
)
);
var rule = Rule.CreateRule(int.MaxValue, "My Rule");
rule.Expression = expression;
container.AddToRules(rule);
container.SaveChanges();
Console.Out.WriteLine(rule.ToString());
var ruleVariables = container.Rules.ByKey(rule.Id).Variables.ToList();
var firstRuleVariable = ruleVariables.Find(rv => rv.Id == firstRuleVariableId);
Console.Out.WriteLine(firstRuleVariable.ToString());
var secondRuleVariable = ruleVariables.Find(rv => rv.Id == firstRuleVariableId);
Console.Out.WriteLine(secondRuleVariable.ToString());
var thirdRuleVariable = ruleVariables.Find(rv => rv.Id == firstRuleVariableId);
Console.Out.WriteLine(thirdRuleVariable.ToString());
}
public void ExpressionVariableCollection_Test()
{
var parser = new ExpressionParser();
var expr = parser.Parse("2+2*2");
var var_collection = expr.Variable;
Assert.IsNotNull(var_collection);
Assert.AreEqual(0, var_collection.Count);
var var_x = var_collection["x"];
Assert.AreEqual(1, var_collection.Count);
var var_x1 = var_collection["x"];
Assert.IsTrue(ReferenceEquals(var_x, var_x1));
Assert.AreEqual(0, var_x.Value);
var_x.Value = 5;
Assert.AreEqual(5, var_x.Value);
Assert.AreEqual(5, var_x1.Value);
var var_y = var_collection["y"];
var_x.Value = 7;
Assert.AreEqual(2, var_collection.Count);
Assert.IsFalse(ReferenceEquals(var_x, var_y));
Assert.AreEqual(7, var_x.Value);
Assert.AreEqual(0, var_y.Value);
expr = parser.Parse("2x^4-7x^3+3x^2-2x+3-7y");
var_collection = expr.Variable;
Assert.AreEqual(2, var_collection.Count);
var_x = var_collection[0];
var_y = var_collection[1];
Assert.AreEqual("x", var_x.Name);
Assert.AreEqual("y", var_y.Name);
var l_var = new LambdaExpressionVariable(() => 10);
var_collection["x"] = l_var;
var vars = expr.Tree
.Where(node => node is VariableValueNode)
.Cast <VariableValueNode>()
.Select(node => node.Variable)
.Where(v => v.Name == "x")
.ToArray();
Assert.IsTrue(vars.All(v => ReferenceEquals(v, l_var)));
vars.Foreach(v => Assert.AreEqual(10, v.GetValue()));
expr = parser.Parse("2x-y");
expr.Variable["x"] = new LambdaExpressionVariable(() => 20);
Assert.IsInstanceOfType(expr.Variable["x"], typeof(LambdaExpressionVariable));
Assert.AreEqual(0, expr.Variable["x"].Value);
Assert.AreEqual(20, expr.Variable["x"].GetValue());
Assert.AreEqual(20, expr.Variable["x"].Value);
Assert.AreEqual(40, expr.Compute());
expr = parser.Parse("(2x-3.27y)^(sin(x)/x)-2z+3q/2x+y");
var_collection = expr.Variable;
var x_var_call_counter = 0;
var_collection["x"] = new LambdaExpressionVariable(() =>
{
// ReSharper disable once AccessToModifiedClosure
x_var_call_counter++;
return(1);
});
expr.Compute();
Assert.AreEqual(4, x_var_call_counter);
x_var_call_counter = 0;
expr.Compile()();
Assert.AreEqual(4, x_var_call_counter);
Assert.IsTrue(var_collection.Add(new ExpressionVariable("test1")));
var var_test2 = new ExpressionVariable("test2");
Assert.IsTrue(var_collection.Add(var_test2));
Assert.IsTrue(var_collection.Add(new ExpressionVariable("test3")));
Assert.IsFalse(var_collection.Add(new ExpressionVariable("test1")));
Assert.IsFalse(var_collection.Add(new ExpressionVariable("x")));
Assert.IsTrue(var_collection.Remove(var_test2));
Assert.IsFalse(var_collection.Remove(var_test2));
Assert.IsFalse(var_collection.Remove(var_collection["x"]));
Assert.IsTrue(var_collection.Remove(var_collection["test3"]));
var var_names = var_collection.Names.ToArray();
Assert.AreEqual(5, var_collection.Count);
Assert.AreEqual(5, var_names.Length);
CollectionAssert.AreEqual(new[] { "y", "z", "q", "x", "test1" }, var_names);
Assert.IsTrue(var_collection.Exist("x"));
Assert.IsTrue(var_collection.Exist("test1"));
Assert.IsFalse(var_collection.Exist("test2"));
Assert.IsTrue(var_collection.Exist(v => v is LambdaExpressionVariable));
Assert.IsFalse(var_collection.Exist(v => v is EventExpressionVariable));
Assert.IsTrue(var_collection.ExistInTree("x"));
Assert.IsTrue(var_collection.ExistInTree("y"));
Assert.IsTrue(var_collection.ExistInTree("z"));
Assert.IsTrue(var_collection.ExistInTree("q"));
Assert.IsFalse(var_collection.ExistInTree("test1"));
#pragma warning disable 183
// ReSharper disable IsExpressionAlwaysTrue
Assert.IsTrue(var_collection.ExistInTree(v => v.Variable is ExpressionVariable));
// ReSharper restore IsExpressionAlwaysTrue
#pragma warning restore 183
Assert.IsTrue(var_collection.ExistInTree(v => v.Variable is LambdaExpressionVariable));
Assert.IsFalse(var_collection.ExistInTree(v => v.Variable is EventExpressionVariable));
Assert.AreEqual(4, var_collection.GetTreeNodes("x").Count());
Assert.AreEqual(2, var_collection.GetTreeNodes("y").Count());
Assert.AreEqual(1, var_collection.GetTreeNodes("z").Count());
Assert.AreEqual(1, var_collection.GetTreeNodes("q").Count());
Assert.AreEqual(0, var_collection.GetTreeNodes("test1").Count());
Assert.AreEqual(4, var_collection.GetTreeNodes(vn => vn.Variable is LambdaExpressionVariable).Count());
Assert.AreEqual(0, var_collection.GetTreeNodes(vn => vn.Variable is EventExpressionVariable).Count());
Assert.AreEqual(8, var_collection.GetTreeNodesOf <ExpressionVariable>().Count());
Assert.AreEqual(4, var_collection.GetTreeNodesOf <LambdaExpressionVariable>().Count());
Assert.AreEqual(0, var_collection.GetTreeNodesOf <EventExpressionVariable>().Count());
Assert.AreEqual(4, var_collection.GetTreeNodesVOf <ExpressionVariable>(v => v.Name == "x").Count());
Assert.AreEqual(4, var_collection.GetTreeNodesVOf <LambdaExpressionVariable>(v => v.Name == "x").Count());
Assert.AreEqual(2, var_collection.GetTreeNodesVOf <ExpressionVariable>(v => v.Name == "y").Count());
Assert.AreEqual(3, var_collection.GetTreeNodesOf <ExpressionVariable>(vn => vn.Parent?.Parent is subtractionOperatorNode).Count());
Assert.AreEqual(1, var_collection.GetTreeNodesOf <LambdaExpressionVariable>(vn => vn.Parent?.Parent is subtractionOperatorNode).Count());
}
