/// <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(); }
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"); }