mathjs 10.0.2 → 10.2.0

package/lib/esm/function/algebra/{simplify/simplifyCore.js → simplifyCore.js}

@@ -1,7 +1,8 @@
-import { isConstantNode, isFunctionNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
-import { factory } from '../../../utils/factory.js';
+import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, isOperatorNode } from '../../utils/is.js';
+import { createUtil } from './simplify/util.js';
+import { factory } from '../../utils/factory.js';
 var name = 'simplifyCore';
-var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'ConstantNode', 'OperatorNode', 'FunctionNode', 'ParenthesisNode'];
+var dependencies = ['equal', 'isZero', 'add', 'subtract', 'multiply', 'divide', 'pow', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', 'ParenthesisNode', 'SymbolNode'];
 export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     equal,
@@ -11,13 +12,26 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
-    ParenthesisNode
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
+    ParenthesisNode,
+    SymbolNode
   } = _ref;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
+  var {
+    hasProperty,
+    isCommutative
+  } = createUtil({
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  });
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -26,30 +40,53 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
    *
    * Syntax:
    *
-   *     simplify.simplifyCore(expr)
+   *     simplifyCore(expr)
    *
    * Examples:
    *
    *     const f = math.parse('2 * 1 * x ^ (2 - 1)')
-   *     math.simplify.simpifyCore(f)                          // Node {2 * x}
-   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplify.simpifyCore]) // Node {2 * x}
+   *     math.simpifyCore(f)                          // Node {2 * x}
+   *     math.simplify('2 * 1 * x ^ (2 - 1)', [math.simplifyCore]) // Node {2 * x}
    *
    * See also:
    *
-   *     derivative
+   *     simplify, resolve, derivative
    *
    * @param {Node} node
    *     The expression to be simplified
+   * @param {Object} options
+   *     Simplification options, as per simplify()
+   * @return {Node} Returns expression with basic simplifications applied
    */
 
