Bug fix for negative numbers

Fixing bug in handling negative numbers where a minus sign was mistook
for a negative sign.

Author: gap777

Source/LoreSoft.MathExpressions.Tests/MathEvaluatorTest.cs

@@ -28,26 +28,21 @@ public void EvaluateNegative()
         {
             double expected = 2d + -1d;
             double result = eval.Evaluate("2 + -1");
-
             Assert.AreEqual(expected, result);
 
             expected = -2d + 1d;
             result = eval.Evaluate("-2 + 1");
-
             Assert.AreEqual(expected, result);
 
-
             expected = (2d + -1d) * (-1d + 2d);
             result = eval.Evaluate("(2 + -1) * (-1 + 2)");
-
             Assert.AreEqual(expected, result);
-        }
 
-        [Test]
-        public void EvaluateNegative2()
-        {
-            double result = eval.Evaluate("(-4-3) *5");
-            Assert.AreEqual(-35d, result);
+            // this failed due to a bug in parsing whereby the minus sign was erroneously mistaken for a negative sign.  
+            // which left the -4 on the calculationStack at the end of evaluation. 
+            expected = (-4 - 3) * 5;
+            result = eval.Evaluate("(-4-3) *5");
+            Assert.AreEqual(expected, result);
         }
 
         [Test]

Source/LoreSoft.MathExpressions/MathEvaluator.cs

@@ -43,6 +43,10 @@ public class MathEvaluator : IDisposable
         private List<string> _innerFunctions;
         private uint _nestedFunctionDepth;
         private StringReader _expressionReader;
+        private VariableDictionary _variables;
+        private ReadOnlyCollection<string> _functions;        
+        private char _currentChar;
+
 
         /// <summary>
         /// Initializes a new instance of the <see cref="MathEvaluator"/> class.
@@ -62,7 +66,6 @@ public MathEvaluator()
             _nestedFunctionDepth = 0;
         }
 
-        private VariableDictionary _variables;
 
         /// <summary>
         /// Gets the variables collections.
@@ -73,8 +76,6 @@ public VariableDictionary Variables
             get { return _variables; }
         }
 
-        private ReadOnlyCollection<string> _functions;
-
         /// <summary>Gets the functions available to <see cref="MathEvaluator"/>.</summary>
         /// <value>The functions for <see cref="MathEvaluator"/>.</value>
         /// <seealso cref="RegisterFunction"/>
@@ -149,54 +150,54 @@ internal bool IsFunction(string name)
 
         private void ParseExpressionToQueue()
         {
-            char l = '\0'; 
-            char c = '\0';
+            char lastChar = '\0'; 
+            _currentChar = '\0';
 
             do
             {
                 // last non white space char
-                if (!char.IsWhiteSpace(c))
-                    l = c;
+                if (!char.IsWhiteSpace(_currentChar))
+                    lastChar = _currentChar;
 
-                c = (char)_expressionReader.Read();
+                _currentChar = (char)_expressionReader.Read();
 
-                if (char.IsWhiteSpace(c))
+                if (char.IsWhiteSpace(_currentChar))
                     continue;
 
-                if (TryNumber(c, l))
+                if (TryNumber(lastChar))
                     continue;
 
-                if (TryString(c))
+                if (TryString())
                     continue;
 
-                if (TryStartGroup(c))
+                if (TryStartGroup())
                     continue;
 
-                if (TryComma(c))
+                if (TryComma())
                     continue;
 
-                if (TryOperator(c))
+                if (TryOperator())
                     continue;
 
-                if (TryEndGroup(c))
+                if (TryEndGroup())
                     continue;
 
-                if (TryConvert(c))
+                if (TryConvert())
                     continue;
 
-                throw new ParseException(Resources.InvalidCharacterEncountered + c);
+                throw new ParseException(Resources.InvalidCharacterEncountered + _currentChar);
             } while (_expressionReader.Peek() != -1);
 
             ProcessSymbolStack();
         }
 
