private Expression ParseExpression()
{
var expression = ParseFactor();
while (true)
{
_scanner.SkipWhiteSpace();
if (_scanner.ReadChar('+'))
{
_scanner.SkipWhiteSpace();
expression = new Addition(expression, ParseFactor());
}
else if (_scanner.ReadChar('-'))
{
_scanner.SkipWhiteSpace();
expression = new Subtraction(expression, ParseFactor());
}
else
{
break;
}
}
return(expression);
}
public static ICalculable GetOperationClass(ModelCalculator.Operators selectedOperator)
{
ICalculable calculateClass = default(ICalculable);
switch (selectedOperator)
{
case ModelCalculator.Operators.Addition:
calculateClass = new Addition();
break;
case ModelCalculator.Operators.Division:
calculateClass = new Division();
break;
case ModelCalculator.Operators.Multiplication:
calculateClass = new Multiplication();
break;
case ModelCalculator.Operators.Subtraction:
calculateClass = new Subtraction();
break;
case ModelCalculator.Operators.SquareRoot:
calculateClass = new SquareRoot();
break;
}
return(calculateClass);
}
public void Test2()
{
var calculation = new Subtraction(10, 10);
var result = calculation.Calculate();
Assert.Equal(0, result);
}
public void CalculateTest()
{
var calculator = new Subtraction();
var actual = calculator.Calculate(10, 5);
Assert.AreEqual(5, actual, 0.01);
}
public void DivisionTest(double first, double second, double expected)
{
ICalculate calculate = new Subtraction();
double result = calculate.Calculate(first, second);
Assert.AreEqual(expected, result);
}
public void SubtractionResultNotNull()
{
Subtraction subt = new Subtraction();
int subAnswer = subt.SubtractionOperation(4, 3);
Assert.IsNotNull(subAnswer);
}
public void CalculateTest(double firstValue, double secondValue, double expected)
{
var calculator = new Subtraction();
var actualResult = calculator.Calculator(firstValue, secondValue);
Assert.AreEqual(expected, actualResult);
}
public void Calcpr()
{
var calculator = new Subtraction();
var actual = calculator.Calculate(9, 3);
Assert.AreEqual(6, actual);
}
public void SubtractionCalculation()
{
Subtraction subt = new Subtraction();
int subAnswer = subt.SubtractionOperation(1, 5);
Assert.AreEqual(-4, subAnswer);
}
public void SimpleTest(double firstarg, double seconarg, double expected)
{
Subtraction calc = new Subtraction();
double result = calc.Calculate(firstarg, seconarg);
Assert.AreEqual(expected, result);
}
public void isSubtracting()
{
var obj = new Subtraction(1.0, 3.0);
obj.calculate();
Assert.Equal(obj.result(), -2);
}
public void ZeroBasedMultiplicationRemover_Doesnt_Change_TangentSubtraction()
{
var expression = new Subtraction
{
Left = new Tangent {
Value = 0
},
Right = new Constant {
Value = 0
}
};
var result = mZeroRemover.Simplify(expression);
result.Should()
.BeOfType <Subtraction>()
.Which.Left.Should()
.BeOfType <Tangent>()
.Which.Value.Should()
.Be(0);
result.Should()
.BeOfType <Subtraction>()
.Which.Right.Should()
.BeOfType <Constant>()
.Which.Value.Should()
.Be(0);
}
void HandleSubtractionInAddition(Addition operation, Subtraction chainedOperation)
{
var parent = (IArithmeticOperation)chainedOperation.Parent;
if (mIsRight)
{
parent.Left = chainedOperation.Left;
operation.Right = new Addition
{
Left = new Subtraction {
Left = new Constant {
Value = 0
}, Right = chainedOperation.Right
},
Right = operation.Right
};
}
else
{
parent.Left = new Subtraction {
Left = new Constant {
Value = 0
}, Right = chainedOperation.Right
};
operation.Right = new Addition {
Left = chainedOperation.Left, Right = operation.Right
};
}
}
void HandelSubtractionInSubtraction(Subtraction operation, Subtraction chainedOperation)
{
var parent = (IArithmeticOperation)chainedOperation.Parent;
if (mIsRight)
{
parent.Left = chainedOperation.Left;
operation.Right = new Subtraction
{
Left = new Subtraction {
Left = new Constant {
Value = 0
}, Right = chainedOperation.Right
},
Right = operation.Right
};
mWasChanged = true;
}
else
{
parent.Left = chainedOperation.Right;
operation.Right = new Subtraction {
Left = chainedOperation.Left, Right = operation.Right
};
mWasChanged = true;
}
}
public void Calculate(double firstArgument, double secondArgument, double result)
{
var calculator = new Subtraction();
var testresult = calculator.Calculate(firstArgument, secondArgument);
Assert.AreEqual(result, testresult);
}
void HandelAdditionInSubtraction(Subtraction operation, Addition chainedOperation)
{
var parent = (IArithmeticOperation)chainedOperation.Parent;
if (mIsRight)
{
parent.Left = chainedOperation.Left;
var replacement = new Addition
{
Left = operation.Left,
Right = new Subtraction {
Left = chainedOperation.Right, Right = operation.Right
}
};
CheckForParent(operation, replacement);
mWasChanged = true;
}
else
{
parent.Left = chainedOperation.Right;
var replacement = new Addition
{
Left = operation.Left,
Right = new Subtraction {
Left = chainedOperation.Left, Right = operation.Right
}
};
CheckForParent(operation, replacement);
mWasChanged = true;
}
}
public Calculator()
{
_operators = new Dictionary <string, IOperator>();
_operators["+"] = new Addition();
_operators["-"] = new Subtraction();
_operators["*"] = new Multiplication();
}
public void GetSubResults(Subtraction subtraction)
{
try
{
string[] values = new string[] { subtraction.Minuend, subtraction.Subtrahend };
var allNumbers = CalculatorService.Server.Helpers.Numbers.AllNumbers(values);
if (allNumbers)
{
var valuesToOperate = CalculatorService.Server.Helpers.Numbers.ConvertStringArrayToDoubleArray(values);
// If subtrahend < 0, change it to positive number
valuesToOperate[1] = valuesToOperate[1] < 0 ? valuesToOperate[1] * -1 : valuesToOperate[1];
double result = valuesToOperate[0] - valuesToOperate[1];
subtraction.Total = result;
}
else
{
throw new Exception("Some of the elements are not numerics");
}
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public void subtraction(double value01, double value02, double expected)
{
Subtraction subtraction = new Subtraction();
double subtractionResult = subtraction.action(value01, value02);
Assert.Equal(expected, subtractionResult);
}
public void CollectionSizedByExpression2()
{
var input = @"
Object1
{
size : int32;
size2 : int16;
collection : bool[size + size2 - 10 * 5];
}";
var expected = new ProgramBuilder();
var object1 = expected.AddObject();
object1.Name = "Object1";
object1.Fields.Add(("size", new Signed(null, 32), null, null));
object1.Fields.Add(("size2", new Signed(null, 16), null, null));
var field3_size = new Subtraction(
null,
new Addition(
null,
new FieldIdentifier(null, "size"),
new FieldIdentifier(null, "size2")
),
new Multiplication(
null,
new BiPaGe.AST.Literals.Integer(null, "10"),
new BiPaGe.AST.Literals.Integer(null, "5")
));
object1.Fields.Add(("collection", new BiPaGe.AST.FieldTypes.Boolean(null), field3_size, null));
expected.Validate(SimpleBuilder.Build(input));
}
public IType Visit(Subtraction node)
{
var leftHandSideValue = Visit((dynamic)node.Lhs);
var rightHandSideValue = Visit((dynamic)node.Rhs);
return(leftHandSideValue.Subtract(rightHandSideValue));
}
public int Subtract(int a, int b)
{
result = Subtraction.Subtract(a, b);
return(result);
}
public TestBase()
{
GivenAdditionOperation = new Addition();
GivenSubtractionOperation = new Subtraction();
GivenDivisionOperation = new Division();
GivenMultyplicationOperation = new Multiplication();
GivenPowerOperation = new Power();
}
void IExpressionVisitor.Visit(Subtraction subtraction)
{
var left = GetResultFor(subtraction.Left);
var right = GetResultFor(subtraction.Right);
Result = UseSubtraction(left, right);
EvaluatingExpressionVisitor.Steps.Add($"{left}-{right}\n {Result}");
}
public void Subtraction_Works()
{
var subtraction = new Subtraction();
var result = subtraction.Execute(2, 1);
Assert.AreEqual(1,result);
}
public void TestNoSubtraction()
{
Subtraction rule4 = new Subtraction();
Assert.False(rule4.CheckViolation("CIL"));
Assert.False(rule4.CheckViolation("MXD"));
Assert.True(rule4.CheckViolation("XIX"));
}
public void SubtractSymbolForSubtractionShouldBeValid()
{
// ReSharper disable once HeapView.ObjectAllocation.Evident
var subtraction = new Subtraction();
const char subtractSymbol = '-';
Assert.IsTrue(subtraction.IsValid(subtractSymbol));
}
public void BaseFunctionTest()
{
Subtraction sub = new Subtraction();
double expected = 2;
double actual = sub.Execute(4, 2);
Assert.AreEqual(expected, actual);
}
public static double ZScore(dynamic score, dynamic values)
{
double mean = StatMean.Mean(values);
double standDev = StatStandardDev.StandDev(values);
double zScore = Division.Quotient(Subtraction.Difference(score, mean), standDev);
return(zScore);
}
public void NonSubtractSymbolForSubtractionShouldBeInvalid()
{
// ReSharper disable once HeapView.ObjectAllocation.Evident
var subtraction = new Subtraction();
const char nonSubtractSymbol = '/';
Assert.IsFalse(subtraction.IsValid(nonSubtractSymbol));
}
public void TestSubtractionRule()
{
Subtraction rule = new Subtraction();
Assert.False(rule.Execute("CIL"));
Assert.False(rule.Execute("MXD"));
Assert.True(rule.Execute("XIX"));
}
public void calculate_should_return_number_that_is_the_subtraction()
{
// Given
SUT = new Subtraction(new RealNumber(2.0), new RealNumber(6.0));
// When
var result = SUT.Calculate() as RealNumber;
// Then
Assert.AreEqual(-4.0, result.Value);
}
public void calculate_should_return_real_number_with_subtrted_value()
{
// Given
SUT = new Subtraction(new RealNumber(2.0), new RealNumber(6.0));
// When
var result = SUT.Calculate();
// Then
Assert.IsInstanceOf<RealNumber>(result);
}
public void Visit(Subtraction sub)
{
Visit(sub, OpCodes.Sub_Ovf); // With overflow check
}
//Using this composition of function, that is, first expr and then term ensures that division and multiplication has higher priority over plus and minus.
private static Sexpr expr(Tokenizer st, Hashtable store)
{
Sexpr res = term(st, store);
st.NextToken();
while (st.isPlus() || st.isMinus())
{
if (st.isPlus())
{
res = new addition(res, term(st,store));
st.NextToken();
}
else if (st.isMinus())
{
res = new Subtraction(res, term(st, store));
st.NextToken();
}
}
st.PushBack();
return res;
}
public void regenerate_should_regenerate_right_number()
{
// Given
var nbr = new Mock<Number>();
SUT = new Subtraction(new RealNumber(1), nbr.Object);
// When
SUT.Regenerate();
// Then
nbr.Verify(x => x.Regenerate());
}
public void Visit(Subtraction sub)
{
// Nothing to do here...
}
public void Setup()
{
SUT = new Subtraction(new RealNumber(1), new RealNumber(2));
}
public void Visit(Subtraction sub)
{
sub.Left.Accept(this);
_sb.Append("-");
sub.Right.Accept(this);
}
public void Teardown()
{
SUT = null;
}
public void subtractionTest()
{
Subtraction MyDifference = new Subtraction();
int answer = MyDifference.SubtractNum(5, 3);
Assert.AreEqual(answer, 2);
}
private Expression ParseAdditiveExpression(TokenSet followers) {
TokenSet followerOrAdditive = followers|Token.Addition|Token.Subtraction;
Expression result = this.ParseMultiplicativeExpression(followerOrAdditive);
while (this.currentToken == Token.Addition || this.currentToken == Token.Subtraction) {
SourceLocationBuilder slb = new SourceLocationBuilder(result.SourceLocation);
Token operatorToken = this.currentToken;
this.GetNextToken();
Expression operand2 = this.ParseMultiplicativeExpression(followerOrAdditive);
slb.UpdateToSpan(operand2.SourceLocation);
switch (operatorToken) {
case Token.Addition: result = new Addition(result, operand2, slb); break;
case Token.Subtraction: result = new Subtraction(result, operand2, slb); break;
}
}
//^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile;
return result;
}
public void Visit(Subtraction sub)
{
ResultIsIntAndBothOperandsMustBeInt(sub);
}
public void constructor_should_set_right_number()
{
// Given
var nbr = new Variable("a", new RealNumber(1));
// When
SUT = new Subtraction(new Variable("b", new RealNumber(1)), nbr);
// Then
Assert.AreSame(nbr, SUT.RightSide);
}