-  function simplifyCore(node) {
-    if (isOperatorNode(node) && node.isUnary()) {
-      var a0 = simplifyCore(node.args[0]);
+  function simplifyCore(node, options) {
+    var context = options ? options.context : undefined;
 
-      if (node.op === '+') {
-        // unary plus
-        return a0;
+    if (hasProperty(node, 'trivial', context)) {
+      // This node does nothing if it has only one argument, so if so,
+      // return that argument simplified
+      if (isFunctionNode(node) && node.args.length === 1) {
+        return simplifyCore(node.args[0], options);
+      } // For other node types, we try the generic methods
+
+
+      var simpChild = false;
+      var childCount = 0;
+      node.forEach(c => {
+        ++childCount;
+
+        if (childCount === 1) {
+          simpChild = simplifyCore(c, options);
+        }
+      });
+
+      if (childCount === 1) {
+        return simpChild;
       }
+    }
+
+    if (isOperatorNode(node) && node.isUnary()) {
+      var a0 = simplifyCore(node.args[0], options);
 
       if (node.op === '-') {
         // unary minus
@@ -64,9 +101,9 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
         return new OperatorNode(node.op, node.fn, [a0]);
       }
     } else if (isOperatorNode(node) && node.isBinary()) {
-      var _a = simplifyCore(node.args[0]);
+      var _a = simplifyCore(node.args[0], options);
 
-      var a1 = simplifyCore(node.args[1]);
+      var a1 = simplifyCore(node.args[1], options);
 
       if (node.op === '+') {
         if (isConstantNode(_a)) {
@@ -102,7 +139,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
           }
 
           if (isOperatorNode(a1) && a1.isUnary() && a1.op === '-') {
-            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]));
+            return simplifyCore(new OperatorNode('+', 'add', [_a, a1.args[0]]), options);
           }
 
           return new OperatorNode(node.op, node.fn, [_a, a1]);
@@ -123,7 +160,7 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
-          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op) {
+          } else if (isOperatorNode(_a) && _a.isBinary() && _a.op === node.op && isCommutative(node, context)) {
             var a00 = _a.args[0];
 
             if (isConstantNode(a00)) {
@@ -132,7 +169,11 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
             }
           }
 
-          return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
+          if (isCommutative(node, context)) {
+            return new OperatorNode(node.op, node.fn, [a1, _a], node.implicit); // constants on left
+          } else {
+            return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
+          }
         }
 
         return new OperatorNode(node.op, node.fn, [_a, a1], node.implicit);
@@ -168,19 +209,22 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
 
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-    } else if (isParenthesisNode(node)) {
-      var c = simplifyCore(node.content);
-
-      if (isParenthesisNode(c) || isSymbolNode(c) || isConstantNode(c)) {
-        return c;
+    } else if (isFunctionNode(node)) {
+      return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
+    } else if (isArrayNode(node)) {
+      return new ArrayNode(node.items.map(n => simplifyCore(n, options)));
+    } else if (isAccessorNode(node)) {
+      return new AccessorNode(simplifyCore(node.object, options), simplifyCore(node.index, options));
+    } else if (isIndexNode(node)) {
+      return new IndexNode(node.dimensions.map(n => simplifyCore(n, options)));
+    } else if (isObjectNode(node)) {
+      var newProps = {};
+
+      for (var prop in node.properties) {
+        newProps[prop] = simplifyCore(node.properties[prop], options);
       }
 
-      return new ParenthesisNode(c);
-    } else if (isFunctionNode(node)) {
-      var args = node.args.map(simplifyCore).map(function (arg) {
-        return isParenthesisNode(arg) ? arg.content : arg;
-      });
-      return new FunctionNode(simplifyCore(node.fn), args);
+      return new ObjectNode(newProps);
     } else {// cannot simplify
     }
 

package/lib/esm/function/arithmetic/invmod.js

@@ -0,0 +1,57 @@
+import { factory } from '../../utils/factory.js';
+var name = 'invmod';
+var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+export var createInvmod = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    BigNumber,
+    xgcd,
+    equal,
+    smaller,
+    mod,
+    add,
+    isInteger
+  } = _ref;
+
+  /**
+   * Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
+   * See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
+   *
+   * Syntax:
+   *
+   *    math.invmod(a, b)
+   *
+   * Examples:
+   *
+   *    math.invmod(8, 12)             // returns NaN
+   *    math.invmod(7, 13)             // return 2
+   *    math.invmod(15151, 15122)      // returns 10429
+   *
+   * See also:
+   *
+   *    gcd, xgcd
+   *
+   * @param {number | BigNumber} a  An integer number
+   * @param {number | BigNumber} b  An integer number
+   * @return {number | BigNumber }  Returns an integer number
+   *                              where `invmod(a,b)*a ≣ 1 (mod b)`
+   */
+  return typed(name, {
+    'number, number': invmod,
+    'BigNumber, BigNumber': invmod
+  });
+
+  function invmod(a, b) {
+    if (!isInteger(a) || !isInteger(b)) throw new Error('Parameters in function invmod must be integer numbers');
+    a = mod(a, b);
+    if (equal(b, 0)) throw new Error('Divisor must be non zero');
+    var res = xgcd(a, b);
+    res = res.valueOf();
+    var [gcd, inv] = res;
+    if (!equal(gcd, BigNumber(1))) return NaN;
+    inv = mod(inv, b);
+    if (smaller(inv, BigNumber(0))) inv = add(inv, b);
+    return inv;
+  }
+});

package/lib/esm/header.js

@@ -10,7 +10,7 @@
  * @date    @@date
  *
  * @license
- * Copyright (C) 2013-2021 Jos de Jong <wjosdejong@gmail.com>
+ * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>
  *
  * Licensed under the Apache License, Version 2.0 (the "License"); you may not
  * use this file except in compliance with the License. You may obtain a copy

