/// <summary>
/// Visits a <see cref="MultiplicationExpression" />.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="_">The ignored.</param>
/// <param name="currentResult">The current result.</param>
public void Multiply(MultiplicationExpression multiplicationExpression, ˍ _, Reference <Expression> currentResult)
{
currentResult.Value =
new MultiplicationExpression(
this.PrivateVisit(multiplicationExpression.Lhs, currentResult),
this.PrivateVisit(multiplicationExpression.Rhs, currentResult));
}
public int MultiplicationInteger(MultiplicationExpression node, List <Object> parameters)
{
int leftOperand = _interpreter.DispatchInt(node.Children[0], parameters);
int rightOperand = _interpreter.DispatchInt(node.Children[1], parameters);
return(leftOperand * rightOperand);
}
protected virtual double VisitMultiplicationExpression(MultiplicationExpression expr)
{
var arg1 = Visit(expr.Arg1);
var arg2 = Visit(expr.Arg2);
return(arg1 * arg2);
}
/// <summary>
/// Visits a <see cref="MultiplicationExpression"/>.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="value">The value.</param>
/// <param name="currentResult">The current result.</param>
public void Multiply(
MultiplicationExpression multiplicationExpression,
double value,
Reference <double> currentResult)
{
currentResult.Value = this.Visit(multiplicationExpression.Lhs) / this.Visit(multiplicationExpression.Rhs);
}
public double MultiplicationReal(MultiplicationExpression 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 EvaluateWithTwoNormalOperands()
{
var left = new Expression { Value = 1 };
var right = new Expression { Value = 2 };
var expression = new MultiplicationExpression(left, right);
Assert.AreEqual(2, expression.Evaluate());
}
private MultiplicationExpression GetMultiplicationExpression(TypeEnum left, TypeEnum right)
{
ExpressionNode leftNode = GetLiteral(left);
ExpressionNode rightNode = GetLiteral(right);
var node = new MultiplicationExpression(leftNode, rightNode, 0, 0);
return(node);
}
/// <summary>
/// Visits a <see cref="MultiplicationExpression" />.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="conversionParameters">The conversion parameters.</param>
/// <param name="conversionVariables">The conversion variables.</param>
public void Multiply(
MultiplicationExpression multiplicationExpression,
ConversionParameters conversionParameters,
ConversionVariables conversionVariables)
{
multiplicationExpression.Lhs.Visit(this, conversionParameters, conversionVariables);
multiplicationExpression.Rhs.Visit(this, conversionParameters, conversionVariables);
}
protected void Evaluate(MultiplicationExpression multiplication)
{
Visit(multiplication.Left);
var tempEquation = "(" + Equation + " * ";
Visit(multiplication.Right);
Equation = tempEquation + Equation + ")";
}
protected void Evaluate(MultiplicationExpression multiplication)
{
Visit(multiplication.Left);
var leftResult = Result;
Visit(multiplication.Right);
Result *= leftResult;
}
/// <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());
}
public void EvaluateWithTwoNormalOperands()
{
var left = new ConstantExpression(1);
var right = new ConstantExpression(2);
var expression = new MultiplicationExpression(left, right);
Assert.AreEqual(2, expression.Evaluate());
}
/// <summary>
/// Adds a mo tag and visits the lhs and rhs expression.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="multiplicationSign">The multiplication sign.</param>
/// <param name="xElement">The x element.</param>
public void Multiply(
MultiplicationExpression multiplicationExpression,
MultiplicationSign multiplicationSign,
XElement xElement)
{
multiplicationExpression.Lhs.Visit(this, multiplicationSign, xElement);
xElement.Add(new XElement(MathML.Mo, MathML.GetMultiplicationSign(multiplicationSign)));
multiplicationExpression.Rhs.Visit(this, multiplicationSign, xElement);
}
public void ProductOfAdditionAndValue()
{
var expr = new MultiplicationExpression(
new AdditionExpression(new Value(2), new Value(3)),
new Value(4)
);
var ep = new ExpressionPrinter();
ep.Visit(expr);
Assert.That(ep.ToString(), Is.EqualTo("(2+3)*4"));
}
public void EvaluateWithOneMultiplicationExpression()
{
var left = new Expression { Value = 1 };
var leftTwo = new Expression { Value = 2 };
var rightTwo = new Expression { Value = 3 };
var right = new MultiplicationExpression(leftTwo, rightTwo);
var expression = new MultiplicationExpression(left, right);
Assert.AreEqual(6, expression.Evaluate());
}
public void VisitMultiplicationExpressionReturnsCorrectResult(int x, int y, EquationPrintingVisitor sut)
{
var left = new Constant(x);
var right = new Constant(y);
var multiplication = new MultiplicationExpression(left, right);
sut.Visit(multiplication);
var expected = $"({x} * {y})";
Assert.Equal(expected, sut.Equation);
}
public void VisitMultiplicationExpressionReturnsCorrectResult(int x, int y, CalculationVisitor sut)
{
var left = new Constant(x);
var right = new Constant(y);
var multiplication = new MultiplicationExpression(left, right);
sut.Visit(multiplication);
var expected = x * y;
Assert.Equal(expected, sut.Result);
}
public void EvaluateWithOneMultiplicationExpression()
{
var left = new ConstantExpression(1);
var leftTwo = new ConstantExpression(2);
var rightTwo = new ConstantExpression(3);
var right = new MultiplicationExpression(leftTwo, rightTwo);
var expression = new MultiplicationExpression(left, right);
Assert.AreEqual(6, expression.Evaluate());
}
public void Visit_When_ConvertingFromFahrenheitSeconds_Then_ResultShouldBeExpected(
double value,
double expected)
{
var testee = new MultiplicationExpression(
UnitDefinitions.Fahrenheit.GetExpression(),
UnitDefinitions.Hour.GetExpression());
var result = new Reference<double>();
testee.Visit(new ValueToBaseVisitor(), value, result);
result.Value.Should().BeApproximately(expected, TestHelper.DefaultAssertPrecision);
}
public void Visit_When_ConvertingFromFahrenheitSeconds_Then_ResultShouldBeExpected(
double value,
double expected)
{
var testee = new MultiplicationExpression(
UnitDefinitions.Fahrenheit.GetExpression(),
UnitDefinitions.Hour.GetExpression());
var result = new Reference <double>();
testee.Visit(new ValueToBaseVisitor(), value, result);
result.Value.Should().BeApproximately(expected, TestHelper.DefaultAssertPrecision);
}
/// <summary>
/// Visits a <see cref="MultiplicationExpression" />.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="notationParameters">The notation parameters.</param>
/// <param name="notationVariables">The notation variables.</param>
public void Multiply(
MultiplicationExpression multiplicationExpression,
NotationParameters notationParameters,
NotationVariables notationVariables)
{
var requestPrecendence = notationVariables.RequestPrecedence;
var stringBuilder = notationParameters.StringBuilder;
this.HandleLeftPrecedence(requestPrecendence, stringBuilder);
multiplicationExpression.Lhs.Visit(this, notationParameters, new NotationVariables(false, true));
stringBuilder.Append(Constants.Multiply);
multiplicationExpression.Rhs.Visit(this, notationParameters, new NotationVariables(true, true));
this.HandleRightPrecedence(requestPrecendence, stringBuilder);
}
public void MultiplicationInteger_TwoIntegers_ReturnsCorrectResultOfMultiplication(int input1, int input2, int expected)
{
IntegerLiteralExpression intLit1 = new IntegerLiteralExpression(input1.ToString(), 1, 1);
IntegerLiteralExpression intLit2 = new IntegerLiteralExpression(input2.ToString(), 2, 2);
MultiplicationExpression multExpr = new MultiplicationExpression(intLit1, intLit2, 1, 1);
IInterpreterInteger parent = Substitute.For <IInterpreterInteger>();
parent.DispatchInt(intLit1, Arg.Any <List <object> >()).Returns(input1);
parent.DispatchInt(intLit2, Arg.Any <List <object> >()).Returns(input2);
IntegerHelper integerHelper = SetUpHelper(parent);
int res = integerHelper.MultiplicationInteger(multExpr, new List <object>());
Assert.AreEqual(expected, res);
}
public void MultiplicationReal_TwoReals_ReturnsCorrectResult(double input1, double input2, double expected)
{
RealLiteralExpression realLit1 = new RealLiteralExpression(input1, 1, 1);
RealLiteralExpression realLit2 = new RealLiteralExpression(input2, 2, 2);
MultiplicationExpression multiplicationExpr = new MultiplicationExpression(realLit1, realLit2, 1, 1);
IInterpreterReal parent = Substitute.For <IInterpreterReal>();
parent.DispatchReal(realLit1, Arg.Any <List <object> >()).Returns(input1);
parent.DispatchReal(realLit2, Arg.Any <List <object> >()).Returns(input2);
RealHelper realHelper = SetUpHelper(parent);
double res = realHelper.MultiplicationReal(multiplicationExpr, new List <object>());
Assert.AreEqual(expected, res);
}
public void ProductOfAdditionAndValue()
{
// Arrange
var expr = new MultiplicationExpression(
new AdditionExpression(new Value(2), new Value(3)),
new Value(4)
);
var ep = new ExpressionPrinter();
// Act
ep.Visit(expr);
// Assert
ep.ToString().Should().Be("(2+3)*4");
}
static void Main(string[] args)
{
IArithmeticVisitor visitor = new ConsoleArithmeticVisitor();
IArithmeticExpression leftInnerNode = new ConstantExpression(39);
IArithmeticExpression rightInnerNode = new ConstantExpression(13);
IArithmeticExpression leftNode = new ConstantExpression(15);
IArithmeticExpression rightNode = new SubtractionExpression(leftInnerNode, rightInnerNode);
IArithmeticExpression rootNode = new MultiplicationExpression(leftNode, new BracketsExpression(rightNode));
rootNode.Accept(visitor);
Console.WriteLine();
}
static void Main(string[] args)
{
IArithmeticVisitor visitor = new ConsoleArithmeticVisitor();
IArithmeticExpression leftInnerNode = new ConstantExpression(39);
IArithmeticExpression rightInnerNode = new ConstantExpression(13);
IArithmeticExpression leftNode = new ConstantExpression(15);
IArithmeticExpression rightNode = new SubtractionExpression(leftInnerNode, rightInnerNode);
IArithmeticExpression rootNode = new MultiplicationExpression(leftNode, new BracketsExpression(rightNode));
rootNode.Accept(visitor);
Console.WriteLine();
}
public void DispatchReal_MultiplicationAndObjectList_CorrectValueReturned()
{
double expected = 17;
MultiplicationExpression input1 = new MultiplicationExpression(null, null, 0, 0);
List <Object> input2 = new List <Object>()
{
23, 2.334, null
};
IRealHelper rhelper = Substitute.For <IRealHelper>();
Interpreter interpreter = Utilities.GetIntepreterOnlyWith(rhelper);
rhelper.MultiplicationReal(Arg.Any <MultiplicationExpression>(), Arg.Any <List <Object> >()).Returns(expected);
double res = interpreter.DispatchReal(input1, input2);
Assert.AreEqual(expected, res);
}
public void DispatchReal_MultiplicationAndObjectList_CorrectListPassed()
{
List <Object> expected = new List <Object>()
{
23, 2.334, null
};
MultiplicationExpression input1 = new MultiplicationExpression(null, null, 0, 0);
IRealHelper rhelper = Substitute.For <IRealHelper>();
Interpreter interpreter = Utilities.GetIntepreterOnlyWith(rhelper);
List <Object> res = null;
rhelper.MultiplicationReal(Arg.Any <MultiplicationExpression>(), Arg.Do <List <Object> >(x => res = x));
interpreter.DispatchReal(input1, expected);
res.Should().BeEquivalentTo(expected);
}
/// <summary>
/// Visits a <see cref="MultiplicationExpression" />.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="rewritingParameters">The rewriting parameters.</param>
/// <param name="currentResult">The current result.</param>
public void Multiply(
MultiplicationExpression multiplicationExpression,
RewritingParameters rewritingParameters,
Reference <Expression> currentResult)
{
multiplicationExpression.Lhs.Visit(this, rewritingParameters, currentResult);
var lhs = currentResult.Value;
multiplicationExpression.Rhs.Visit(this, rewritingParameters, currentResult);
var rhs = currentResult.Value;
currentResult.Value = this.SelectCurrentExpression(
multiplicationExpression,
lhs,
rhs,
(newLhs, newRhs) => new MultiplicationExpression(newLhs, newRhs));
}
public void DispatchInteger_MultiplicationAndObjectList_CorrectMultiplicationExprPassed()
{
MultiplicationExpression expected = new MultiplicationExpression(null, null, 0, 0);
MultiplicationExpression input1 = expected;
List <Object> input2 = new List <Object>()
{
23, 2.334, null
};
IIntegerHelper ihelper = Substitute.For <IIntegerHelper>();
Interpreter interpreter = Utilities.GetIntepreterOnlyWith(ihelper);
MultiplicationExpression res = null;
ihelper.MultiplicationInteger(Arg.Do <MultiplicationExpression>(x => res = x), Arg.Any <List <Object> >());
interpreter.DispatchInt(input1, input2);
res.Should().BeEquivalentTo(expected);
}
public void BEDMASTest()
{
Expression expression = parseExpression("a + b * g / p - y");
SubtractionExpression a = assertTypeAndCast <SubtractionExpression>(expression);
AdditionExpression b = assertTypeAndCast <AdditionExpression>(a.left);
VariableReferenceExpression c = assertTypeAndCast <VariableReferenceExpression>(a.right);
VariableReferenceExpression d = assertTypeAndCast <VariableReferenceExpression>(b.left);
DivisionExpression e = assertTypeAndCast <DivisionExpression>(b.right);
MultiplicationExpression f = assertTypeAndCast <MultiplicationExpression>(e.left);
VariableReferenceExpression g = assertTypeAndCast <VariableReferenceExpression>(e.right);
VariableReferenceExpression h = assertTypeAndCast <VariableReferenceExpression>(f.left);
VariableReferenceExpression i = assertTypeAndCast <VariableReferenceExpression>(f.right);
Assert.AreEqual(c.name, "y");
Assert.AreEqual(d.name, "a");
Assert.AreEqual(g.name, "p");
Assert.AreEqual(h.name, "b");
Assert.AreEqual(i.name, "g");
}
/// <summary>
/// Visits a <see cref="MultiplicationExpression"/>.
/// </summary>
/// <param name="multiplicationExpression">The multiplication expression.</param>
/// <param name="value">The value.</param>
/// <param name="currentResult">The current result.</param>
public void Multiply(
MultiplicationExpression multiplicationExpression,
double value,
Reference <double> currentResult)
{
var lhs = this.PrivateVisit(multiplicationExpression.Lhs, value, currentResult);
if (lhs.Equals(Zero))
{
currentResult.Value = Zero;
return;
}
var rhs = this.PrivateVisit(multiplicationExpression.Rhs, value, currentResult);
if (rhs.Equals(Zero))
{
currentResult.Value = Zero;
return;
}
currentResult.Value = lhs * rhs / value;
}
public void ExitMultiplication(QueryParser.MultiplicationContext context)
{
CompileLeftAssociativeOperator(context.MULT_DIV(), _expressions,
(opNode, left, right) =>
{
var op = opNode.Symbol;
BinaryOperatorExpression value = null;
switch (op.Text)
{
case "*":
value = new MultiplicationExpression(op.Line, op.Column, left, right);
break;
case "/":
value = new DivisionExpression(op.Line, op.Column, left, right);
break;
}
Trace.Assert(value != null, "Invalid multiplication operator " + op.Text);
return(value);
});
}
public void TupleDefinition()
{
Expression expression = parseExpression("(a, b, 4+6,\"dsas\\\"dasd\", a - g + p * t)");
TupleDefinitionExpression a = assertTypeAndCast <TupleDefinitionExpression>(expression);
Assert.AreEqual(a.members.Count, 5);
VariableReferenceExpression b = assertTypeAndCast <VariableReferenceExpression>(a.members[0]);
VariableReferenceExpression c = assertTypeAndCast <VariableReferenceExpression>(a.members[1]);
AdditionExpression z = assertTypeAndCast <AdditionExpression>(a.members[2]);
StringLiteralExpression d = assertTypeAndCast <StringLiteralExpression>(a.members[3]);
AdditionExpression e = assertTypeAndCast <AdditionExpression>(a.members[4]);
Assert.AreEqual(b.name, "a");
Assert.AreEqual(c.name, "b");
IntegralLiteralExpression y = assertTypeAndCast <IntegralLiteralExpression>(z.left);
IntegralLiteralExpression x = assertTypeAndCast <IntegralLiteralExpression>(z.right);
Assert.AreEqual(4, y.value);
Assert.AreEqual(6, x.value);
Assert.AreEqual(d.value, "dsas\"dasd");
SubtractionExpression f = assertTypeAndCast <SubtractionExpression>(e.left);
MultiplicationExpression g = assertTypeAndCast <MultiplicationExpression>(e.right);
VariableReferenceExpression h = assertTypeAndCast <VariableReferenceExpression>(f.left);
VariableReferenceExpression i = assertTypeAndCast <VariableReferenceExpression>(f.right);
VariableReferenceExpression j = assertTypeAndCast <VariableReferenceExpression>(g.left);
VariableReferenceExpression k = assertTypeAndCast <VariableReferenceExpression>(g.right);
Assert.AreEqual(h.name, "a");
Assert.AreEqual(i.name, "g");
Assert.AreEqual(j.name, "p");
Assert.AreEqual(k.name, "t");
}
