public void MultiplyDoubleByInteger() { MultiplyExpression expr = new MultiplyExpression(new ConstantExpression(2.5), new ConstantExpression(3)); Assert.AreEqual(2.5 * 3, expr.Evaluate(null)); Assert.AreSame(TypeInfo.Double, expr.TypeInfo); }
private IExpression ParseBinaryExpressionLevel2() { IExpression expression = this.ParseSimpleExpression(); Token token = this.lexer.NextToken(); while (token != null && (token.Value == "*" || token.Value == "/")) { switch (token.Value[0]) { case '*': expression = new MultiplyExpression(expression, this.ParseSimpleExpression()); break; case '/': expression = new DivideExpression(expression, this.ParseSimpleExpression()); break; } token = this.lexer.NextToken(); } if (token != null) { this.lexer.PushToken(token); } return(expression); }
public void MultiplyTwoIntegers() { MultiplyExpression expr = new MultiplyExpression(new ConstantExpression(3), new ConstantExpression(2)); Assert.AreEqual(6, expr.Evaluate(null)); Assert.AreSame(TypeInfo.Int, expr.TypeInfo); }
public void MultiplyTwoDoubles() { MultiplyExpression expr = new MultiplyExpression(new ConstantExpression(2.5), new ConstantExpression(3.7)); Assert.AreEqual(2.5 * 3.7, expr.Evaluate(null)); Assert.AreSame(TypeInfo.Double, expr.TypeInfo); }
public void MultiplicationExpressionEvaluatesDifferenceOfComplexDecimalExpression() { // 2 * x - 7 + x * 10 IExpression two = new Constant(2); IExpression x = new VariableX(); IExpression seven = new Constant(7); IExpression ten = new Constant(10); IExpression result = new MultiplyExpression(two, x); result = new SubtractionExpression(result, seven); result = new SumExpression(result, x); result = new MultiplyExpression(result, ten); Context c = new Context(0.5); var y = result.Interpret(c); Assert.AreEqual(-55, y, 1e-10); c = new Context(1.5); y = result.Interpret(c); Assert.AreEqual(-25, y, 1e-10); }
public void InstanceHasSameHashCodeAsItself() { var expression = new MultiplyExpression(new IntegerExpression(1), new VariableExpression("x")); var available = new AvailableExpression(_CreateFlowNode(), expression); Assert.AreEqual(available.GetHashCode(), available.GetHashCode()); }
public void ParseAddMultiplyWithParens() { Parser parser = new Parser("(2+3)*4."); IExpression expression = parser.ParseExpression(); Assert.IsNotNull(expression); Assert.IsInstanceOfType(expression, typeof(MultiplyExpression)); MultiplyExpression multexpression = (MultiplyExpression)expression; Assert.IsInstanceOfType(multexpression.RightExpression, typeof(ConstantExpression)); Assert.AreEqual(4, ((ConstantExpression)multexpression.RightExpression).Value); Assert.IsInstanceOfType(multexpression.LeftExpression, typeof(AddExpression)); AddExpression addexpression = (AddExpression)multexpression.LeftExpression; Assert.IsInstanceOfType(addexpression.LeftExpression, typeof(ConstantExpression)); Assert.IsInstanceOfType(addexpression.RightExpression, typeof(ConstantExpression)); Assert.AreEqual(2, ((ConstantExpression)addexpression.LeftExpression).Value); Assert.AreEqual(3, ((ConstantExpression)addexpression.RightExpression).Value); Assert.IsNull(parser.ParseExpression()); }
// Function to perform arithmetic operations. public Expression applyOp(Expression val1, Expression op, Expression val2) { if (((Operator)op).GetOp() == '+') { BinaryExpression Add = new AddExpression(val1, val2); return(Add); } else if (((Operator)op).GetOp() == '-') { BinaryExpression Substract = new SubstractExpression(val1, val2); return(Substract); } else if (((Operator)op).GetOp() == '*') { BinaryExpression Multiply = new MultiplyExpression(val1, val2); return(Multiply); } else if (((Operator)op).GetOp() == '/') { BinaryExpression Division = new DivisionExpression(val1, val2); return(Division); } else /*if (((Operator)op).GetOp() == '^')*/ { BinaryExpression Appointment = new AppointmentExpression(val1, val2); return(Appointment); } }
public void EqualMultiplyExpressionsMirrored() { var a = new MultiplyExpression(new IntegerExpression(5), new VariableExpression("a")); var b = new MultiplyExpression(new VariableExpression("a"), new IntegerExpression(5)); Assert.IsTrue(_instance.AreEqual(a, b)); }
public void InstanceIsNotEqualToNull() { var expression = new MultiplyExpression(new IntegerExpression(1), new VariableExpression("x")); var available = new AvailableExpression(_CreateFlowNode(), expression); Assert.AreNotEqual(available, null); }
public void DistinctMultiplyExpressions() { var a = new MultiplyExpression(new IntegerExpression(5), new VariableExpression("a")); var b = new MultiplyExpression(new VariableExpression("a"), new VariableExpression("a")); Assert.IsFalse(_instance.AreEqual(a, b)); }
public void MultiplyTwoIntegers() { MultiplyExpression expr = new MultiplyExpression(new ConstantExpression(3), new ConstantExpression(2)); Assert.AreEqual(6, expr.Evaluate(null)); Assert.IsFalse(expr.HasVariable()); }
private IExpression ParseBinaryExpression(int level) { if (level >= binaryoperators.Length) { return(this.ParseTerm()); } IExpression expr = this.ParseBinaryExpression(level + 1); if (expr == null) { return(null); } Token token; for (token = this.lexer.NextToken(); token != null && this.IsBinaryOperator(level, token); token = this.lexer.NextToken()) { if (token.Value == "=:=") { expr = new StrictEqualExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "==") { expr = new EqualExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "+") { expr = new AddExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "-") { expr = new SubtractExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "*") { expr = new MultiplyExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "/") { expr = new DivideExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "div") { expr = new DivExpression(expr, this.ParseBinaryExpression(level + 1)); } else if (token.Value == "rem") { expr = new RemExpression(expr, this.ParseBinaryExpression(level + 1)); } } if (token != null) { this.lexer.PushToken(token); } return(expr); }
public Expression Visit(MultiplyExpression expression) { return(_ApplyBinaryExpression(expression, (left, right) => left * right, (left, right) => (left.Value == 0) ? new IntegerExpression(0) : (left.Value == 1 ? right : new MultiplyExpression(left, right)), (left, right) => (right.Value == 0) ? new IntegerExpression(0) : (right.Value == 1 ? left : new MultiplyExpression(left, right)), (left, right) => new MultiplyExpression(left, right))); }
public void SerializeSubtractExpression() { var num = new LiteralExpression(1); var a = new MultiplyExpression(num, num); var b = Reserialize(a); Assert.AreEqual(a, b); }
//--------------------------------------------------------------------- public override Expression Visit(MultiplyExpression multiplyExpression) { var expression = this.TryParameterMultipliedBy2(multiplyExpression); return(expression ?? this.VisitBinaryCore(multiplyExpression, (a, b) => a * b) ?? base.Visit(multiplyExpression)); }
public static void SerializeMultiplyExpression() { var v = new NumberLiteral(2); var a = new MultiplyExpression(v, v); var b = SerializationUtil.Reserialize(a); Assert.AreEqual(a, b); }
public void MultiplyExpression() { var e = new MultiplyExpression(new StringLiteral("hi"), new StringLiteral("bye")); Assert.IsFalse(e.IsTrivial); Assert.AreEqual("(\"hi\"*\"bye\")", e.ToString()); Assert.AreEqual("Multiply", e.Name); }
public void TestEvaluate() { var expression = new MultiplyExpression( Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)5), Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)2), new Context(ExpressiveOptions.None)); Assert.AreEqual(10, expression.Evaluate(null)); }
public void InstanceIsNotEqualToOtherWithOperator() { var node = _CreateFlowNode(); var expression1 = new AddExpression(new IntegerExpression(5), new VariableExpression("y")); var expression2 = new MultiplyExpression(new IntegerExpression(5), new VariableExpression("y")); var available1 = new AvailableExpression(node, expression1); var available2 = new AvailableExpression(node, expression2); Assert.AreNotEqual(available1, available2); }
public void ShouldMultiplyTwoRealNumbers() { IExpression expression = new MultiplyExpression(3.0, 2.0); object value = expression.Evaluate(null); Assert.IsNotNull(value); Assert.IsInstanceOfType(value, typeof(double)); Assert.AreEqual(6.0, (double)value); }
//--------------------------------------------------------------------- private BinaryExpression TryParameterMultipliedBy2(MultiplyExpression multiplyExpression) { ArrayIndexExpression parameter; ConstantExpression constant; if (multiplyExpression.Left is ArrayIndexExpression p && multiplyExpression.Right is ConstantExpression c) { parameter = p; constant = c; }
public void InstanceHasNotSameHashCodeAsOtherWithDifferentOperator() { var node = _CreateFlowNode(); var expression1 = new AddExpression(new IntegerExpression(5), new VariableExpression("y")); var expression2 = new MultiplyExpression(new IntegerExpression(5), new VariableExpression("y")); var available1 = new AvailableExpression(node, expression1); var available2 = new AvailableExpression(node, expression2); Assert.AreNotEqual(available1.GetHashCode(), available2.GetHashCode()); }
public void ShouldMultiplyTwoIntegerNumbers() { IExpression expression = new MultiplyExpression(3, 2); object value = expression.Evaluate(null); Assert.IsNotNull(value); Assert.IsInstanceOfType(value, typeof(int)); Assert.AreEqual(6, (int)value); }
public void Eval_When_Multiply_TwoConstants2and3_MustReturn_6() { // Arrange var sut = new MultiplyExpression(new ConstantExpression(2), new ConstantExpression(3)); // Act var actual = sut.Eval(); // Assert Assert.AreEqual(expected: 6, actual: actual); }
public void ParseMultiplyTwoIntegers() { Parser parser = new Parser("3*2"); var expected = new MultiplyExpression(new ConstantExpression(3), new ConstantExpression(2)); var result = parser.ParseExpression(); Assert.IsNotNull(result); Assert.AreEqual(expected, result); Assert.IsNull(parser.ParseExpression()); }
public void MultiplicationExpressionEvaluatesDifferenceOf2Constants() { IExpression leftConstant = new Constant(4); IExpression rightConstant = new Constant(6); IExpression difference = new MultiplyExpression(leftConstant, rightConstant); Context context = new Context(0); var result = difference.Interpret(context); Assert.AreEqual(24, result, 1e-10); }
private object Multiply(object l, object r) { var scope = new Scope(); scope.SetVar("l", l); scope.SetVar("r", r); var exp = new MultiplyExpression( new VariableExpression("l"), new VariableExpression("r") ); return(exp.Evaluate(scope, new Bindings()).AsObject()); }
public void Eval_When_Multiply_OneVariableAndOneConstants5and3_MustReturn_15() { // Arrange var sut = new MultiplyExpression(new AssignmentExpression( new VariableExpression("P"), new ConstantExpression(5)), new ConstantExpression(3)); // Act var actual = sut.Eval(); // Assert Assert.AreEqual(expected: 15, actual: actual); }
/// <summary> /// Client /// </summary> /// <remarks> /// Build a syntax tree representing a particular sentence in the language that the grammar defines. /// </remarks> public override void Execute() { var context = new Context(); // expression1 = 1 + 2 var expression1 = new AddExpression(new ConstantExpression(1), new ConstantExpression(2)); Assert.Equal(1 + 2, expression1.Solve(context)); // expression2 = 4 * 6 var expression2 = new MultiplyExpression(new ConstantExpression(4), new ConstantExpression(6)); Assert.Equal(4.0 * 6.0, expression2.Solve(context)); // expression3 = expression2 / 2 var expression3 = new DivideExpression(expression2, new ConstantExpression(2)); Assert.Equal(4.0 * 6.0 / 2.0, expression3.Solve(context)); // expression4 = expression1 - expression3 var expression4 = new SubtractExpression(new VariableExpression(nameof(expression1)), new VariableExpression(nameof(expression3))); context.SetVariable(nameof(expression1), expression1); context.SetVariable(nameof(expression3), expression3); Assert.Equal((/* expression1 */ 1 + 2) - (/* expression3 */ 4.0 * 6.0 / 2.0), expression4.Solve(context)); // f(x) = ((5 * x) / 2) + ((2 ^ x) - 6) // x = 6 var expression5 = new AddExpression( new DivideExpression( new MultiplyExpression( new ConstantExpression(5), new VariableExpression("x")), new ConstantExpression(2)), new SubtractExpression( new PowerExpression( new ConstantExpression(2), new VariableExpression("x")), new ConstantExpression(6))); double x = 6; context.SetVariable("x", new ConstantExpression(x)); Assert.Equal(((5 * x) / 2) + (Math.Pow(2, x) - 6), expression5.Solve(context)); }
private string GetExpression(MultiplyExpression expression, ref List<OleDbParameter> parameters) { return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " * " + GetExpressionDispatch(expression.Children[1], ref parameters) + " ) "; }
private IExpression ParseBinaryExpression(int level) { if (level >= binaryoperators.Length) return this.ParseTerm(); IExpression expr = this.ParseBinaryExpression(level + 1); if (expr == null) return null; Token token; for (token = this.lexer.NextToken(); token != null && this.IsBinaryOperator(level, token); token = this.lexer.NextToken()) { if (token.Value == "=:=") expr = new StrictEqualExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "==") expr = new EqualExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "+") expr = new AddExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "-") expr = new SubtractExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "*") expr = new MultiplyExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "/") expr = new DivideExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "div") expr = new DivExpression(expr, this.ParseBinaryExpression(level + 1)); else if (token.Value == "rem") expr = new RemExpression(expr, this.ParseBinaryExpression(level + 1)); } if (token != null) this.lexer.PushToken(token); return expr; }
/// <summary> /// Finds the first instance of currentOperator (i.e. '+'), takes the operands on the left and right /// to the operator and builds an Expression instance (i.e. AddExpression in case of '+'). /// </summary> /// <param name="expression">A list containing numbers, operators and expressions.</param> /// <param name="currentOperator">The symbol of the current operator to be processed.</param> private static void CreateExpression(List<dynamic> expression, char currentOperator) { int operatorIndex = expression.IndexOf(currentOperator); Expression operation; dynamic leftOperand, rightOperand; try { if (expression.ElementAt(operatorIndex - 1) is double) { leftOperand = new NumberExpression(expression.ElementAt(operatorIndex - 1)); } else if (expression.ElementAt(operatorIndex - 1) is Expression) { leftOperand = expression.ElementAt(operatorIndex - 1); } else { throw new ArgumentException("Invalid expression string."); } if (expression.ElementAt(operatorIndex + 1) is double) { rightOperand = new NumberExpression(expression.ElementAt(operatorIndex + 1)); } else if (expression.ElementAt(operatorIndex + 1) is Expression) { rightOperand = expression.ElementAt(operatorIndex + 1); } else { throw new ArgumentException("Invalid expression string."); } } catch (Exception ex) { throw new ArgumentException("Invalid expression string."); } switch (currentOperator) { case '+': operation = new AddExpression(leftOperand, rightOperand); break; case '-': operation = new SubtractExpression(leftOperand, rightOperand); break; case '*': operation = new MultiplyExpression(leftOperand, rightOperand); break; case '/': operation = new DivideExpression(leftOperand, rightOperand); break; default: operation = new NumberExpression(0); break; } expression.RemoveAt(operatorIndex + 1); expression.RemoveAt(operatorIndex); expression.RemoveAt(operatorIndex - 1); expression.Insert(operatorIndex - 1, operation); }