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