protected virtual double VisitAdditionExpression(AdditionExpression expr)
{
var arg1 = Visit(expr.Arg1);
var arg2 = Visit(expr.Arg2);
return(arg1 + arg2);
}
public string AdditionString(AdditionExpression node, List <Object> parameters)
{
string leftOperand = _interpreter.DispatchString(node.Children[0], parameters);
string rightOperand = _interpreter.DispatchString(node.Children[1], parameters);
return(string.Concat(leftOperand, rightOperand));
}
public double AdditionReal(AdditionExpression node, List <object> parameters)
{
double leftOperand = _interpreter.DispatchReal(node.Children[0], parameters);
double rightOperand = _interpreter.DispatchReal(node.Children[1], parameters);
return(leftOperand + rightOperand);
}
public void Reduce_RightOperandOfABinaryOperatorIsConstant()
{
_runtime
.Setup(mock => mock.FindAndCall("+",
It.Is <IExecutionContext>(context =>
context.Line == 2 &&
context.Column == 2 &&
context.Count == 2 &&
context[0].Equals(new IntValue(1)) &&
context[1].Equals(new IntValue(2))
)))
.Returns(new IntValue(3));
var expr =
new AdditionExpression(1, 2,
new AttributeAccessExpression(0, 2, "a"),
new AdditionExpression(2, 2,
new ConstantExpression(0, 0, new IntValue(1)),
new ConstantExpression(0, 0, new IntValue(2))));
var reduced = expr.Accept(_visitor);
Assert.IsInstanceOfType(reduced, typeof(AdditionExpression));
var addition = reduced as AdditionExpression;
Assert.AreEqual("a", ((AttributeAccessExpression)addition.Left).Name);
Assert.AreEqual(0, addition.Left.Line);
Assert.AreEqual(2, addition.Left.Column);
Assert.AreEqual(new IntValue(3), ((ConstantExpression)addition.Right).Value);
Assert.AreEqual(2, addition.Right.Line);
Assert.AreEqual(2, addition.Right.Column);
}
public void SimpleAddition()
{
var simple = new AdditionExpression(new Value(2), new Value(3));
var ep = new ExpressionPrinter();
ep.Visit(simple);
Assert.That(ep.ToString(), Is.EqualTo("(2+3)"));
}
public void Reduce_BinaryOperatorWithTransitivelyConstantOperands()
{
_runtime
.Setup(mock => mock.FindAndCall("+",
It.Is <IExecutionContext>(context =>
context.Line == 0 &&
context.Column == 1 &&
context.Count == 2 &&
context[0].Equals(new IntValue(1)) &&
context[1].Equals(new IntValue(2))
)))
.Returns(new IntValue(3));
_runtime
.Setup(mock => mock.FindAndCall("+",
It.Is <IExecutionContext>(context =>
context.Line == 0 &&
context.Column == 3 &&
context.Count == 2 &&
context[0].Equals(new IntValue(3)) &&
context[1].Equals(new IntValue(2))
)))
.Returns(new IntValue(5));
var expr = new AdditionExpression(0, 3,
new AdditionExpression(0, 1,
new ConstantExpression(0, 0, new IntValue(1)),
new ConstantExpression(0, 2, new IntValue(2))),
new ConstantExpression(0, 4, new IntValue(2)));
var reduced = expr.Accept(_visitor);
Assert.IsInstanceOfType(reduced, typeof(ConstantExpression));
Assert.AreEqual(new IntValue(5), ((ConstantExpression)reduced).Value);
Assert.AreEqual(0, reduced.Line);
Assert.AreEqual(3, reduced.Column);
}
public void AnonymousFunctionDefinition()
{
Expression expression = parseExpression("(a -> int, b-> Banana) -> Platypus { a + 5; }");
AnonymousFunctionExpression a = assertTypeAndCast <AnonymousFunctionExpression>(expression);
Assert.AreEqual("Platypus", a.returnType.name);
Assert.IsNotInstanceOfType(a.returnType, typeof(GenericTypeName));
Assert.AreEqual(2, a.arguments.members.Count);
Assert.AreEqual(1, a.body.innerExpressions.Count);
Assert.AreEqual("a", a.arguments.members[0].name);
Assert.AreEqual("int", a.arguments.members[0].typeName.name);
Assert.IsNotInstanceOfType(a.arguments.members[0].typeName, typeof(GenericTypeName));
Assert.AreEqual("b", a.arguments.members[1].name);
Assert.AreEqual("Banana", a.arguments.members[1].typeName.name);
Assert.IsNotInstanceOfType(a.arguments.members[1].typeName, typeof(GenericTypeName));
AdditionExpression d = assertTypeAndCast <AdditionExpression>(a.body.innerExpressions[0]);
VariableReferenceExpression e = assertTypeAndCast <VariableReferenceExpression>(d.left);
IntegralLiteralExpression f = assertTypeAndCast <IntegralLiteralExpression>(d.right);
Assert.AreEqual("a", e.name);
Assert.AreEqual(5, f.value);
}
public int AdditionInteger(AdditionExpression node, List <Object> parameters)
{
int leftOperand = _interpreter.DispatchInt(node.Children[0], parameters);
int rightOperand = _interpreter.DispatchInt(node.Children[1], parameters);
return(leftOperand + rightOperand);
}
public TypeNode VisitAddition(AdditionExpression n, List <TypeNode> parameterTypes)
{
TypeNode left = GetType(n.Children[0], parameterTypes);
TypeNode right = GetType(n.Children[1], parameterTypes);
if ((left.Type == TypeEnum.Integer && right.Type == TypeEnum.Real) || (left.Type == TypeEnum.Real && right.Type == TypeEnum.Integer))
{
CastToReal(n, left, 0);
CastToReal(n, right, 1);
return(new TypeNode(TypeEnum.Real, 0, 0));
}
else if (left.Type == TypeEnum.Integer && right.Type == TypeEnum.Integer)
{
return(new TypeNode(TypeEnum.Integer, 0, 0));
}
else if (left.Type == TypeEnum.Real && right.Type == TypeEnum.Real)
{
return(new TypeNode(TypeEnum.Real, 0, 0));
}
else if ((left.Type == TypeEnum.String && IsAddableType(right.Type)) || IsAddableType(left.Type) && right.Type == TypeEnum.String)
{
CastToString(n, left, 0);
CastToString(n, right, 1);
return(new TypeNode(TypeEnum.String, 0, 0));
}
throw new UnmatchableTypesException(n, left.Type, right.Type, "number or string");
}
public TypeNode Dispatch(ExpressionNode node, List <TypeNode> parameterTypes)
{
return(node switch
{
IBinaryNumberOperator n => _numberHelper.VisitBinaryNumOp(n, parameterTypes),
IBinaryBooleanOperator n => _booleanHelper.VisitBinaryBoolOp(n, parameterTypes),
IBinarySetOperator n => _setHelper.VisitBinarySetOp(n, parameterTypes),
SubsetExpression n => _setHelper.VisitSubset(n, parameterTypes),
SetExpression n => _setHelper.VisitSet(n, parameterTypes),
NotExpression n => _booleanHelper.VisitNot(n, parameterTypes),
FunctionCallExpression n => _declarationHelper.VisitFunctionCall(n, parameterTypes),
IdentifierExpression n => _declarationHelper.VisitIdentifier(n, parameterTypes),
IntegerLiteralExpression _ => _declarationHelper.VisitIntegerLiteral(),
RealLiteralExpression _ => _declarationHelper.VisitRealLiteral(),
BooleanLiteralExpression _ => _declarationHelper.VisitBooleanLiteral(),
StringLiteralExpression _ => _declarationHelper.VisitStringLiteral(),
EmptySetLiteralExpression _ => _declarationHelper.VisitEmptySetLiteral(),
AdditionExpression n => _commonOperatorHelper.VisitAddition(n, parameterTypes),
SubtractionExpression n => _commonOperatorHelper.VisitSubtraction(n, parameterTypes),
AbsoluteValueExpression n => _commonOperatorHelper.VisitAbsoluteValue(n, parameterTypes),
IRelationOperator n => _commonOperatorHelper.VisitRelationalOperator(n, parameterTypes),
IEquivalenceOperator n => _commonOperatorHelper.VisitEquivalenceOperator(n, parameterTypes),
NegativeExpression n => _numberHelper.VisitNegative(n, parameterTypes),
ElementExpression n => _commonOperatorHelper.VisitElement(n, parameterTypes),
ISetGraphField n => _commonOperatorHelper.VisitISetGraphField(n, parameterTypes),
IFunctionGraphField n => _commonOperatorHelper.VisitIFunctionGraphField(n, parameterTypes),
GraphExpression n => _commonOperatorHelper.VisitGraph(n, parameterTypes),
AnonymousFunctionExpression n => _declarationHelper.VisitAnonymousFunction(n, parameterTypes),
_ => throw new UnimplementedTypeCheckerException(node, "Dispatch"),
});
public void Visit(AdditionExpression ae)
{
sb.Append("(");
ae.Left.Accept(this);
sb.Append("+");
ae.Right.Accept(this);
sb.Append(")");
}
public override void Visit(AdditionExpression ae)
{
str += "(";
ae.LHS.Accept(this);
str += "+";
ae.RHS.Accept(this);
str += ")";
}
protected void Evaluate(AdditionExpression addition)
{
Visit(addition.Left);
var tempEquation = "(" + Equation + " + ";
Visit(addition.Right);
Equation = tempEquation + Equation + ")";
}
public void SetUp()
{
_expression = new AdditionExpression(
new DoubleExpression(1),
new AdditionExpression(
new DoubleExpression(2),
new DoubleExpression(3)));
}
public void Two_Plus_Two_Equals_Four()
{
var two = new UnaryExpression <int>(2);
var additionExpression = new AdditionExpression(two, two);
var value = additionExpression.Value;
Assert.AreEqual(4, value, "Two + Two = 4");
}
public override void Visit(AdditionExpression ae)
{
sb.Append("(");
ae.LHS.Accept(this);
sb.Append("+");
ae.RHS.Accept(this);
sb.Append(")");
}
public void Visit(AdditionExpression ae)
{
ae.Left.Accept(this);
var left = Result;
ae.Right.Accept(this);
Result += left;
}
protected void Evaluate(AdditionExpression addition)
{
Visit(addition.Left);
var leftResult = Result;
Visit(addition.Right);
Result += leftResult;
}
public void EvaluateWithTwoNormalOperands()
{
var left = new Expression { Value = 1 };
var right = new Expression { Value = 2 };
var expression = new AdditionExpression(left, right);
Assert.AreEqual(3, expression.Evaluate());
}
public void Two_Plus_Two_Times_Negative_Four_Equals_negative_Eight()
{
var two = new UnaryExpression <int>(2);
var additionExpression = new AdditionExpression(two, two);
var multiply = new Multiply(additionExpression, new NegativeOf(two.Value));
var value = multiply.Value;
Assert.AreEqual(-8, value, "Two + Two = 4");
}
public void TestExpression()
{
var e = new AdditionExpression(new DoubleExpression(1),
new AdditionExpression(new DoubleExpression(2), new DoubleExpression(3)));
var sb = new StringBuilder();
e.Print(sb);
Console.WriteLine(sb);
}
public void EvaluateWithTwoNormalOperands()
{
var left = new ConstantExpression(1);
var right = new ConstantExpression(2);
var expression = new AdditionExpression(left, right);
Assert.AreEqual(3, expression.Evaluate());
}
public void Addition_TestCases(int a, int b, int expectedValue)
{
var additionExpression = new AdditionExpression(new UnaryExpression <int>(a), new UnaryExpression <int>(b));
var value = additionExpression;
Assert.AreEqual(new UnaryExpression <int>(expectedValue), value);
}
/// <summary>
/// Creates a tree for math expression represented in Infix notation.
/// </summary>
/// <param name="s">String representing math expression in Infix notation.</param>
/// <returns>Built expression.</returns>
public MathExpression Build(string s)
{
if (string.IsNullOrEmpty(s))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(s));
}
// Convert expression to use Reverse Polish (postfix) notation
var notationConverter = new ExpressionNotationConverter();
var rpnExprStr = notationConverter.ToReversePolishNotation(s);
var stack = new Stack <MathExpression>();
string token;
var index = 0;
while ((token = ReadNextToken(rpnExprStr, ref index)) != null)
{
MathExpression expr;
var tokenKind = GetTokenKind(token);
switch (tokenKind)
{
case TokenKind.Number:
expr = new NumberExpression(token);
break;
case TokenKind.Addition:
expr = new AdditionExpression(GetChildExpressions(stack, 2, tokenKind));
break;
case TokenKind.Subtraction:
expr = new SubtractionExpression(GetChildExpressions(stack, 2, tokenKind));
break;
case TokenKind.Multiplication:
expr = new MultiplicationExpression(GetChildExpressions(stack, 2, tokenKind));
break;
case TokenKind.Division:
expr = new DivisionExpression(GetChildExpressions(stack, 2, tokenKind));
break;
default:
throw new ArgumentOutOfRangeException($"Unexpected token kind: '{tokenKind}'.");
}
stack.Push(expr);
}
if (stack.Count != 1)
{
throw new InvalidOperationException("Incorrect math expression.");
}
return(stack.Pop());
}
private static void VisitorDemo2()
{
var expr1 = new Number(10);
var expr2 = new Number(20);
var addition = new AdditionExpression(expr1, expr2);
var expression = new ExpressionPrinter();
expression.Visit(addition);
Console.WriteLine(expression);
}
public void Visit(AdditionExpression ae)
{
ae.left.Accept(this);
var a = this.Result;
ae.right.Accept(this);
var b = this.Result;
this.Result = a + b;
}
public void SimpleAddition()
{
Expression expression = parseExpression("a + b");
AdditionExpression a = assertTypeAndCast <AdditionExpression>(expression);
VariableReferenceExpression b = assertTypeAndCast <VariableReferenceExpression>(a.left);
VariableReferenceExpression c = assertTypeAndCast <VariableReferenceExpression>(a.right);
Assert.AreEqual(b.name, "a");
Assert.AreEqual(c.name, "b");
}
public void EvaluateWithOneAdditionOperand()
{
var left = new Expression { Value = 1 };
var leftTwo = new Expression { Value = 2 };
var rightTwo = new Expression { Value = 3 };
var right = new AdditionExpression(leftTwo, rightTwo);
var expression = new AdditionExpression(left, right);
Assert.AreEqual(6, expression.Evaluate());
}
public void Visit(AdditionExpression ae)
{
ae.Left.Accept(this);
var a = Result;
ae.Right.Accept(this);
var b = Result;
Result = a + b;
}
public void TestDynamicExpression()
{
Expression e = new AdditionExpression(new DoubleExpression(1),
new AdditionExpression(new DoubleExpression(2), new DoubleExpression(3)));
var ep = new ExpressionPrinter();
var sb = new StringBuilder();
ep.Print((dynamic)e, sb);
Console.WriteLine(sb);
}
public void EvaluateWithOneAdditionOperand()
{
var left = new ConstantExpression(1);
var leftTwo = new ConstantExpression(2);
var rightTwo = new ConstantExpression(3);
var right = new AdditionExpression(leftTwo, rightTwo);
var expression = new AdditionExpression(left, right);
Assert.AreEqual(6, expression.Evaluate());
}
public void VisitAdditionExpressionReturnsCorrectResult(int x, int y, CalculationVisitor sut)
{
var left = new Constant(x);
var right = new Constant(y);
var addition = new AdditionExpression(left, right);
sut.Visit(addition);
var expected = x + y;
Assert.Equal(expected, sut.Result);
}
public void EvaluateWithTwoSubtractionExpressions()
{
var leftOne = new Expression { Value = 1 };
var rightOne = new Expression { Value = 2 };
var leftTwo = new Expression { Value = 2 };
var rightTwo = new Expression { Value = 3 };
var left = new AdditionExpression(leftOne, rightOne);
var right = new AdditionExpression(leftTwo, rightTwo);
var expression = new AdditionExpression(left, right);
Assert.AreEqual(8, expression.Evaluate());
}