// 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); } }
protected virtual double VisitDivisionExpression(DivisionExpression expr) { var arg1 = Visit(expr.Arg1); var arg2 = Visit(expr.Arg2); return(arg1 / arg2); }
private double CalculateBinary(TerminalExpression a, TerminalExpression b) { // double hasil = 0; if (op == '+') { AddExpression hasil = new AddExpression(a, b); //hasil = a + b; return(hasil.solve()); } else if (op == '-') { SubstractExpression hasil = new SubstractExpression(a, b); //hasil = a - b; return(hasil.solve()); } else if (op == '*') { MultiplyExpression hasil = new MultiplyExpression(a, b); //hasil = a * b; return(hasil.solve()); } else if (op == '÷') { DivisionExpression hasil = new DivisionExpression(a, b); //hasil = a / b; return(hasil.solve()); } return(0); }
public void EvaluateWithTwoNormalOperands() { var left = new Expression { Value = 1 }; var right = new Expression { Value = 2 }; var expression = new DivisionExpression(left, right); Assert.AreEqual(0.5, expression.Evaluate()); }
protected void Evaluate(DivisionExpression division) { Visit(division.Left); var tempEquation = "(" + Equation + " / "; Visit(division.Right); Equation = tempEquation + Equation + ")"; }
/// <summary> /// Visits a <see cref="DivisionExpression" />. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="conversionParameters">The conversion parameters.</param> /// <param name="conversionVariables">The conversion variables.</param> public void Divide( DivisionExpression divisionExpression, ConversionParameters conversionParameters, ConversionVariables conversionVariables) { divisionExpression.Lhs.Visit(this, conversionParameters, conversionVariables); divisionExpression.Rhs.Visit(this, conversionParameters, new ConversionVariables(conversionVariables.Exponent * -1, true)); }
protected void Evaluate(DivisionExpression division) { Visit(division.Left); var leftResult = Result; Visit(division.Right); Result = leftResult / Result; }
/// <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 DivisionExpression(left, right); Assert.AreEqual(0.5, expression.Evaluate()); }
public void EvaluateWithOneMultiplicationExpression() { var left = new Expression { Value = 1 }; var leftTwo = new Expression { Value = 2 }; var rightTwo = new Expression { Value = 4 }; var right = new DivisionExpression(leftTwo, rightTwo); var expression = new DivisionExpression(left, right); Assert.AreEqual(2, expression.Evaluate()); }
public void EvaluateWithOneMultiplicationExpression() { var left = new ConstantExpression(1); var leftTwo = new ConstantExpression(2); var rightTwo = new ConstantExpression(4); var right = new DivisionExpression(leftTwo, rightTwo); var expression = new DivisionExpression(left, right); Assert.AreEqual(2, expression.Evaluate()); }
public void VisitDivisionExpressionReturnsCorrectResult(int x, int y, EquationPrintingVisitor sut) { var left = new Constant(x); var right = new Constant(y); var division = new DivisionExpression(left, right); sut.Visit(division); var expected = $"({x} / {y})"; Assert.Equal(expected, sut.Equation); }
public void VisitDivisionExpressionReturnsCorrectResult(int x, int y, CalculationVisitor sut) { var left = new Constant(x); var right = new Constant(y); var division = new DivisionExpression(left, right); sut.Visit(division); var expected = x / y; Assert.Equal(expected, sut.Result); }
public int DivisionInteger(DivisionExpression node, List <Object> parameters) { int leftOperand = _interpreter.DispatchInt(node.Children[0], parameters); int rightOperand = _interpreter.DispatchInt(node.Children[1], parameters); if (rightOperand == 0) { throw new DivisionByZeroException(node); } return(leftOperand / rightOperand); }
public double DivisionReal(DivisionExpression node, List <object> parameters) { double leftOperand = _interpreter.DispatchReal(node.Children[0], parameters); double rightOperand = _interpreter.DispatchReal(node.Children[1], parameters); if (rightOperand == 0.0) { throw new DivisionByZeroException(node); } return(leftOperand / rightOperand); }
public void EvaluateWithTwoMultiplicationExpressions() { var leftOne = new Expression { Value = 1 }; var rightOne = new Expression { Value = 2 }; var leftTwo = new Expression { Value = 6 }; var rightTwo = new Expression { Value = 3 }; var left = new DivisionExpression(leftOne, rightOne); var right = new DivisionExpression(leftTwo, rightTwo); var expression = new DivisionExpression(left, right); Assert.AreEqual(0.25, expression.Evaluate()); }
public void EvaluateWithTwoMultiplicationExpressions() { var leftOne = new ConstantExpression(1); var rightOne = new ConstantExpression(2); var leftTwo = new ConstantExpression(6); var rightTwo = new ConstantExpression(3); var left = new DivisionExpression(leftOne, rightOne); var right = new DivisionExpression(leftTwo, rightTwo); var expression = new DivisionExpression(left, right); Assert.AreEqual(0.25, expression.Evaluate()); }
public void DivisionReal_DivisorIsZero_ThrowsException(double input1, double input2) { RealLiteralExpression realLit1 = new RealLiteralExpression(input1, 1, 1); RealLiteralExpression realLit2 = new RealLiteralExpression(input2, 2, 2); DivisionExpression divisionExpr = new DivisionExpression(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); Assert.ThrowsException <DivisionByZeroException>(() => realHelper.DivisionReal(divisionExpr, new List <object>())); }
/// <summary> /// Adds a mfrac tag with two mrow tags and visits the lhs and rhs expression. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="multiplicationSign">The multiplication sign.</param> /// <param name="xElement">The x element.</param> public void Divide( DivisionExpression divisionExpression, MultiplicationSign multiplicationSign, XElement xElement) { var nominator = new XElement(MathML.Mrow); var denominator = new XElement(MathML.Mrow); var fraction = new XElement(MathML.Mfrac, nominator, denominator); xElement.Add(fraction); divisionExpression.Lhs.Visit(this, multiplicationSign, nominator); divisionExpression.Rhs.Visit(this, multiplicationSign, denominator); }
public static BinaryExpression Create(Expression left, Expression right, char oper) { BinaryExpression expr = null; switch(oper) { case '+' : expr = new AdditiveExpression(left,right); break; case '-': expr = new SubstractExpression(left, right); break; case '*' : expr = new MultiplicativeExpression(left,right); break; case '/' : expr = new DivisionExpression(left,right); break; } expr.oper = oper; return expr; }
/// <summary> /// Visits a <see cref="DivisionExpression" />. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="notationParameters">The notation parameters.</param> /// <param name="notationVariables">The notation variables.</param> public void Divide( DivisionExpression divisionExpression, NotationParameters notationParameters, NotationVariables notationVariables) { var requestPrecendence = notationVariables.RequestPrecedence; var stringBuilder = notationParameters.StringBuilder; this.HandleLeftPrecedence(requestPrecendence, stringBuilder); divisionExpression.Lhs.Visit(this, notationParameters, new NotationVariables(false, true)); stringBuilder.Append(Constants.Divide); divisionExpression.Rhs.Visit(this, notationParameters, new NotationVariables(true, true)); this.HandleRightPrecedence(requestPrecendence, stringBuilder); }
/// <summary> /// Visits a <see cref="DivisionExpression"/>. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="value">The value.</param> /// <param name="currentResult">The current result.</param> public void Divide(DivisionExpression divisionExpression, double value, Reference <double> currentResult) { var lhs = this.PrivateVisit(divisionExpression.Lhs, value, currentResult); if (lhs.Equals(Zero)) { currentResult.Value = Zero; return; } var rhs = this.PrivateVisit(divisionExpression.Rhs, value, currentResult); currentResult.Value = lhs / rhs * value; }
public void DivisionInteger_TwoIntegers_ReturnsCorrectResultOfDivision(int input1, int input2, int expected) { IntegerLiteralExpression intLit1 = new IntegerLiteralExpression(input1.ToString(), 1, 1); IntegerLiteralExpression intLit2 = new IntegerLiteralExpression(input2.ToString(), 2, 2); DivisionExpression divExpr = new DivisionExpression(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.DivisionInteger(divExpr, new List <object>()); Assert.AreEqual(expected, res); }
public void DivisionReal_TwoReals_ReturnsCorrectResult(double input1, double input2, double expected) { RealLiteralExpression realLit1 = new RealLiteralExpression(input1, 1, 1); RealLiteralExpression realLit2 = new RealLiteralExpression(input2, 2, 2); DivisionExpression divisionExpr = new DivisionExpression(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.DivisionReal(divisionExpr, new List <object>()); Assert.AreEqual(expected, res); }
/// <summary> /// Visits a <see cref="DivisionExpression" />. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="rewritingParameters">The rewriting parameters.</param> /// <param name="currentResult">The current result.</param> public void Divide( DivisionExpression divisionExpression, RewritingParameters rewritingParameters, Reference <Expression> currentResult) { divisionExpression.Lhs.Visit(this, rewritingParameters, currentResult); var lhs = currentResult.Value; divisionExpression.Rhs.Visit(this, rewritingParameters, currentResult); var rhs = currentResult.Value; currentResult.Value = this.SelectCurrentExpression( divisionExpression, lhs, rhs, (newLhs, newRhs) => new DivisionExpression(newLhs, newRhs)); }
public void DispatchReal_DivisionAndObjectList_CorrectListPassed() { List <Object> expected = new List <Object>() { 23, 2.334, null }; DivisionExpression input1 = new DivisionExpression(null, null, 0, 0); IRealHelper rhelper = Substitute.For <IRealHelper>(); Interpreter interpreter = Utilities.GetIntepreterOnlyWith(rhelper); List <Object> res = null; rhelper.DivisionReal(Arg.Any <DivisionExpression>(), Arg.Do <List <Object> >(x => res = x)); interpreter.DispatchReal(input1, expected); res.Should().BeEquivalentTo(expected); }
public void DispatchReal_DivisionAndObjectList_CorrectValueReturned() { double expected = 17; DivisionExpression input1 = new DivisionExpression(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.DivisionReal(Arg.Any <DivisionExpression>(), Arg.Any <List <Object> >()).Returns(expected); double res = interpreter.DispatchReal(input1, input2); Assert.AreEqual(expected, res); }
public void DispatchInteger_DivisionAndObjectList_CorrectDivisionExprPassed() { DivisionExpression expected = new DivisionExpression(null, null, 0, 0); DivisionExpression input1 = expected; List <Object> input2 = new List <Object>() { 23, 2.334, null }; IIntegerHelper ihelper = Substitute.For <IIntegerHelper>(); Interpreter interpreter = Utilities.GetIntepreterOnlyWith(ihelper); DivisionExpression res = null; ihelper.DivisionInteger(Arg.Do <DivisionExpression>(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"); }
public void SparqlParallelEvaluationDivision1() { INode zero = (0).ToLiteral(this._factory); INode one = (0).ToLiteral(this._factory); List <INode[]> data = new List <INode[]>() { new INode[] { zero, zero, zero }, new INode[] { zero, one, zero }, new INode[] { one, zero, null }, new INode[] { one, one, one } }; BaseMultiset multiset = new Multiset(); foreach (INode[] row in data) { Set s = new Set(); s.Add("x", row[0]); s.Add("y", row[1]); s.Add("expected", row[2]); } ISparqlExpression expr = new DivisionExpression(new VariableTerm("x"), new VariableTerm("y")); for (int i = 1; i <= 10000; i++) { Console.WriteLine("Iteration #" + i); SparqlEvaluationContext context = new SparqlEvaluationContext(null, null); context.InputMultiset = multiset; context.OutputMultiset = new Multiset(); context.InputMultiset.SetIDs.AsParallel().ForAll(id => this.EvalExtend(context, context.InputMultiset, expr, "actual", id)); foreach (ISet s in context.OutputMultiset.Sets) { Assert.Equal(s["expected"], s["actual"]); } Console.WriteLine("Iteration #" + i + " Completed OK"); } }
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 Bitmap Visit(DivisionExpression expr) { return(ComputeFunction(expr)); }
/// <summary> /// Visits a <see cref="DivisionExpression" />. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="_">The ignored.</param> /// <param name="currentResult">The current result.</param> public void Divide(DivisionExpression divisionExpression, ˍ _, Reference <Expression> currentResult) { currentResult.Value = new DivisionExpression( this.PrivateVisit(divisionExpression.Lhs, currentResult), this.PrivateVisit(divisionExpression.Rhs, currentResult)); }
/// <summary> /// Visits a <see cref="DivisionExpression"/>. /// </summary> /// <param name="divisionExpression">The division expression.</param> /// <param name="value">The value.</param> /// <param name="currentResult">The current result.</param> public void Divide(DivisionExpression divisionExpression, double value, Reference <double> currentResult) { currentResult.Value = this.Visit(divisionExpression.Lhs) / this.Visit(divisionExpression.Rhs); }