Version v2.1.0 (#10)

* Implement it using 'm'

* Use full word 'max' as token

* Use function names as variables

* Make it explicitly case insensitive

* Convert to generalised 'function'

* Add error states

* Increment minor version

* Update readme

* Add test for empty call of max

* Update readme again

* Generalise getVariables for future functions

* Update and add tests

* Use `isFunctionToken` and add comment

* Make commas fully not operators

Author: Alastair-L

README.md

@@ -46,3 +46,15 @@ import { getVariables } from '@beyondessential/arithmetic';
 const variables = getVariables('(-a * b - 1) / (c + 3)');
 console.log(variables); // ['a', 'b', 'c']
 ```
+
+## formulaText operators
+Note: All operators are case **in**sensitive.
+Operator | Example | Description
+-|-|-
+ `+` | `1 + 1` | Addition
+ `-` | `1 - 1` | Subtraction
+`*` or `x` | `1 * 1` or `1 x 1` | Multiplication
+`/` | `1 / 1` | Division
+`()`| `1 / (1 + 1)` | Brackets
+`-` | `-1` | Unary minus
+`max` | `max(1, 2, 3)` | Takes the maximum value of it's arguments. `-Infinity` if given none

__tests__/arithmetic.test.js

@@ -65,7 +65,7 @@ describe('Arithmetic', () => {
   });
 
   describe('unary minus (for eg, -1)', () => {
-    it('should handle multiplying by a negative', () => {
+    it('should handle dividing by a negative', () => {
       const result = runArithmetic('4 / - 2');
       expect(result).toEqual(4 / -2);
     });
@@ -75,7 +75,7 @@ describe('Arithmetic', () => {
       expect(result).toEqual(4 * -2 * -2);
     });
 
-    it('should handle multiplying by a double negative', () => {
+    it('should handle dividing by a double negative', () => {
       const result = runArithmetic('4 / - - 2');
       expect(result).toEqual(4 / 2);
     });
@@ -94,6 +94,44 @@ describe('Arithmetic', () => {
       const result = runArithmetic('1+1 - - 5');
       expect(result).toEqual(1 + 1 - -5);
     });
+
+    it('should handle negating a function call', () => {
+      const result = runArithmetic('1 - -max(1, 2)');
+      expect(result).toEqual(1 - -Math.max(1, 2));
+    });
+  });
+
+  describe('max function', () => {
+    const { max } = Math;
+    it('should handle max with no arguments', () => {
+      const result = runArithmetic('max()');
+      expect(result).toEqual(-Infinity);
+    });
+
+    it('should handle max of one number', () => {
+      const result = runArithmetic('max(15)');
+      expect(result).toEqual(max(15));
+    });
+
+    it('should handle max of two numbers', () => {
+      const result = runArithmetic('max(15, 20)');
+      expect(result).toEqual(max(15, 20));
+    });
+
+    it('should handle a more complex expression', () => {
+      const result = runArithmetic('max(1, 3 - 2, -100) / 2');
+      expect(result).toEqual(max(1, 3 - 2, -100) / 2);
+    });
+
+    it('should handle a yet more complex expression', () => {
+      const result = runArithmetic('max(max(), (-max(15, 3 -2, -100) / 2 + 1 - max(3/2)) /2, -10)');
+      expect(result).toEqual(max(-Infinity, (-max(15, 3 - 2, -100) / 2 + 1 - max(3 / 2)) / 2, -10));
+    });
+
+    it('should be caps insensitive', () => {
+      const result = runArithmetic('maX(15)');
+      expect(result).toEqual(max(15));
+    });
   });
 
   describe('substituting values', () => {
@@ -103,6 +141,9 @@ describe('Arithmetic', () => {
       pi: 3.14159,
       sins: 7,
       negative: -5,
+      theLetter_A: 65,
+      theLetter_a: 97,
+      max: 100,
     };
 
     it('should handle simple value substitution', () => {
@@ -115,10 +156,25 @@ describe('Arithmetic', () => {
       expect(result).toEqual(10 - 5);
     });
 
+    it('should handle substituting based on capitalization', () => {
+      const result = runArithmetic('theLetter_A - theLetter_a', VALUES);
+      expect(result).toEqual(65 - 97);
+    });
+
     it('should handle a more complicated case', () => {
       const result = runArithmetic('-eyes * (sins - pi * 3) / negative + (sins + 1)', VALUES);
       expect(result).toEqual((-2 * (7 - 3.14159 * 3)) / -5 + (7 + 1));
     });
+
+    it('should handle substitution of a value which is a function name', () => {
+      const result = runArithmetic('fingers + max', VALUES);
+      expect(result).toEqual(10 + 100);
+    });
+
+    it('should be able to substitute values into a function with the same name', () => {
+      const result = runArithmetic('max(max, eyes)', VALUES);
+      expect(result).toEqual(Math.max(100, 10));
+    });
   });
 
   describe('errors', () => {
@@ -135,6 +191,25 @@ describe('Arithmetic', () => {
       expect(() => runArithmetic('4 * 1 + 2)')).toThrow();
     });
 
+    it('should fail on incorrect function call', () => {
+      expect(() => runArithmetic('max(')).toThrow();
+      expect(() => runArithmetic('max())')).toThrow();
+      expect(() => runArithmetic('max(()')).toThrow();
+      expect(() => runArithmetic('max((1, 2), 3)')).toThrow();
+      expect(() => runArithmetic('max(3, (1, 2))')).toThrow();
+      expect(() => runArithmetic('max(, 3)')).toThrow();
+      expect(() => runArithmetic('max(3, )')).toThrow();
+      expect(() => runArithmetic('max(3,,2)')).toThrow();
+      expect(() => runArithmetic('max(3-,2)')).toThrow();
+    });
+
+    it('should fail on incorrect comma usage', () => {
+      expect(() => runArithmetic('1 + , 1')).toThrow();
+      expect(() => runArithmetic('1 , 1')).toThrow();
+      expect(() => runArithmetic('1 + (1, 1)')).toThrow();
+      expect(() => runArithmetic(',')).toThrow();
+    });
+
     it('should fail if a substitution is not numeric', () => {
       expect(() => runArithmetic('check + 1', { check: 'check' })).toThrow();
       expect(() => runArithmetic('check + 1', { check: '+' })).toThrow();

__tests__/symbols.test.js

@@ -18,6 +18,8 @@ describe('getVariables()', () => {
     ['no whitespace', 'a+b', ['a', 'b']],
     ['same variable multiple times', 'a * b + a', ['a', 'b']],
     ['all operators', '(a + -b) / ((2 * c) - 3 x d)', ['a', 'b', 'c', 'd']],
+    ['formula includes functions', 'max(1, 2, a)', ['a']],
+    ['variable with function name', 'max(1, 2, a, max)', ['a', 'max']],
   ];
 
   it.each(testData)('%s', (_, formula, expected) => {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@beyondessential/arithmetic",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Utility to evaluate BODMAS arithmetic formulas",
   "keywords": [
     "arithmetic",

src/arithmetic.js

@@ -22,9 +22,11 @@
 // that, don't sweat! There're unit tests and you can validate that things
 // work over there.
 
-import { isOperator, getPrecedence } from './symbols';
+import {
+  isOperator, getPrecedence, FUNCTION_NAMES, isFunctionToken,
+} from './symbols';
 
-const unaryRegex = /(^|[*x/+\-u])-/g;
+const unaryRegex = /(^|[*x/+\-u,(])-/g;
 function replaceUnaryMinus(text) {
   const replaced = text.replace(unaryRegex, (match, p1) => `${p1}u`);
   if (replaced !== text) {
@@ -47,7 +49,7 @@ function shouldPopOperator(token, topOfStack) {
   return true;
 }
 
-const tokenizer = /([+\-*/()ux])/g;
+const tokenizer = new RegExp(`(${FUNCTION_NAMES.join('|')}|[+\\-*/()ux,])`, 'g');
 
 function shuntingYard(text) {
   const stack = [];
@@ -64,18 +66,32 @@ function shuntingYard(text) {
         queue.push(stack.shift());
       }
       stack.unshift(token);
+      if (isFunctionToken(token)) queue.push('END_ARGS');
       continue;
     }
     if (token === '(') {
       stack.unshift(token);
       continue;
     }
+    if (token === ',') {
+      while (stack.length && stack[0] !== '(') {
+        queue.push(stack.shift());
+      }
+      if (!(stack[0] === '(' && isFunctionToken(stack[1]))) {
+        // A comma is ONLY valid when the next thing in the stack is the function call
+        throw new Error('Incorrect function call');
+      }
+      continue;
+    }
     if (token === ')') {
       while (stack.length > 0 && stack[0] !== '(') {
         queue.push(stack.shift());
       }
       if (stack[0] === '(') {
         stack.shift();
+        if (isFunctionToken(stack[0])) {
+          queue.push(stack.shift());
+        }
       } else {
         throw new Error('Unmatched parenthesis');
       }
@@ -88,7 +104,7 @@ function shuntingYard(text) {
       continue;
     }
 
-    throw new Error('Unrecognised token');
+    throw new Error(`Unrecognised token: ${token}`);
   }
 
   while (stack.length > 0) {
@@ -109,11 +125,23 @@ function processQueue(queue) {
 
     // alias just in case
     x: () => operations['*'](),
+
+    // functions
+    max: () => {
+      let val = stack.pop();
+      let max = -Infinity;
+      while (val !== 'END_ARGS') {
+        max = Math.max(max, val);
+        if (stack.length === 0) throw new Error('No END_ARGS for function "max"');
+        val = stack.pop();
+      }
+      return max;
+    },
   };
 
   while (queue.length > 0) {
     const item = queue.shift();
-    if (typeof item === 'number') {
+    if (typeof item === 'number' || item === 'END_ARGS') {
       stack.push(item);
       continue;
     }
@@ -129,26 +157,36 @@ function processQueue(queue) {
 
 const noWhitespace = /\s/g;
 
+// Names with a '(' after them are function calls, not variables
+// e.g. max(5 + max)
+// the first max would not be replaced
+const buildVariableReplacer = (key) => new RegExp(`${key}(?!\\s*\\()`, 'g');
+
 export function runArithmetic(formulaText, values = {}) {
   // first replace variables with their actual values
   // (we do this here rather than treating the variable names as tokens,
   // so that the tokeniser doesn't get confused by variable names with
   // u and x in them)
   let valuedText = formulaText;
-  Object.entries(values).map(([key, value]) => {
+  Object.entries(values).forEach(([key, value]) => {
     if (Number.isNaN(parseFloat(value))) {
       throw new Error('Invalid value substitution');
     }
 
-    valuedText = valuedText.replace(new RegExp(key, 'g'), value);
+    valuedText = valuedText.replace(buildVariableReplacer(key), value);
   });
 
   // strip out all whitespace
   const strippedText = valuedText.replace(noWhitespace, '');
 
+  if (strippedText.match(/([(,],)|(,\))/g)) throw new Error('Leading or trailing comma detected');
+
+  // functions are case insensitive
+  const lowercaseText = strippedText.toLowerCase();
+
   // then replace the unary minus with a 'u' so we can
   // handle it differently to subtraction in the tokeniser
-  const replacedText = replaceUnaryMinus(strippedText);
+  const replacedText = replaceUnaryMinus(lowercaseText);
 
   // then create a postfix queue using the shunting yard algorithm
   const queue = shuntingYard(replacedText);

src/symbols.js

@@ -5,11 +5,17 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+export const FUNCTION_NAMES = ['max'];
+
+export const isFunctionToken = (token) => FUNCTION_NAMES.includes(token);
+
 export function isOperator(token) {
-  return ['+', '-', '/', '*', 'x', 'u'].includes(token);
+  return ['+', '-', '/', '*', 'x', 'u'].includes(token) || isFunctionToken(token);
 }
 
 export function getPrecedence(operator) {
+  if (isFunctionToken(operator)) return 5;
+
   switch (operator) {
     case 'u':
       return 4;
@@ -29,8 +35,10 @@ export function getVariables(formulaText) {
   const variables = formulaText
     // Replace the alternate multiplication symbol 'x' with a non-alphanumeric character
     .replace(/(^|\W)x(\W|$)/, ' ')
+    // Replace functions with a non-alphanumeric character
+    .replace(new RegExp(`${FUNCTION_NAMES.join('|')}\\s*\\(`, 'g'), ' ')
     .split(/[+-/*() ]/g)
-    .filter(v => v !== '' && Number.isNaN(Number(v)));
+    .filter((v) => v !== '' && Number.isNaN(Number(v)));
 
   return [...new Set(variables)];
 }