package/lib/esm/plain/number/combinations.js

@@ -14,14 +14,26 @@ export function combinationsNumber(n, k) {
   }
 
   var nMinusk = n - k;
-  var prodrange;
+  var answer = 1;
+  var firstnumerator = k < nMinusk ? nMinusk + 1 : k + 1;
+  var nextdivisor = 2;
+  var lastdivisor = k < nMinusk ? k : nMinusk; // balance multiplications and divisions to try to keep intermediate values
+  // in exact-integer range as long as possible
 
-  if (k < nMinusk) {
-    prodrange = product(nMinusk + 1, n);
-    return prodrange / product(1, k);
+  for (var nextnumerator = firstnumerator; nextnumerator <= n; ++nextnumerator) {
+    answer *= nextnumerator;
+
+    while (nextdivisor <= lastdivisor && answer % nextdivisor === 0) {
+      answer /= nextdivisor;
+      ++nextdivisor;
+    }
+  } // for big n, k, floating point may have caused weirdness in remainder
+
+
+  if (nextdivisor <= lastdivisor) {
+    answer /= product(nextdivisor, lastdivisor);
   }
 
-  prodrange = product(k + 1, n);
-  return prodrange / product(1, nMinusk);
+  return answer;
 }
 combinationsNumber.signature = 'number, number';

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '10.0.2'; // Note: This file is automatically generated when building math.js.
+export var version = '10.2.0'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "10.0.2",
+  "version": "10.2.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,43 +25,44 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.16.5",
+    "@babel/runtime": "^7.17.2",
     "complex.js": "^2.0.15",
     "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.1.2",
+    "fraction.js": "^4.1.3",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
     "typed-function": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.16.5",
-    "@babel/plugin-transform-object-assign": "7.16.5",
-    "@babel/plugin-transform-runtime": "7.16.5",
-    "@babel/preset-env": "7.16.5",
-    "@babel/register": "7.16.5",
+    "@babel/core": "7.17.5",
+    "@babel/plugin-transform-object-assign": "7.16.7",
+    "@babel/plugin-transform-runtime": "7.17.0",
+    "@babel/preset-env": "7.16.11",
+    "@babel/register": "7.17.0",
+    "assert": "2.0.0",
     "babel-loader": "8.2.3",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.20.1",
+    "core-js": "3.21.1",
     "del": "6.0.0",
     "dtslint": "4.2.1",
     "expr-eval": "2.0.2",
-    "fancy-log": "1.3.3",
+    "fancy-log": "2.0.0",
     "glob": "7.2.0",
     "gulp": "4.0.2",
     "gulp-babel": "8.0.0",
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
-    "jsep": "1.2.0",
-    "karma": "6.3.9",
+    "jsep": "1.3.0",
+    "karma": "6.3.16",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "4.0.2",
-    "math-expression-evaluator": "1.3.8",
+    "math-expression-evaluator": "1.3.14",
     "mkdirp": "1.0.4",
     "mocha": "8.4.0",
     "ndarray": "1.0.19",
@@ -72,9 +73,10 @@
     "numericjs": "1.2.6",
     "nyc": "15.1.0",
     "pad-right": "0.2.2",
+    "process": "0.11.10",
     "standard": "16.0.4",
     "sylvester": "0.0.21",
-    "typescript": "4.5.4",
+    "typescript": "4.5.5",
     "webpack": "4.46.0",
     "zeros": "1.0.0"
   },
