Refactoring + new features

Author: miroiu

README.md

@@ -1,19 +1,40 @@
 # String Math
-Calculates the value of a math expression from a string.
+Calculates the value of a math expression from a string returning a decimal.
 Supports variables and user defined operators.
 
 ```csharp
-// Simple expression
-decimal result = Calculator.Evaluate("1 * (2 - 3) ^ 2"); // 1
+// Evaluating a simple expression
+Calculator myCalculator = new Calculator();
+decimal result = myCalculator.Evaluate("1 * (2 - 3) ^ 2"); // 1
 
-// Variables
-decimal result = Calculator.Evaluate("{a} + 2 * {b}", new Replacement("a", 2), new Replacement("b", 1)); // 4
+// Using custom operators
+myCalculator.AddOperator("abs", a => a > 0 ? a : -a);
+decimal result = myCalculator.Evaluate("abs -5"); // 5
+
+// Using custom operator precedence (you can specify an int for precedence)
+myCalculator.AddOperator("max", (a, b) => a > b ? a : b, Precedence.Power);
+decimal result = myCalculator.Evaluate("2 * 3 max 4"); // 8
+```
 
-// Adding custom operators
-Calculator.AddOperator("abs", a => a > 0 ? a : -a);
-Calculator.AddOperator("max", (a, b) => a > b ? a : b);
+```csharp 
+// Using a variables collection
+Replacements variables = new Replacements
+{
+	["a"] = 5,
+	["PI"] = 3.1415926535897931
+};
+variables["a"] = 0;
 
-// Using custom operators
-decimal result = Calculator.Evaluate("abs -5"); // 5
-decimal result = Calculator.Evaluate("3 max 4"); // 4
+Calculator myCalculator = new Calculator(variables);
+
+// Replacing existing variables
+myCalculator.Replace("a", 2);
+myCalculator.Replace("b", 1);
+decimal result = calculator.Evaluate("{a} + 2 * {b} + {PI}"); // 7.1415926535897931
+```
+
+```csharp
+// Using the static class SMath
+decimal result = SMath.Evaluate("1 + 1"); // 2
+decimal result = SMath.Evaluate("1 + {myVar}", new Replacements { ["myVar"] = 1 }); // 2
 ```

StringMath.Tests/CalculatorTests.cs

@@ -0,0 +1,65 @@
+using NUnit.Framework;
+using System;
+
+namespace StringMath.Tests
+{
+    [TestFixture]
+    internal class CalculatorTests
+    {
+        private Calculator _calculator;
+
+        [Test]
+        [TestCase("1 +\t 2", 3)]
+        [TestCase("-1.5 + 3", 1.5)]
+        [TestCase("4!", 24)]
+        [TestCase("(3! + 1) * 2", 14)]
+        [TestCase("2 ^ 3", 8)]
+        [TestCase("1 + 16 log 2", 5)]
+        [TestCase("1 + sqrt 4", 3)]
+        [TestCase("((1 + 1) + ((1 + 1) + (((1) + 1)) + 1))", 7)]
+        public void TestEvaluationResult(string input, decimal expected)
+        {
+            Assert.AreEqual(expected, _calculator.Evaluate(input));
+        }
+
+        [Test]
+        [TestCase("{a}+2", 1, 3)]
+        [TestCase("2*{a}+2", 3, 8)]
+        [TestCase("2*{a}+2*{a}", 3, 12)]
+        [TestCase("{b}+3*{a}", 3, 11)]
+        [TestCase("({a})", 3, 3)]
+        [TestCase("{PI}", Math.PI, Math.PI)]
+        [TestCase("{E}", Math.E, Math.E)]
+        public void ReplacementEvaluationResult(string input, decimal replacement, decimal expected)
+        {
+            _calculator.Replace("a", replacement);
+            _calculator.Replace("b", 2);
+
+            Assert.AreEqual(expected, _calculator.Evaluate(input));
+        }
+
+        [OneTimeSetUp]
+        public void Setup()
+        {
+            _calculator = new Calculator();
+
+            _calculator.AddOperator("abs", a => a > 0 ? a : -a);
+            _calculator.AddOperator("x", (a, b) => a * b);
+            _calculator.AddOperator("<<", (a, b) => (decimal)Math.ScaleB((double)a, (int)b));
+            _calculator.AddOperator("<>", (a, b) => decimal.Parse($"{a}{b}"), Precedence.Prefix);
+            _calculator.AddOperator("e", (a, b) => decimal.Parse($"{a}e{b}"), Precedence.Power);
+        }
+
+        [Test]
+        [TestCase("abs -5", 5)]
+        [TestCase("abs(-1)", 1)]
+        [TestCase("3 max 2", 3)]
+        [TestCase("2 x\r\n 5", 10)]
+        [TestCase("3 << 2", 12)]
+        [TestCase("-3 <> 2", -32)]
+        public void CustomOperators(string input, decimal expected)
+        {
+            Assert.AreEqual(expected, _calculator.Evaluate(input));
+        }
+    }
+}

