static void Main(string[] args)
{
var mathOperationsContainer = new MathOperationsContainer();
var parser = new Parser();
var notationConverter = new NotationConverter();
var mathProcessor = new MathProcessor();
var calculator = new MathCalculator(parser, notationConverter, mathProcessor, mathOperationsContainer);
Console.WriteLine("Calculator");
Console.WriteLine("To complete the work, type exit.");
while (true)
{
Console.Write("Enter a math expression: ");
var expression = Console.ReadLine();
if (expression == "exit")
{
Console.WriteLine("Work completed.");
break;
}
var result = calculator.Calculate(expression);
Console.WriteLine("Result: {0}", result);
}
}
public void Run()
{
string expression;
ShowHelp();
while ((expression = AskForInput()) != "")
{
try
{
NotationConverter converter = new NotationConverter(expression);
converter.Convert();
calculator.Calculate(converter.PolishNotation);
ShowResult();
}
catch (InvalidExpressionException ex)
{
Console.WriteLine(ex.Message);
}
catch (DivideByZeroException ex)
{
Console.WriteLine(ex.Message);
}
}
}
public void ConvertToPostfix_StringExpression_ArrayOfStringsPostfixExpression(string input, string expected)
{
// Act
string result = string.Join("", NotationConverter.ConvertToPostfix(input, _operators));
// Assert
Assert.AreEqual(result, expected);
}
private float GetExpressionResult(string infix)
{
NotationConverter converter = new NotationConverter(infix);
converter.Convert();
calc.Calculate(converter.PolishNotation);
return(calc.Result);
}
public void CorrectWorkWithDifferentPriorities()
{
NotationConverter converter = new NotationConverter("-4+5*6+1/2*3+7");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "4", "_", "5", "6", "*", "+", "1", "2", "/", "3", "*", "+", "7", "+" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectUnaryMinus()
{
NotationConverter converter = new NotationConverter("-4");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "4", "_" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectDivisionOf2Numbers()
{
NotationConverter converter = new NotationConverter("4/31");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "4", "31", "/" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectDifferenceOf2Numbers()
{
NotationConverter converter = new NotationConverter("41-5");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "41", "5", "-" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectSumOf2Digits()
{
NotationConverter converter = new NotationConverter("4+5");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "4", "5", "+" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectCommaProcessing()
{
NotationConverter converter = new NotationConverter("pow((3 ) ,(3))");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "3", "3", "pow" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectWorkWithMultiplyFunctionsAndOperatorsInPow()
{
NotationConverter converter = new NotationConverter("pow(cos(1) + pow(2 + 3, 2), sin(5))");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "1", "cos", "2", "3", "+", "2", "pow", "+", "5", "sin", "pow" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectWorkIfMultiplyFunctions()
{
NotationConverter converter = new NotationConverter("sin(pow(5, -cos(3)))");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "5", "3", "cos", "_", "pow", "sin" });
CollectionAssert.AreEqual(result, expected);
}
public void CorrectSumOfManyNumbers()
{
NotationConverter converter = new NotationConverter("4+5+6+1+2+3+7");
converter.Convert();
var result = converter.PolishNotation;
var expected = PushToStack(new string[] { "4", "5", "+", "6", "+", "1", "+", "2", "+", "3", "+", "7", "+" });
CollectionAssert.AreEqual(result, expected);
}
public string Calculate()
{
IExpressionValidator expressionValidator = Factory.CreateExpressionValidator();
expressionValidator.Expression = string.Join("", InfixNotationValue);
if (expressionValidator.Validate())
{
PostfixNotationValue = NotationConverter.ConvertToPostfix(string.Join("", InfixNotationValue), _operators);
foreach (var item in PostfixNotationValue)
{
if (_operators.Contains(item))
{
B = double.Parse(Stack.Pop());
A = double.Parse(Stack.Pop());
if (item == "/")
{
State = ExpressionSubjectState.Division;
this.Notify();
}
else if (item == "*")
{
State = ExpressionSubjectState.Multiplication;
this.Notify();
}
else if (item == "+")
{
State = ExpressionSubjectState.Addition;
this.Notify();
}
else if (item == "-")
{
State = ExpressionSubjectState.Subtraction;
this.Notify();
}
}
else
{
Stack.Push(item);
}
}
return(Result = Stack.Pop());
}
else
{
return(Result);
}
}
public void NotationConverter_converts_one_digit_to_RPN()
{
var notationConverter = new NotationConverter();
var inputValue = new List <ExpressionUnit>
{
new NumberExpressionUnit("2.00")
};
var result = notationConverter.ConvertToReversePolishNotation(inputValue, _mathOperationsContainer);
var expectedItem = new NumberExpressionUnit("2.00");
Assert.Collection(result, item => AssertExpressionUnit.Equal(expectedItem, item));
}
public void NotationConverter_converts_digit_with_unary_minus_to_RPN()
{
var notationConverter = new NotationConverter();
var inputValue = new List <ExpressionUnit>()
{
new OperationExpressionUnit("-", "~"),
new NumberExpressionUnit("8.00")
};
var result = notationConverter.ConvertToReversePolishNotation(inputValue, _mathOperationsContainer);
Assert.Collection(result,
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("8.00"), item),
item => AssertExpressionUnit.Equal(new OperationExpressionUnit("-", "~"), item));
}
public void NotationConverter_throws_custom_exception_for_unsupported_operation()
{
var notationConverter = new NotationConverter();
var inputValue = new List <ExpressionUnit>()
{
new NumberExpressionUnit("3.00"),
new OperationExpressionUnit("&"),
new NumberExpressionUnit("2.00")
};
Action action = () => notationConverter.ConvertToReversePolishNotation(inputValue, _mathOperationsContainer);
var exception = Assert.Throws <ArgumentException>(action);
Assert.Equal("Invalid mathematical expression or unsupported operation.", exception.Message);
}
public void NotationConverter_converts_higher_priority_unary_operation_and_lower_priority_binary_operation_to_RPN()
{
var notationConverter = new NotationConverter();
var inputValue = new List <ExpressionUnit>()
{
new OperationExpressionUnit("-", "~"),
new NumberExpressionUnit("8.00"),
new OperationExpressionUnit("+"),
new NumberExpressionUnit("2.00"),
};
var result = notationConverter.ConvertToReversePolishNotation(inputValue, _mathOperationsContainer);
Assert.Collection(result,
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("8.00"), item),
item => AssertExpressionUnit.Equal(new OperationExpressionUnit("-", "~"), item),
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("2.00"), item),
item => AssertExpressionUnit.Equal(new OperationExpressionUnit("+"), item));
}
public void NotationConverter_converts_two_digit_and_operation_with_brackets_to_RPN()
{
var notationConverter = new NotationConverter();
var inputValue = new List <ExpressionUnit>()
{
new LeftBracketExpressionUnit(),
new NumberExpressionUnit("3.00"),
new OperationExpressionUnit("+"),
new NumberExpressionUnit("2.00"),
new RightBracketExpressionUnit()
};
var result = notationConverter.ConvertToReversePolishNotation(inputValue, _mathOperationsContainer);
Assert.Collection(result,
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("3.00"), item),
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("2.00"), item),
item => AssertExpressionUnit.Equal(new OperationExpressionUnit("+"), item));
}
public void NotationConverter_converts_expression_with_first_priority_operation_to_RPN()
{
var notationConverter = new NotationConverter();
var inputValue = new List <ExpressionUnit>()
{
new NumberExpressionUnit("4.00"),
new OperationExpressionUnit("+"),
new NumberExpressionUnit("2.00"),
new OperationExpressionUnit("*"),
new NumberExpressionUnit("3.00")
};
var result = notationConverter.ConvertToReversePolishNotation(inputValue, _mathOperationsContainer);
Assert.Collection(result,
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("4.00"), item),
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("2.00"), item),
item => AssertExpressionUnit.Equal(new NumberExpressionUnit("3.00"), item),
item => AssertExpressionUnit.Equal(new OperationExpressionUnit("*"), item),
item => AssertExpressionUnit.Equal(new OperationExpressionUnit("+"), item));
}
public void NotationConverter_should_be()
{
var notationConverter = new NotationConverter();
}
public void ThrowsExeptionIfIncorrectBracket2()
{
NotationConverter converter = new NotationConverter("()(");
converter.Convert();
}
