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