@@ -124,13 +126,14 @@
     "CONTRIBUTING.md"
   ],
   "scripts": {
-    "build": "gulp --gulpfile gulpfile.cjs",
+    "build": "gulp --gulpfile gulpfile.cjs && npm run update-authors",
     "build-and-test": "npm run build && npm run test:all && npm run lint",
     "build:clean": "gulp --gulpfile gulpfile.cjs clean",
     "build:docs": "gulp --gulpfile gulpfile.cjs docs",
     "compile": "gulp --gulpfile gulpfile.cjs compile",
     "watch": "gulp --gulpfile gulpfile.cjs watch",
     "lint": "standard --env=mocha --env=worker",
+    "format": "npm run lint -- --fix",
     "validate:ascii": "gulp --gulpfile gulpfile.cjs validate:ascii",
     "test": "npm run test:src && npm run lint",
     "test:src": "mocha test/unit-tests",
@@ -160,5 +163,8 @@
     "src": "./src",
     "test": "./test"
   },
+  "browserslist": [
+    "IE 11"
+  ],
   "sideEffects": false
 }

package/types/index.d.ts

@@ -575,7 +575,7 @@ declare namespace math {
      * @param unit The unit to be created
      * @returns The created unit
      */
-    unit(value: number | MathArray | Matrix, unit: string): Unit;
+    unit(value: number | MathArray | Matrix | BigNumber, unit: string): Unit;
 
     /*************************************************************************
      * Expression functions
@@ -1674,6 +1674,19 @@ declare namespace math {
         column: number
     ): T;
 
+    /**
+     * Return a rotated matrix.
+     * @param {Array | Matrix} w                             Vector to rotate
+     * @param {number | BigNumber | Complex | Unit} theta    Rotation angle
+     * @param {Array | Matrix} [v]                           Rotation axis
+     * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
+     */
+         rotate<T extends MathArray | Matrix>(
+          w: T,
+          theta: number | BigNumber | Complex | Unit,
+          v?: T
+      ): T;
+
     /**
      * Calculate the size of a matrix or scalar.
      * @param A matrix
@@ -1783,7 +1796,7 @@ declare namespace math {
      * @param n A real or complex number
      * @returns The gamma of n
      */
-    gamma(n: number | MathArray | Matrix): number | MathArray | Matrix;
+    gamma<T extends number | BigNumber | Complex | MathArray | Matrix>(n: T): NoLiteralType<T>;
 
     /**
      * Calculate the Kullback-Leibler (KL) divergence between two
@@ -3121,6 +3134,28 @@ declare namespace math {
     fixPrefix?: boolean;
   }
 
+  interface UnitComponent {
+    power: number;
+    prefix: string;
+    unit: {
+      name: string;
+      base: {
+        dimensions: number[];
+        key: string;
+      };
+      prefixes: Record<string, UnitPrefix>;
+      value: number;
+      offset: number;
+      dimensions: number[];
+    };
+  }
+
+  interface UnitPrefix {
+    name: string;
+    value: number;
+    scientific: boolean;
+  }
+
   interface Unit {
     valueOf(): string;
     clone(): Unit;
@@ -3139,7 +3174,14 @@ declare namespace math {
     toJSON(): MathJSON;
     formatUnits(): string;
     format(options: FormatOptions): string;
+    simplify(): Unit;
     splitUnit(parts: ReadonlyArray<string | Unit>): Unit[];
+
+    units: UnitComponent[];
+    dimensions: number[];
+    value: number;
+    fixPrefix: boolean;
+    skipAutomaticSimplification: true;
   }
 
   interface CreateUnitOptions {
@@ -3409,11 +3451,11 @@ declare namespace math {
 
   interface ConfigOptions {
     epsilon?: number;
-    matrix?: string;
-    number?: string;
+    matrix?: 'Matrix' | 'Array';
+    number?: 'number' | 'BigNumber' | 'Fraction';
     precision?: number;
-    parenthesis?: string;
-    randomSeed?: string;
+    predictable?: boolean;
+    randomSeed?: string | null;
   }
 
   interface MathJsJson {

package/lib/cjs/function/algebra/simplify/resolve.js

@@ -1,76 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createResolve = void 0;
-
-var _map = require("../../../utils/map.js");
-
-var _is = require("../../../utils/is.js");
-
-var _factory = require("../../../utils/factory.js");
-
-var name = 'resolve';
-var dependencies = ['parse', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
-var createResolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var parse = _ref.parse,
-      FunctionNode = _ref.FunctionNode,
-      OperatorNode = _ref.OperatorNode,
-      ParenthesisNode = _ref.ParenthesisNode;
-
-  /**
-   * resolve(expr, scope) replaces variable nodes with their scoped values
-   *
-   * Syntax:
-   *
-   *     simplify.resolve(expr, scope)
-   *
-   * Examples:
-   *
-   *     math.simplify.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
-   *     math.simplify.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
-   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
-   *
-   * @param {Node} node
-   *     The expression tree to be simplified
-   * @param {Object} scope with variables to be resolved
-   */
-  function resolve(node, scope) {
-    if (!scope) {
-      return node;
-    }
-
-    if (!(0, _map.isMap)(scope)) {
-      scope = (0, _map.createMap)(scope);
-    }
-
-    if ((0, _is.isSymbolNode)(node)) {
-      var value = scope.get(node.name);
-
-      if ((0, _is.isNode)(value)) {
-        return resolve(value, scope);
-      } else if (typeof value === 'number') {
-        return parse(String(value));
-      }
-    } else if ((0, _is.isOperatorNode)(node)) {
-      var args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-      return new OperatorNode(node.op, node.fn, args, node.implicit);
-    } else if ((0, _is.isParenthesisNode)(node)) {
-      return new ParenthesisNode(resolve(node.content, scope));
-    } else if ((0, _is.isFunctionNode)(node)) {
-      var _args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-
-      return new FunctionNode(node.name, _args);
-    }
-
-    return node;
-  }
-
-  return resolve;
-});
-exports.createResolve = createResolve;

