@pie-lib/math-evaluator 2.1.23 → 2.2.0-beta.1

package/CHANGELOG.md

@@ -3,7 +3,7 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
-## [2.1.23](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.22...@pie-lib/math-evaluator@2.1.23) (2023-06-24)
+# [2.2.0-beta.1](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.23...@pie-lib/math-evaluator@2.2.0-beta.1) (2025-07-20)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
@@ -11,7 +11,7 @@ See [Conventional Commits](https://conventionalcommits.org) for commit guideline
 
 
 
-## [2.1.22](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.20...@pie-lib/math-evaluator@2.1.22) (2023-01-31)
+# [2.2.0-beta.0](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.23...@pie-lib/math-evaluator@2.2.0-beta.0) (2025-07-20)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
@@ -19,62 +19,50 @@ See [Conventional Commits](https://conventionalcommits.org) for commit guideline
 
 
 
-## [2.1.20](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.19...@pie-lib/math-evaluator@2.1.20) (2023-01-31)
+# [2.3.0-beta.0](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.23...@pie-lib/math-evaluator@2.3.0-beta.0) (2025-07-15)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
+# [2.2.0-beta.0](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.23...@pie-lib/math-evaluator@2.2.0-beta.0) (2025-07-15)
 
+**Note:** Version bump only for package @pie-lib/math-evaluator
 
+## [2.1.23](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.22...@pie-lib/math-evaluator@2.1.23) (2023-06-24)
 
+**Note:** Version bump only for package @pie-lib/math-evaluator
 
-## [2.1.19](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.18...@pie-lib/math-evaluator@2.1.19) (2023-01-31)
+## [2.1.22](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.20...@pie-lib/math-evaluator@2.1.22) (2023-01-31)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
+## [2.1.20](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.19...@pie-lib/math-evaluator@2.1.20) (2023-01-31)
 
+**Note:** Version bump only for package @pie-lib/math-evaluator
 
+## [2.1.19](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.18...@pie-lib/math-evaluator@2.1.19) (2023-01-31)
 
+**Note:** Version bump only for package @pie-lib/math-evaluator
 
 ## [2.1.18](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.17...@pie-lib/math-evaluator@2.1.18) (2023-01-31)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
-
-
-
-
 ## [2.1.17](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.11...@pie-lib/math-evaluator@2.1.17) (2023-01-31)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
-
-
-
-
 ## [2.1.11](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.9...@pie-lib/math-evaluator@2.1.11) (2023-01-31)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
-
-
-
-
 ## [2.1.9](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.7...@pie-lib/math-evaluator@2.1.9) (2023-01-31)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
-
-
-
-
 ## [2.1.7](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.6...@pie-lib/math-evaluator@2.1.7) (2022-11-23)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator
 
-
-
-
-
 ## [2.1.6](https://github.com/pie-framework/pie-lib/compare/@pie-lib/math-evaluator@2.1.4...@pie-lib/math-evaluator@2.1.6) (2021-06-25)
 
 **Note:** Version bump only for package @pie-lib/math-evaluator

package/NEXT.CHANGELOG.json

@@ -0,0 +1 @@
+[]

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.1.23",
+  "version": "2.2.0-beta.1",
   "description": "Math evaluator tool for comparing expressions for equality",
   "keywords": [
     "math",
@@ -19,11 +19,12 @@
   "dependencies": {
     "@pie-framework/math-expressions": "^3.0.0",
     "jsesc": "^2.5.2",
+    "lodash": "^4.17.11",
     "mathjs": "^7.0.1"
   },
   "devDependencies": {
-    "@pie-lib/test-utils": "^0.2.33"
+    "@pie-lib/test-utils": "latest"
   },
   "scripts": {},
-  "gitHead": "4043c98430c000ce3a25357d92845175b076ea21"
+  "gitHead": "e2aa3ddac60f49bcb8c2562370f496323642f453"
 }

package/src/__tests__/index.test.js

@@ -0,0 +1,413 @@
+import areValuesEqual, { ave, latexToText } from '../index';
+import _ from 'lodash';
+
+describe('math-evaluator', () => {
+  describe('latexToText', () => {
+    const assertLatexToText = (input, expected) => {
+      it(`${input} => ${expected}`, () => {
+        const result = latexToText(input);
+        expect(result).toEqual(expected);
+      });
+    };
+    assertLatexToText('\\frac{ \\frac{1}{3}}{3}', '(1/3)/3');
+    assertLatexToText('\\neq', '0 != 0');
+    assertLatexToText('10 \\neq 20', '10 != 20');
+    assertLatexToText('10 \\neq', '10 != 0');
+    assertLatexToText('\\neq 10', '0 != 10');
+    assertLatexToText('40%', 'percent(40)');
+    assertLatexToText('%', 'percent(0)');
+    assertLatexToText('12%', 'percent(12)');
+    assertLatexToText('12\\%', 'percent(12)');
+    assertLatexToText('-12.5%', '- percent(12.5)');
+    assertLatexToText('-12.5\\%', '- percent(12.5)');
+  });
+
+  const assert = (isEqual, opts) => (label) =>
+    function() {
+      const args = Array.from(arguments);
+      const pairs = _.chunk(args, 2);
+
+      describe(label, () => {
+        pairs.forEach(([a, b]) => {
+          it(`${a} === ${b} ? ${isEqual}`, () => {
+            expect(areValuesEqual(a, b, opts)).toBe(isEqual);
+          });
+        });
+      });
+    };
+
+  const assertEqual = assert(true);
+  const assertNotEqual = assert(false);
+
+  const assertLatexEqual = assert(true, { isLatex: true });
+  const assertLatexNotEqual = assert(false, { isLatex: true });
+
+  const _amjs = (only) => (a, b, equal) => {
+    const fn = only ? it.only : it;
+    fn(`${a} === ${b} => ${equal}`, () => {
+      const as = latexToText(a);
+      const bs = latexToText(b);
+      expect(ave(as, bs)).toEqual(equal);
+    });
+  };
+
+  const assertThroughMathJs = _amjs(false);
+  assertThroughMathJs.only = _amjs(true);
+
+  const _als = (only) => (input, expected) => {
+    const fn = only ? it.only : it;
+    fn(`${input} => ${expected}`, () => {
+      expect(latexToText(input)).toEqual(expected);
+    });
+  };
+
+  const assertLatexFromString = _als(false);
+  assertLatexFromString.only = _als(true);
+
+  describe('ch6456', () => {
+    assertEqual('percent')('-12.5%', '-12.5%');
+    assertEqual('percent')('-12.5\\%', '-12.5%');
+    assertNotEqual('percent')('-11.5%', '-12.5%');
+  });
+
+  describe('ch6456 - latex', () => {
+    assertLatexEqual('percent')('\\frac{1}{2} -12.5%', '\\frac{2}{4} -12.5%');
+    assertLatexEqual('percent')('\\frac{1}{2} -12.5%', '\\frac{2}{4} -12.5\\%');
+    assertLatexNotEqual('percent')('\\frac{4}{2} -12.5%', '\\frac{2}{4} -12.5\\%');
+    assertLatexNotEqual('percent')('\\frac{2}{2} -12.5%', '\\frac{2}{4} -12.5\\%');
+  });
+
+  describe('PIE-188-math-expressions', () => {
+    // it('parses expressions correctly', async () => {
+
+    // geometry
+
+    // MULTIPLY WITH VARIABLE BASED
+    assertThroughMathJs('\\parallel x', '\\parallel x', true);
+    assertThroughMathJs('\\parallel x', '\\parallel   x', true);
+    assertThroughMathJs('\\parallel x', '\\parallel   0', false);
+    assertThroughMathJs('\\overrightarrow{x + 4}', '\\overrightarrow {4 + x}', true);
+    assertThroughMathJs('\\overrightarrow{4x^2 + 4}', '\\overrightarrow {4x^2 + 8 - 4}', true);
+    assertThroughMathJs('\\overrightarrow{21*2*x}', '\\overrightarrow {42x}', true);
+    assertLatexFromString('\\nparallel x', 'nparallel x');
+    assertLatexFromString('\\overrightarrow{x}', 'overrightarrow x');
+    assertLatexFromString('\\overleftrightarrow{x}', 'overleftrightarrow x');
+    assertLatexFromString('\\perp x', 'perp x');
+    assertLatexFromString('\\angle x', 'angle x');
+    assertLatexFromString('\\overarc x', 'overarc x');
+    assertLatexFromString('\\measuredangle x', 'measuredangle x');
+    assertLatexFromString('\\triangle x', 'triangle x');
+    assertLatexFromString('\\parallelogram x', 'parallelogram x');
+    assertLatexFromString('\\odot x', 'odot x');
+    assertLatexFromString('\\degree x', 'degree x');
+    assertLatexFromString('\\sim x', 'sim x');
+    assertLatexFromString('\\cong x', 'cong x');
+    assertLatexFromString('\\ncong x', 'ncong x');
+    assertLatexFromString('\\napprox x', 'napprox x'); // UNRECOGNIZED BY LEARNOSITY
+    assertLatexFromString('\\nim x', 'nim x'); // UNRECOGNIZED BY LEARNOSITY
+    assertLatexFromString('\\sim x', 'sim x');
+    expect(() => latexToText('\\sim 4', { unknownCommandBehavior: 'error' })).toThrow();
+
+    // comparisons
+
+    assertLatexFromString('1 \\lt 2', '1 < 2');
+
+    assertLatexFromString('1 \\gt 2', '1 > 2');
+
+    assertLatexFromString('1 \\le 2', '1 ≤ 2');
+
+    assertLatexFromString('1 \\ge 2', '1 ≥ 2');
+
+    // exponents
+
+    assertLatexFromString('2^2', '2^2');
+
+    assertLatexFromString('2^{3}', '2^3');
+
+    // roots
+
+    assertLatexFromString('\\sqrt{2}', 'sqrt(2)');
+
+    assertLatexFromString('\\sqrt[{3}]{3}', '3^(1/3)');
+
+    // fractions
+
+    assertLatexFromString('\\frac{3}{3}', '3/3');
+
+    assertLatexFromString('\\frac{x}{3}', 'x/3');
+
+    assertLatexFromString('x\\frac{5}{3}', 'x (5/3)');
+
+    // ACTUAL OPERATOR BASED
+    assertLatexFromString('\\overline{x}', 'overline x');
+    assertLatexFromString('\\pm', 'pm');
+    assertLatexFromString('\\approx x', 'approx x');
+
+    // logarithms
+
+    assertLatexFromString("4'", "4'");
+    assertLatexFromString('\\log 4', 'log(4)');
+    assertLatexFromString('\\log(4x)', 'log(4 x)');
+    assertLatexFromString('\\ln 4', 'ln(4)');
+
+    assertLatexFromString('|4|', '|4|');
+    assertLatexFromString('(4)', '4');
+    assertLatexFromString('(4 + x) * 5', '(4 + x) * 5');
+    assertLatexFromString('[4]', '4');
+    assertLatexFromString('\\mu', 'μ');
+    assertLatexFromString('\\Sigma', 'Σ');
+    assertLatexFromString('x^{15}', 'x^15');
+    assertLatexFromString('x_{15}', 'x_15');
+
+    // Trigo
+
+    assertLatexFromString('\\sin(x)', 'sin(x)');
+    assertLatexFromString('\\cos(x)', 'cos(x)');
+    assertLatexFromString('\\tan(x)', 'tan(x)');
+    assertLatexFromString('\\sec(x)', 'sec(x)');
+    assertLatexFromString('\\csc(x)', 'csc(x)');
+    assertLatexFromString('\\cot(x)', 'cot(x)');
+  });
+
+  // assertNotEqual('custom latex')('1530', `\\odot`);
+  assertNotEqual('evaluates simple expressions correctly')('0', 'x', '3x', '4x');
+
+  assertEqual('evaluates simple expressions correctly')('x', 'x', '2x', '2x');
+
+  describe('bad frac throws error', () => {
+    it('throws an error', () => {
+      expect(() => areValuesEqual('\\frac12', '\\frac34', { isLatex: true })).toThrow('Expecting {');
+    });
+  });
+  describe('7119', () => {
+    it.each`
+      v                             | isEqual
+      ${'4.5'}                      | ${true}
+      ${'3.2 + 1.3'}                | ${true}
+      ${'(4 - \\frac{4}{5}) + 1.3'} | ${true}
+      ${'\\frac{9}{2}'}             | ${true}
+      ${'4 \\frac{1}{2}'}           | ${true}
+      ${'\\frac{10}{2} - 0.5'}      | ${true}
+      ${'4.55'}                     | ${false}
+    `('$a == $isEqual', ({ v, isEqual }) => {
+      const result = areValuesEqual('4 \\frac{1}{2}', v, { isLatex: true });
+      expect(result).toEqual(isEqual);
+    });
+
+    it('?', () => {
+      expect(latexToText('4\\frac{1}{2}')).toEqual('4 + 1/2');
+    });
+  });
+
+  assertEqual('evaluates simple expressions correctly 2')(
+    '100',
+    '100',
+    '50 + 50',
+    '25 * 4',
+    '200 / 2',
+    '20 * 5',
+    '2.5 * 40',
+    '10 * 10',
+  );
+
+  assertNotEqual('evaluates simple expressions correctly 2')(
+    '100',
+    '0',
+    '0',
+    '50 * 2',
+    '44 + 57',
+    '100',
+    '44 + 57',
+    '50 * 3',
+  );
+
+  assertEqual('evaluates simple expressions correctly 3')(
+    '50 + 50',
+    '100',
+    '100 / 2 + 50',
+    '100',
+    '2 + 2',
+    '4',
+    '1/2 + .5',
+    '1',
+  );
+
+  assertNotEqual('evaluates simple expressions correctly 3')(
+    '50 + 51',
+    '100',
+    '25 * 2 + 51',
+    '100',
+    '1/2 + .5',
+    '1.9',
+    '1/2 + .5',
+    '1.1',
+  );
+
+  assertEqual('evaluates simple expressions correctly 4')(
+    '50 + 50',
+    '100',
+    '100 / 2 + 50',
+    '100',
+    '2 + 2',
+    '4',
+    '1/2 + .5',
+    '1',
+    '13/2',
+    '13/2',
+    '26/4',
+    '13/2',
+    '6 + 1/2',
+    '13/2',
+    '6.5',
+    '13/2',
+  );
+
+  assertNotEqual('evaluates simple expressions correctly 4')(
+    '50 + 51',
+    '100',
+    '25 * 2 + 51',
+    '100',
+    '1/2 + .5',
+    '1.9',
+    '1/2 + .5',
+    '1.1',
+    '14/2',
+    '13/2',
+    '6.6',
+    '13/2',
+  );
+
+  it.each`
+    a                        | b
+    ${'((x^2 + x) / x) - 1'} | ${'x'}
+  `('$a == $b', ({ a, b }) => {
+    expect(areValuesEqual(a, b)).toBe(true);
+  });
+
+  assertEqual('evaluates simple variable expressions correctly')(
+    'x',
+    'x',
+    'x + 0',
+    'x',
+    '(x-2) + 2',
+    'x',
+    '((x^2 + x) / x) - 1',
+    'x',
+    '2x/2',
+    'x',
+    '(x + 2)^2',
+    '(x + 2)^2',
+    'x^2 + 4x + 4',
+    '(x + 2)^2',
+    'x^2 + 4(x+1)',
+    '(x + 2)^2',
+    'x^2 + 8 ((x+1) / 2)',
+    '(x + 2)^2',
+  );
+
+  assertNotEqual('evaluates simple variable expressions correctly')(
+    'y',
+    'x',
+    'x + 1',
+    'x',
+    'x^3 + 4x + 4',
+    '(x + 2)^2',
+    'x^2 + 4(x+2)',
+    '(x + 2)^2',
+  );
+
+  assertEqual('evaluates simple variable expressions correctly 2')(
+    '(2 + x)^2',
+    '(x + 2)^2',
+    'x^2 + 4x + 4',
+    '(x + 2)^2',
+    'x^2 + 4(x+1)',
+    '(x + 2)^2',
+    'x^2 + 8 ((x+1) / 2)',
+    '(x + 2)^2',
+  );
+
+  assertEqual('evaluates expressions correctly with variable exponents')(
+    '(2 + x)^2x',
+    '(x + 2)^2x',
+    'y^(2 x)',
+    'y^(x+x)',
+  );
+
+  assertEqual('evaluates function expressions correctly with variable parameters')(
+    'sqrt(4x)',
+    'sqrt(2x+2x)',
+    'sqrt(x^2)',
+    'sqrt(((x+1)^2) - ((x+1)^2) + x^2)',
+  );
+
+  assertNotEqual('evaluates simple variable expressions correctly 2')(
+    'x^3 + 4x + 4',
+    '(x + 2)^2',
+    'x^2 + 4(x+2)',
+    '(x + 2)^2',
+  );
+
+  it('correctly consumes allowDecimals option', () => {
+    expect(areValuesEqual('123', '123', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('123', '123.0', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('123,0', '123.0', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('123,0', '123.0', { allowDecimals: false })).toEqual(false);
+    expect(areValuesEqual('123', '123.0', { allowDecimals: false })).toEqual(false);
+    expect(areValuesEqual('123', '123,0', { allowDecimals: false })).toEqual(false);
+  });
+
+  it('correctly consumes allowDecimals option for complex examples too', () => {
+    expect(areValuesEqual('1500000', '1500000', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('1,500,000', '1,500,000', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('1500000', '1,500,000', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('1500000', '1,500,000.00', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('1500000', '1,500,000.0', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('1,500,000.0', '1,500,000.00', { allowDecimals: true })).toEqual(true);
+    expect(areValuesEqual('1500000', '1,500000', { allowDecimals: true })).toEqual(false);
+    expect(areValuesEqual('1500000', '1500,000', { allowDecimals: true })).toEqual(false);
+    expect(areValuesEqual('1500000', '1,500,000.01', { allowDecimals: true })).toEqual(false);
+    expect(areValuesEqual('1500000', '1,500,00,0', { allowDecimals: true })).toEqual(false);
+    expect(areValuesEqual('1500000', '1500,000', { allowDecimals: true })).toEqual(false);
+    expect(areValuesEqual('1500000', ',1500,000', { allowDecimals: true })).toEqual(false);
+  });
+
+  it('evaluates simple trigo expressions correctly', () => {
+    expect(areValuesEqual('sin(x)', 'sin(x)')).toEqual(true);
+    expect(areValuesEqual('tan(x)', 'tan(x)')).toEqual(true);
+  });
+
+  it('correctly creates math expressions 1', () => {
+    expect(
+      areValuesEqual('f^{-1}\\left(x\\right)=\\sqrt{x-1}+3', 'f^{-1}\\left(x\\right)=\\sqrt{x-1}+3', {
+        allowDecimals: true,
+        isLatex: true,
+      }),
+    ).toEqual(true);
+  });
+
+  it('correctly creates math expressions 2', () => {
+    expect(
+      areValuesEqual('72\\div12=6\\text{eggs}', '72\\div12=6\\text{eggs}', {
+        allowDecimals: true,
+        isLatex: true,
+      }),
+    ).toEqual(true);
+  });
+
+  describe('PD-3', () => {
+    it.each`
+      a                                                               | b
+      ${'\\left(x\\right)^{ \\frac{1}{\\left(y + 3\\right)}}'}        | ${'\\sqrt[\\left(y + 3\\right)]{x}'}
+      ${'\\left(x\\right)^{\\frac{1}{3}}'}                            | ${'\\sqrt[3]{x}'}
+      ${'\\left(x\\right)^{\\frac{1}{n}}'}                            | ${'\\sqrt[n]{x}'}
+      ${'\\left(x\\right)^{\\frac{1}{2}}'}                            | ${'\\sqrt{x}'}
+      ${'\\left(x-1\\right)^{\\frac{1}{2}}+3'}                        | ${'\\sqrt{x-1}+3'}
+      ${'f^{-1}\\left(x\\right)=\\left(x-1\\right)^{\\frac{1}{2}}+3'}
+      ${'f^{-1}\\left(x\\right)=\\sqrt{x-1}+3'}
+    `('$a == $b', ({ a, b }) => {
+      const opts = { allowDecimals: true, isLatex: true };
+      expect(areValuesEqual(a, b, opts)).toBeTruthy();
+    });
+  });
+});