-        private bool TryConvert(char c)
+        private bool TryConvert()
         {
-            if (c != '[')
+            if (_currentChar != '[')
                 return false;
 
             _buffer.Length = 0;
-            _buffer.Append(c);
+            _buffer.Append(_currentChar);
 
             char p = (char)_expressionReader.Peek();
             while (char.IsLetter(p) || char.IsWhiteSpace(p) || p == '-' || p == '>' || p == ']')
@@ -222,13 +223,13 @@ private bool TryConvert(char c)
             throw new ParseException(Resources.InvalidConvertionExpression + _buffer);
         }
 
-        private bool TryString(char c)
+        private bool TryString()
         {
-            if (!char.IsLetter(c))
+            if (!char.IsLetter(_currentChar))
                 return false;
 
             _buffer.Length = 0;
-            _buffer.Append(c);
+            _buffer.Append(_currentChar);
 
             char p = (char)_expressionReader.Peek();
             while (char.IsLetter(p) || char.IsNumber(p))
@@ -256,34 +257,34 @@ private bool TryString(char c)
             throw new ParseException(Resources.InvalidVariableEncountered + _buffer);
         }
 
-        private bool TryStartGroup(char c)
+        private bool TryStartGroup()
         {
-            if (c != '(')
+            if (_currentChar != '(')
                 return false;
 
             if (PeekNextNonWhitespaceChar() == ',')
             {
                 throw new ParseException(Resources.InvalidCharacterEncountered + ",");
             }
 
-            _symbolStack.Push(c.ToString());
+            _symbolStack.Push(_currentChar.ToString());
             return true;
         }
 
-        private bool TryComma(char c)
+        private bool TryComma()
         {
-            if (c != ',')
+            if (_currentChar != ',')
                 return false;
 
             if (_nestedFunctionDepth <= 0)
             {
-                throw new ParseException(Resources.InvalidCharacterEncountered + c);
+                throw new ParseException(Resources.InvalidCharacterEncountered + _currentChar);
             }
 
             char nextChar = PeekNextNonWhitespaceChar();
             if (nextChar == ')' || nextChar == ',')
             {
-                throw new ParseException(Resources.InvalidCharacterEncountered + c);
+                throw new ParseException(Resources.InvalidCharacterEncountered + _currentChar);
             }
 
             return true;
@@ -301,9 +302,9 @@ private char PeekNextNonWhitespaceChar()
         }
 
 
-        private bool TryEndGroup(char c)
+        private bool TryEndGroup()
         {
-            if (c != ')')
+            if (_currentChar != ')')
                 return false;
 
             bool hasStart = false;
@@ -340,13 +341,13 @@ private bool TryEndGroup(char c)
             return true;
         }
 
-        private bool TryOperator(char c)
+        private bool TryOperator()
         {
-            if (!OperatorExpression.IsSymbol(c))
+            if (!OperatorExpression.IsSymbol(_currentChar))
                 return false;
 
             bool repeat;
-            string s = c.ToString();
+            string s = _currentChar.ToString();
 
             do
             {
@@ -369,23 +370,24 @@ private bool TryOperator(char c)
             return true;
         }
 
-        private bool TryNumber(char c, char l)
+        private bool TryNumber(char lastChar)
         {
-            bool isNumber = NumberExpression.IsNumber(c);
+            bool isNumber = NumberExpression.IsNumber(_currentChar);
             // only negative when last char is group start or symbol
-            bool isNegative = NumberExpression.IsNegativeSign(c) &&
-                (l == '\0' || l == '(' || OperatorExpression.IsSymbol(l));
+            bool isNegative = NumberExpression.IsNegativeSign(_currentChar) &&
+                              (lastChar == '\0' || lastChar == '(' || OperatorExpression.IsSymbol(lastChar));
 
             if (!isNumber && !isNegative)
                 return false;
 
             _buffer.Length = 0;
-            _buffer.Append(c);
+            _buffer.Append(_currentChar);
 
             char p = (char)_expressionReader.Peek();
             while (NumberExpression.IsNumber(p))
             {
-                _buffer.Append((char)_expressionReader.Read());
+                _currentChar = (char) _expressionReader.Read();
+                _buffer.Append(_currentChar);
                 p = (char)_expressionReader.Peek();
             }