private static LimitedDouble Counting(LimitedDouble firstNumber, LimitedDouble secondNumber, char operation)
{
LimitedDouble result = 0;
if (operation == '+')
{
result = firstNumber + secondNumber;
}
else if (operation == '-')
{
result = firstNumber - secondNumber;
}
else if (operation == '*')
{
result = firstNumber * secondNumber;
}
else if (operation == '/')
{
result = firstNumber / secondNumber;
}
else if (operation == '^')
{
result = firstNumber ^ secondNumber;
}
else
{
throw new ArgumentException("Invalid operator!");
}
return(result);
}
public static LimitedDouble Counting(string rpnExpression)
{
string[] expression = rpnExpression.Split(' ');
var numbersStack = new Stack <LimitedDouble>();
LimitedDouble result = 0;
LimitedDouble firstNumber;
LimitedDouble secondNumber;
for (int i = 0; i < expression.Length; i++)
{
if (ExpressionParser.IsOperator(expression[i][0]))
{
secondNumber = numbersStack.Pop();
firstNumber = numbersStack.Pop();
result = Counting(firstNumber, secondNumber, expression[i][0]);
numbersStack.Push(result);
}
else
{
LimitedDouble tempNumber = Double.Parse(expression[i]);
numbersStack.Push(tempNumber);
}
}
return(numbersStack.Pop());
}
public void CountingRPN_WithInalidRPNExpression_ThrowExpectedException()
{
// arrange
string rpnExpression = "6.0 7 + 8.1 * 4 - 3.2 / 1 3 ^ + + +";
LimitedDouble expected = 5.78125;
// act
LimitedDouble result = Calculator.Counting(rpnExpression);
// assert of throwing InvalidOperationException
}
public void CountingRPN_WithValidRPNExpression_SameAsExpected()
{
// arrange
string rpnExpression = "6.0 7 + 8.1 * 4 - 3.2 / 1 3 ^ +";
LimitedDouble expected = 5.78125;
// act
LimitedDouble result = Calculator.Counting(rpnExpression);
// assert
Assert.AreEqual(expected, result, 0.00001, string.Format("{0} - {1}", expected, result));
}
public void CountingRPN_WithValidRPNExpression_5()
{
// arrange
string rpnExpression = "4 1 +";
LimitedDouble expected = 5;
// act
LimitedDouble result = Calculator.Counting(rpnExpression);
// assert
Assert.AreEqual(expected, result);
}
public void OperatorPow_CorrectValues_8()
{
//arrange
LimitedDouble limitedDouble1 = 2;
LimitedDouble limitedDouble2 = 3;
LimitedDouble expected = 8;
LimitedDouble result;
//acr
result = limitedDouble1 ^ limitedDouble2;
//assert
Assert.AreEqual(expected, result, 0.001, "Type 'LimitedDouble' devided incorrectly");
}
public void OperatorMultiply_IncorrectValues_5()
{
//arrange
LimitedDouble limitedDouble1 = 2;
LimitedDouble limitedDouble2 = 4;
LimitedDouble expected = 5;
LimitedDouble result;
//acr
result = limitedDouble1 * limitedDouble2;
//assert
Assert.AreNotEqual(expected, result, 0.001, "Type 'LimitedDouble' multiply incorrectly");
}
public void OperatorMultiply_CorrectValues_5()
{
//arrange
LimitedDouble limitedDouble1 = 2;
LimitedDouble limitedDouble2 = 2.5;
LimitedDouble expected = 5;
LimitedDouble result;
//acr
result = limitedDouble1 * limitedDouble2;
//assert
Assert.AreEqual(expected, result, string.Format("Type 'LimitedDouble' multiplied incorrectly", expected, result));
}
public void OperatorPlus_IncorrectValues_9()
{
//arrange
LimitedDouble limitedDouble1 = 2.99;
LimitedDouble limitedDouble2 = 2.01;
LimitedDouble expected = 9;
LimitedDouble result;
//acr
result = limitedDouble1 + limitedDouble2;
//assert
Assert.AreNotEqual(expected, result, 0.001, "Type 'LimitedDouble' summed incorrectly");
}
public void OverflowMinValue_IncorrectValues_10()
{
//arrange
LimitedDouble limitedDouble1 = -6.99;
LimitedDouble limitedDouble2 = -0.02;
LimitedDouble expected = 10;
LimitedDouble result;
//acr
result = limitedDouble1 + limitedDouble2;
//assert
Assert.AreNotEqual(expected, result, 0.001, "Type 'LimitedDouble' overflow Min_Value incorrectly");
}
public void OverflowMinValue_CorrectValues_36()
{
//arrange
LimitedDouble limitedDouble1 = -6.99;
LimitedDouble limitedDouble2 = -0.03;
LimitedDouble expected = 35.99;
LimitedDouble result;
//acr
result = limitedDouble1 + limitedDouble2;
//assert
Assert.AreEqual(expected, result, 0.02, "Type 'LimitedDouble' overflow Min_Value incorrectly");
}
public void OverflowMaxValue_IncorrectValues_3()
{
//arrange
LimitedDouble limitedDouble1 = 36.0;
LimitedDouble limitedDouble2 = 8;
LimitedDouble expected = 3;
LimitedDouble result;
//acr
result = limitedDouble1 + limitedDouble2;
//assert
Assert.AreNotEqual(result, expected, "Type 'LimitedDouble' overflow Max_Value incorrectly");
}
public void OverflowMaxValue_CorrectValues_0()
{
//arrange
LimitedDouble limitedDouble1 = 36.0;
LimitedDouble limitedDouble2 = 7;
LimitedDouble expected = 0;
LimitedDouble result;
//acr
result = limitedDouble1 + limitedDouble2;
//assert
Assert.AreEqual(expected, result, 0.001, "Type 'LimitedDouble' overflow Max_Value incorrectly");
}
public void OperatorDevide_IncorrectValues_7()
{
//arrange
LimitedDouble limitedDouble1 = -1;
LimitedDouble limitedDouble2 = 0.5;
LimitedDouble expected = 7;
LimitedDouble result;
//acr
result = limitedDouble1 / limitedDouble2;
//assert
Assert.AreNotEqual(expected, result, 0.001, "Type 'LimitedDouble' devided incorrectly");
}
static void Main(string[] args)
{
Console.WriteLine("1:");
string incorrectExpression = "(((QWRaarx(6.AS0+7)*8.1-4)XXX/3ASD.2+1^3asdasd";
//Console.WriteLine(ExpressionParser.GetCorrectExpression(incorrectExpression));
string fixedExpressionRPN = ExpressionParser.GetReversePolishNotation(incorrectExpression);
LimitedDouble res = Calculator.Counting(fixedExpressionRPN);
Console.WriteLine(incorrectExpression);
Console.WriteLine(fixedExpressionRPN);
Console.WriteLine(res);
Console.WriteLine("2:");
string expression = "((6.0+7)*8.1-4)/3.2+1^3";
string rpn = ExpressionParser.GetReversePolishNotation(expression);
LimitedDouble result = Calculator.Counting(rpn);
Console.WriteLine(expression);
Console.WriteLine(rpn);
Console.WriteLine(result);
}
private Color GetColorFromValue(LimitedDouble gene, bool biggerRed = true)
{
return(GetColorFromValue(gene.NormalizedValue, biggerRed));
}