StringMath.Tests/EvaluatorTest.cs

@@ -13,6 +13,7 @@ public void Setup()
         {
             _context = new MathContext();
             _context.AddBinaryOperator("pow", default);
+            _context.AddBinaryOperator("<<<", default);
         }
 
         [Test]
@@ -22,6 +23,7 @@ public void Setup()
         [TestCase("2 pow 3", new[] { TokenType.Number, TokenType.Operator, TokenType.Number })]
         [TestCase("{a} + 2", new[] { TokenType.Identifier, TokenType.Operator, TokenType.Number })]
         [TestCase("(-1) + 2", new[] { TokenType.OpenParen, TokenType.Operator, TokenType.Number, TokenType.CloseParen, TokenType.Operator, TokenType.Number })]
+        [TestCase("<<<", new[] { TokenType.Operator })]
         public void TestCorrectSyntax(string input, TokenType[] expected)
         {
             Assert.AreEqual(expected, input.GetTokens(_context).Select(t => t.Type).ToArray());

StringMath.Tests/LexerTests.cs

@@ -0,0 +1,61 @@
+using NUnit.Framework;
+using System;
+
+namespace StringMath.Tests
+{
+    [TestFixture]
+    internal class SMathTests
+    {
+        [Test]
+        [TestCase("1 +\t 2", 3)]
+        [TestCase("-1.5 + 3", 1.5)]
+        [TestCase("4!", 24)]
+        [TestCase("(3! + 1) * 2", 14)]
+        [TestCase("2 ^ 3", 8)]
+        [TestCase("1 + 16 log 2", 5)]
+        [TestCase("1 + sqrt 4", 3)]
+        [TestCase("((1 + 1) + ((1 + 1) + (((1) + 1)) + 1))", 7)]
+        public void TestEvaluationResult(string input, decimal expected)
+        {
+            Assert.AreEqual(expected, SMath.Evaluate(input));
+        }
+
+        [Test]
+        [TestCase("{a}+2", 1, 3)]
+        [TestCase("2*{a}+2", 3, 8)]
+        [TestCase("2*{a}+2*{a}", 3, 12)]
+        [TestCase("{b}+3*{a}", 3, 11)]
+        [TestCase("({a})", 3, 3)]
+        public void ReplacementEvaluationResult(string input, decimal replacement, decimal expected)
+        {
+            Assert.AreEqual(expected, SMath.Evaluate(input, new Replacements
+            {
+                ["a"] = replacement,
+                ["b"] = 2,
+            }));
+        }
+
+        [OneTimeSetUp]
+        public void Setup()
+        {
+            SMath.AddOperator("abs", a => a > 0 ? a : -a);
+            SMath.AddOperator("max", (a, b) => a > b ? a : b);
+            SMath.AddOperator("x", (a, b) => a * b);
+            SMath.AddOperator("<<", (a, b) => (decimal)Math.ScaleB((double)a, (int)b));
+            SMath.AddOperator("<>", (a, b) => decimal.Parse($"{a}{b}"), Precedence.Prefix);
+            SMath.AddOperator("e", (a, b) => decimal.Parse($"{a}e{b}"), Precedence.Power);
+        }
+
+        [Test]
+        [TestCase("abs -5", 5)]
+        [TestCase("abs(-1)", 1)]
+        [TestCase("3 max 2", 3)]
+        [TestCase("2 x\r\n 5", 10)]
+        [TestCase("3 << 2", 12)]
+        [TestCase("-3 <> 2", -32)]
+        public void CustomOperators(string input, decimal expected)
+        {
+            Assert.AreEqual(expected, SMath.Evaluate(input));
+        }
+    }
+}

StringMath.Tests/SMathTests.cs

@@ -1,85 +1,63 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("StringMath.Tests")]
 namespace StringMath
 {
-    public static class Calculator
+    public class Calculator
     {
-        internal static MathContext MathContext { get; } = new MathContext();
+        private readonly MathContext _mathContext = new MathContext();
+        private readonly Replacements _replacements;
 
-        public static void AddOperator(string operatorName, Func<decimal, decimal, decimal> operation)
-            => MathContext.AddBinaryOperator(operatorName, operation);
+        private static Reducer Reducer { get; } = new Reducer();
 
-        public static void AddOperator(string operatorName, Func<decimal, decimal> operation)
-            => MathContext.AddUnaryOperator(operatorName, operation);
-
-        private static readonly Dictionary<Type, Func<Expression, Replacement[], Expression>> _expressionEvaluators = new Dictionary<Type, Func<Expression, Replacement[], Expression>>
-        {
-            [typeof(BinaryExpression)] = EvaluateBinaryExpression,
-            [typeof(UnaryExpression)] = EvaluateUnaryExpression,
-            [typeof(ConstantExpression)] = EvaluateConstantExpression,
-            [typeof(GroupingExpression)] = EvaluateGroupingExpression,
-            [typeof(ReplacementExpression)] = EvaluateReplacementExpression
-        };
-
-        public static decimal Evaluate(string expression)
-            => Evaluate(expression, default);
-
-        public static decimal Evaluate(string expression, params Replacement[] replacements)
-        {
-            SourceText text = new SourceText(expression);
-            Lexer lex = new Lexer(text, MathContext);
-            Parser parse = new Parser(lex, MathContext);
-
-            Expression expr = Reduce(parse.Parse(), replacements);
-            return ((NumberExpression)expr).Value;
-        }
-
-        internal static Expression Reduce(Expression expression, Replacement[] replacements)
-        {
-            if (expression is NumberExpression)
+        /// <summary>
+        /// Create an instance of a Calculator which has it's own operators and variable definitions.
+        /// </summary>
+        /// <param name="replacements"></param>
+        public Calculator(Replacements replacements = default)
+            => _replacements = replacements ?? new Replacements
             {
-                return expression;
-            }
-
-            var expr = _expressionEvaluators[expression.Type](expression, replacements);
-            return Reduce(expr, replacements);
-        }
-
-        private static Expression EvaluateConstantExpression(Expression arg, Replacement[] replacements)
-            => new NumberExpression(decimal.Parse(((ConstantExpression)arg).Value));
-
-        private static Expression EvaluateGroupingExpression(Expression arg, Replacement[] replacements)
-            => ((GroupingExpression)arg).Inner;
-
-        private static Expression EvaluateUnaryExpression(Expression arg, Replacement[] replacements)
+                ["PI"] = (decimal)Math.PI,
+                ["E"] = (decimal)Math.E
+            };
+
+        /// <summary>
+        /// Add a new binary operator or overwrite an existing operator's logic. 
+        /// </summary>
+        /// <param name="operatorName">The operator's string representation.</param>
+        /// <param name="operation">The operation to execute for this operator.</param>
+        /// <param name="precedence">Logarithmic precedence by default.</param>
+        public void AddOperator(string operatorName, Func<decimal, decimal, decimal> operation, Precedence precedence = default)
+            => _mathContext.AddBinaryOperator(operatorName, operation, precedence);
+
+        /// <summary>
+        /// Add a new unary operator or overwrite an existing operator's logic. 
+        /// <see cref="Precedence"/> is always <see cref="Precedence.Prefix" />
+        /// </summary>
+        /// <param name="operatorName">The operator's string representation.</param>
+        /// <param name="operation">The operation to execute for this operator.</param>
+        public void AddOperator(string operatorName, Func<decimal, decimal> operation)
+            => _mathContext.AddUnaryOperator(operatorName, operation);
+
+        /// <summary>
+        /// Evaluates a mathematical expression which can contain variables and returns a decimal value.
+        /// </summary>
+        /// <param name="expression">The math expression to evaluate.</param>
+        /// <returns>The result as a decimal value.</returns>
+        public decimal Evaluate(string expression)
         {
-            var unary = (UnaryExpression)arg;
-            var value = (NumberExpression)Reduce(unary.Operand, replacements);
-
-            var result = MathContext.EvaluateUnary(unary.OperatorName, value.Value);
-            return new NumberExpression(result);
-        }
-
-        private static Expression EvaluateBinaryExpression(Expression expr, Replacement[] replacements)
-        {
-            var binary = (BinaryExpression)expr;
-            var left = (NumberExpression)Reduce(binary.Left, replacements);
-            var right = (NumberExpression)Reduce(binary.Right, replacements);
+            SourceText text = new SourceText(expression);
+            Lexer lex = new Lexer(text, _mathContext);
+            Parser parse = new Parser(lex, _mathContext);
 
-            var result = MathContext.EvaluateBinary(binary.OperatorName, left.Value, right.Value);
-            return new NumberExpression(result);
+            return Reducer.Reduce<ResultExpression>(parse.Parse(), _mathContext, _replacements).Value;
         }
 
-        private static Expression EvaluateReplacementExpression(Expression expr, Replacement[] replacements)
-        {
-            var replacement = (ReplacementExpression)expr;
-            var value = replacements.FirstOrDefault(r => r.Identifier == replacement.Name);
-
-            return new NumberExpression(value.Value);
-        }
+        /// <summary>
+        /// Replaces the value of a variable.
+        /// </summary>
+        /// <param name="name">The variable's name.</param>
+        /// <param name="value">The new value.</param>
+        public void Replace(string name, decimal value)
+            => _replacements[name] = value;
     }
 }