package/lib/esm/function/algebra/simplify/resolve.js

@@ -1,67 +0,0 @@
-import { createMap, isMap } from '../../../utils/map.js';
-import { isFunctionNode, isNode, isOperatorNode, isParenthesisNode, isSymbolNode } from '../../../utils/is.js';
-import { factory } from '../../../utils/factory.js';
-var name = 'resolve';
-var dependencies = ['parse', 'FunctionNode', 'OperatorNode', 'ParenthesisNode'];
-export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
-  var {
-    parse,
-    FunctionNode,
-    OperatorNode,
-    ParenthesisNode
-  } = _ref;
-
-  /**
-   * resolve(expr, scope) replaces variable nodes with their scoped values
-   *
-   * Syntax:
-   *
-   *     simplify.resolve(expr, scope)
-   *
-   * Examples:
-   *
-   *     math.simplify.resolve('x + y', {x:1, y:2})           // Node {1 + 2}
-   *     math.simplify.resolve(math.parse('x+y'), {x:1, y:2}) // Node {1 + 2}
-   *     math.simplify('x+y', {x:2, y:'x+x'}).toString()      // "6"
-   *
-   * @param {Node} node
-   *     The expression tree to be simplified
-   * @param {Object} scope with variables to be resolved
-   */
-  function resolve(node, scope) {
-    if (!scope) {
-      return node;
-    }
-
-    if (!isMap(scope)) {
-      scope = createMap(scope);
-    }
-
-    if (isSymbolNode(node)) {
-      var value = scope.get(node.name);
-
-      if (isNode(value)) {
-        return resolve(value, scope);
-      } else if (typeof value === 'number') {
-        return parse(String(value));
-      }
-    } else if (isOperatorNode(node)) {
-      var args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-      return new OperatorNode(node.op, node.fn, args, node.implicit);
-    } else if (isParenthesisNode(node)) {
-      return new ParenthesisNode(resolve(node.content, scope));
-    } else if (isFunctionNode(node)) {
-      var _args = node.args.map(function (arg) {
-        return resolve(arg, scope);
-      });
-
-      return new FunctionNode(node.name, _args);
-    }
-
-    return node;
-  }
-
-  return resolve;
-});