public void DistinctDivideExpressions()
{
var a = new DivideExpression(new IntegerExpression(5), new VariableExpression("a"));
var b = new DivideExpression(new VariableExpression("a"), new VariableExpression("a"));
Assert.IsFalse(_instance.AreEqual(a, b));
}
public void DivideTwoDoubles()
{
DivideExpression expr = new DivideExpression(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()
{
// 3 / x - 7 + x / 2
IExpression three = new Constant(3);
IExpression x = new VariableX();
IExpression seven = new Constant(7);
IExpression two2 = new Constant(2);
IExpression result = new DivideExpression(three, x);
result = new SubtractionExpression(result, seven);
result = new SumExpression(result, x);
result = new DivideExpression(result, two2);
Context c = new Context(0.5);
var y = result.Interpret(c);
Assert.AreEqual(-0.25, y, 1e-10);
c = new Context(1.5);
y = result.Interpret(c);
Assert.AreEqual(-1.75, y, 1e-10);
}
public void EqualDivideExpressionsSameOrder()
{
var a = new DivideExpression(new VariableExpression("a"), new IntegerExpression(5));
var b = new DivideExpression(new VariableExpression("a"), new IntegerExpression(5));
Assert.IsTrue(_instance.AreEqual(a, b));
}
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 DivideIntegerByDouble()
{
DivideExpression expr = new DivideExpression(new ConstantExpression(2), new ConstantExpression(2.5));
Assert.AreEqual(2 / 2.5, expr.Evaluate(null));
Assert.AreSame(TypeInfo.Double, expr.TypeInfo);
}
public void DivideTwoIntegers()
{
DivideExpression expr = new DivideExpression(new ConstantExpression(6), new ConstantExpression(2));
Assert.AreEqual(3, expr.Evaluate(null));
Assert.AreSame(TypeInfo.Int, expr.TypeInfo);
}
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 static void SerializeDivideExpression()
{
var v = new NumberLiteral(2);
var a = new DivideExpression(v, v);
var b = SerializationUtil.Reserialize(a);
Assert.AreEqual(a, b);
}
public void SerializeDivideExpression()
{
var num = new LiteralExpression(1);
var a = new DivideExpression(num, num);
var b = Reserialize(a);
Assert.AreEqual(a, b);
}
public void DivideExpression()
{
var e = new DivideExpression(new Literal("13"), new Literal("37"));
Assert.IsFalse(e.IsTrivial);
Assert.AreEqual("(13/37)", e.ToString());
Assert.AreEqual("Divide", e.Name);
}
public void InstanceIsNotEqualToOtherWithDifferentNode()
{
var expression1 = new DivideExpression(new IntegerExpression(5), new VariableExpression("y"));
var expression2 = new DivideExpression(new IntegerExpression(5), new VariableExpression("y"));
var available1 = new AvailableExpression(_CreateFlowNode(), expression1);
var available2 = new AvailableExpression(_CreateFlowNode(), expression2);
Assert.AreNotEqual(available1, available2);
}
public void InstanceHasNotSameHashCodeAsCompletelyDifferent()
{
var expression1 = new ModuloExpression(new IntegerExpression(3), new VariableExpression("y"));
var expression2 = new DivideExpression(new IntegerExpression(4), new VariableExpression("z"));
var available1 = new AvailableExpression(_CreateFlowNode(), expression1);
var available2 = new AvailableExpression(_CreateFlowNode(), expression2);
Assert.AreNotEqual(available1.GetHashCode(), available2.GetHashCode());
}
public void InstanceHasNotSameHashCodeAsOtherWithDifferenNode()
{
var expression1 = new DivideExpression(new IntegerExpression(5), new VariableExpression("y"));
var expression2 = new DivideExpression(new IntegerExpression(5), new VariableExpression("y"));
var available1 = new AvailableExpression(_CreateFlowNode(), expression1);
var available2 = new AvailableExpression(_CreateFlowNode(), expression2);
Assert.AreNotEqual(available1.GetHashCode(), available2.GetHashCode());
}
public void TestEvaluate()
{
var expression = new DivideExpression(
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1),
Mock.Of <IExpression>(e => e.Evaluate(It.IsAny <IDictionary <string, object> >()) == (object)1),
ExpressiveOptions.None);
Assert.AreEqual(1d, expression.Evaluate(null));
}
public void InstanceIsEqualToOtherWithSameInformation()
{
var node = _CreateFlowNode();
var expression1 = new DivideExpression(new IntegerExpression(5), new VariableExpression("y"));
var expression2 = new DivideExpression(new IntegerExpression(5), new VariableExpression("y"));
var available1 = new AvailableExpression(node, expression1);
var available2 = new AvailableExpression(node, expression2);
Assert.AreEqual(available1, available2);
}
public void ShouldDivideTwoRealNumbers()
{
IExpression expression = new DivideExpression(3.0, 2.0);
object value = expression.Evaluate(null);
Assert.IsNotNull(value);
Assert.IsInstanceOfType(value, typeof(double));
Assert.AreEqual(1.5, (double)value);
}
public Expression Visit(DivideExpression expression)
{
var left = expression.Left.Accept(this);
if (left is IntegerExpression integer && integer.Value == 0)
{
return(left);
}
return(new DivideExpression(left, expression.Right.Accept(this)));
}
public void MultiplicationExpressionEvaluatesDifferenceOf2Constants()
{
IExpression leftConstant = new Constant(10);
IExpression rightConstant = new Constant(4);
IExpression difference = new DivideExpression(leftConstant, rightConstant);
Context context = new Context(0);
var result = difference.Interpret(context);
Assert.AreEqual(2.5, result, 1e-10);
}
public void ParseDivideTwoIntegers()
{
Parser parser = new Parser("3/2");
var expected = new DivideExpression(new ConstantExpression(3), new ConstantExpression(2));
var result = parser.ParseExpression();
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
Assert.IsNull(parser.ParseExpression());
}
private object Divide(object l, object r)
{
var scope = new Scope();
scope.SetVar("l", l);
scope.SetVar("r", r);
var exp = new DivideExpression(
new VariableExpression("l"),
new VariableExpression("r")
);
return(exp.Evaluate(scope, new Bindings()).AsObject());
}
public override IExpression?Differentiate(string byVariable)
{
if (Right is ConstantExpression)
{
// f(x) = g(x)^n
// f'(x) = n * g'(x) * g(x)^(n-1)
var newRight = new DivideExpression(new ConstantExpression(1), Right);
return
(new MultiplyExpression(new MultiplyExpression(newRight, Left?.Differentiate(byVariable)),
new ExponentExpression(Left, new SubtractExpression(newRight, new ConstantExpression(1)))));
}
throw new CannotDifferentiateException(Resources.CanotDifferentiate);
}
/// <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));
}
public void ParseSimpleDivide()
{
Parser parser = new Parser("10/20.");
IExpression expression = parser.ParseExpression();
Assert.IsNotNull(expression);
Assert.IsInstanceOfType(expression, typeof(DivideExpression));
DivideExpression divideexpression = (DivideExpression)expression;
Assert.IsInstanceOfType(divideexpression.LeftExpression, typeof(ConstantExpression));
Assert.IsInstanceOfType(divideexpression.RightExpression, typeof(ConstantExpression));
Assert.AreEqual(10, ((ConstantExpression)divideexpression.LeftExpression).Value);
Assert.AreEqual(20, ((ConstantExpression)divideexpression.RightExpression).Value);
}
public void Equals()
{
DivideExpression expr1 = new DivideExpression(new ConstantExpression(1), new ConstantExpression(2));
DivideExpression expr2 = new DivideExpression(new ConstantExpression(1), new ConstantExpression(3));
DivideExpression expr3 = new DivideExpression(new ConstantExpression(1), new ConstantExpression(2));
DivideExpression expr4 = new DivideExpression(new ConstantExpression(2), new ConstantExpression(2));
Assert.IsTrue(expr1.Equals(expr3));
Assert.IsTrue(expr3.Equals(expr1));
Assert.AreEqual(expr1.GetHashCode(), expr3.GetHashCode());
Assert.IsFalse(expr1.Equals(null));
Assert.IsFalse(expr1.Equals("foo"));
Assert.IsFalse(expr1.Equals(expr2));
Assert.IsFalse(expr2.Equals(expr1));
Assert.IsFalse(expr1.Equals(expr4));
Assert.IsFalse(expr4.Equals(expr1));
}
protected IExpression ParseTerm()
{
var left = ParseFactor();
while (Accept("*") || Accept("/") || Accept("%"))
{
if (Prev().Type == "*")
{
left = MultiplyExpression.Create(left, ParseFactor());
}
else if (Prev().Type == "/")
{
left = DivideExpression.Create(left, ParseFactor());
}
else
{
left = ModuloExpression.Create(left, ParseFactor());
}
}
return(left);
}
public override AstNode VisitMultiplication([NotNull] QlParser.MultiplicationContext context)
{
var op = context.op.Text;
BinaryExpression binExp = null;
var lhs = this.Visit(context.lhs) as Expression;
var rhs = this.Visit(context.rhs) as Expression;
switch (op)
{
case "*":
binExp = new MultiplyExpression(lhs, rhs);
break;
case "/":
binExp = new DivideExpression(lhs, rhs);
break;
default:
throw new ArgumentOutOfRangeException(nameof(op), "Unsupported operator.");
}
return(binExp);
}
public void DivideDoubleByInteger()
{
DivideExpression expr = new DivideExpression(new ConstantExpression(2.5), new ConstantExpression(3));
Assert.AreEqual(2.5 / 3, expr.Evaluate(null));
}
public void DivideTwoIntegersToReal()
{
DivideExpression expr = new DivideExpression(new ConstantExpression(5), new ConstantExpression(2));
Assert.AreEqual(2.5, expr.Evaluate(null));
}
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 AddExpression(expr, this.ParseBinaryExpression(level + 1));
}
if (token.Value == "-")
{
expr = new SubtractExpression(expr, this.ParseBinaryExpression(level + 1));
}
if (token.Value == "*")
{
expr = new MultiplyExpression(expr, this.ParseBinaryExpression(level + 1));
}
if (token.Value == "/")
{
expr = new DivideExpression(expr, this.ParseBinaryExpression(level + 1));
}
if (token.Value == "==")
{
expr = new CompareExpression(expr, this.ParseBinaryExpression(level + 1), CompareOperator.Equal);
}
if (token.Value == "!=")
{
expr = new CompareExpression(expr, this.ParseBinaryExpression(level + 1), CompareOperator.NotEqual);
}
if (token.Value == "<")
{
expr = new CompareExpression(expr, this.ParseBinaryExpression(level + 1), CompareOperator.Less);
}
if (token.Value == ">")
{
expr = new CompareExpression(expr, this.ParseBinaryExpression(level + 1), CompareOperator.Greater);
}
if (token.Value == "<=")
{
expr = new CompareExpression(expr, this.ParseBinaryExpression(level + 1), CompareOperator.LessOrEqual);
}
if (token.Value == ">=")
{
expr = new CompareExpression(expr, this.ParseBinaryExpression(level + 1), CompareOperator.GreaterOrEqual);
}
if (token.Value == "..")
{
expr = new RangeExpression(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);
}
private string GetExpression(DivideExpression expression, ref List<OleDbParameter> parameters)
{
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " / " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " ) ";
}
