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()); }