mathjs 10.1.0 → 10.3.0

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

@@ -1,7 +1,8 @@
-import { isAccessorNode, isArrayNode, isConstantNode, isFunctionNode, isIndexNode, isObjectNode, 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', 'AccessorNode', 'ArrayNode', 'ConstantNode', 'FunctionNode', 'IndexNode', 'ObjectNode', 'OperatorNode', '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,
@@ -18,16 +19,19 @@ export var createSimplifyCore = /* #__PURE__ */factory(name, dependencies, _ref
     IndexNode,
     ObjectNode,
     OperatorNode,
-    ParenthesisNode
+    ParenthesisNode,
+    SymbolNode
   } = _ref;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
-
-  function mapSimplifyCore(nodeArray) {
-    return nodeArray.map(simplifyCore).map(function (arg) {
-      return isParenthesisNode(arg) ? arg.content : arg;
-    });
-  }
+  var {
+    hasProperty,
+    isCommutative
+  } = createUtil({
+    FunctionNode,
+    OperatorNode,
+    SymbolNode
+  });
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -36,31 +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, options) {
+    var context = options ? options.context : undefined;
 
-  function simplifyCore(node) {
-    if (isOperatorNode(node) && node.isUnary()) {
-      var a0 = simplifyCore(node.args[0]);
+    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
 
-      if (node.op === '+') {
-        // unary plus
-        return a0;
+
+      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
@@ -75,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)) {
@@ -113,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]);
@@ -134,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)) {
@@ -143,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);
@@ -179,33 +209,19 @@ 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;
-      }
-
-      return new ParenthesisNode(c);
     } else if (isFunctionNode(node)) {
-      return new FunctionNode(simplifyCore(node.fn), mapSimplifyCore(node.args));
+      return new FunctionNode(simplifyCore(node.fn), node.args.map(n => simplifyCore(n, options)));
     } else if (isArrayNode(node)) {
-      return new ArrayNode(mapSimplifyCore(node.items));
+      return new ArrayNode(node.items.map(n => simplifyCore(n, options)));
     } else if (isAccessorNode(node)) {
-      var obj = mapSimplifyCore(node.object);
-
-      if (isParenthesisNode(obj)) {
-        obj = obj.content;
-      }
-
-      return new AccessorNode(obj, simplifyCore(node.index));
+      return new AccessorNode(simplifyCore(node.object, options), simplifyCore(node.index, options));
     } else if (isIndexNode(node)) {
-      return new IndexNode(mapSimplifyCore(node.dimensions));
+      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]);
+        newProps[prop] = simplifyCore(node.properties[prop], options);
       }
 
       return new ObjectNode(newProps);

package/lib/esm/function/algebra/symbolicEqual.js

@@ -0,0 +1,80 @@
+import { isConstantNode } from '../../utils/is.js';
+import { factory } from '../../utils/factory.js';
+var name = 'symbolicEqual';
+var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+export var createSymbolicEqual = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    parse,
+    simplify,
+    typed,
+    OperatorNode
+  } = _ref;
+
+  /**
+   * Attempts to determine if two expressions are symbolically equal, i.e.
+   * one is the result of valid algebraic manipulations on the other.
+   * Currently, this simply checks if the difference of the two expressions
+   * simplifies down to 0. So there are two important caveats:
+   * 1. whether two expressions are symbolically equal depends on the
+   *     manipulations allowed. Therefore, this function takes an optional
+   *     third argument, which are the options that control the behavior
+   *     as documented for the `simplify()` function.
+   * 2. it is in general intractable to find the minimal simplification of
+   *     an arbitrarily complicated expression. So while a `true` value
+   *     of `symbolicEqual` ensures that the two expressions can be manipulated
+   *     to match each other, a `false` value does not absolutely rule this out.
+   *
+   * Syntax:
+   *
+   *    symbolicEqual(expr1, expr2)
+   *    symbolicEqual(expr1, expr2, options)
+   *
+   * Examples:
+   *
+   *    symbolicEqual('x*y', 'y*x') // true
+   *    symbolicEqual('x*y', 'y*x', {context: {multiply: {commutative: false}}})
+   *        //false
+   *    symbolicEqual('x/y', '(y*x^(-1))^(-1)') // true
+   *    symbolicEqual('abs(x)','x') // false
+   *    symbolicEqual('abs(x)','x', simplify.positiveContext) // true
+   *
+   * See also:
+   *
+   *    simplify, evaluate
+   *
+   * @param {Node|string} expr1  The first expression to compare
+   * @param {Node|string} expr2  The second expression to compare
+   * @param {Object} [options] Optional option object, passed to simplify
+   * @returns {boolean}
+   *     Returns true if a valid manipulation making the expressions equal
+   *     is found.
+   */
+  return typed(name, {
+    'string, string': function stringString(s1, s2) {
+      return this(parse(s1), parse(s2), {});
+    },
+    'string, string, Object': function stringStringObject(s1, s2, options) {
+      return this(parse(s1), parse(s2), options);
+    },
+    'Node, string': function NodeString(e1, s2) {
+      return this(e1, parse(s2), {});
+    },
+    'Node, string, Object': function NodeStringObject(e1, s2, options) {
+      return this(e1, parse(s2), options);
+    },
+    'string, Node': function stringNode(s1, e2) {
+      return this(parse(s1), e2, {});
+    },
+    'string, Node, Object': function stringNodeObject(s1, e2, options) {
+      return this(parse(s1), e2, options);
+    },
+    'Node, Node': function NodeNode(e1, e2) {
+      return this(e1, e2, {});
+    },
+    'Node, Node, Object': function NodeNodeObject(e1, e2, options) {
+      var diff = new OperatorNode('-', 'subtract', [e1, e2]);
+      var simplified = simplify(diff, {}, options);
+      return isConstantNode(simplified) && !simplified.value;
+    }
+  });
+});

package/lib/esm/function/matrix/eigs/complexEigs.js

@@ -84,8 +84,9 @@ export function createComplexEigs(_ref) {
   function balance(arr, N, prec, type, findVectors) {
     var big = type === 'BigNumber';
     var cplx = type === 'Complex';
-    var zero = big ? bignumber(0) : cplx ? complex(0) : 0;
-    var one = big ? bignumber(1) : cplx ? complex(1) : 1; // base of the floating-point arithmetic
+    var realzero = big ? bignumber(0) : 0;
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1;
+    var realone = big ? bignumber(1) : 1; // base of the floating-point arithmetic
 
     var radix = big ? bignumber(10) : 2;
     var radixSq = multiplyScalar(radix, radix); // the diagonal transformation matrix R
@@ -106,12 +107,13 @@ export function createComplexEigs(_ref) {
       for (var i = 0; i < N; i++) {
         // compute the taxicab norm of i-th column and row
         // TODO optimize for complex numbers
-        var colNorm = zero;
-        var rowNorm = zero;
+        var colNorm = realzero;
+        var rowNorm = realzero;
 
         for (var j = 0; j < N; j++) {
           if (i === j) continue;
-          var c = abs(arr[i][j]);
+          var c = abs(arr[i][j]); // should be real
+
           colNorm = addScalar(colNorm, c);
           rowNorm = addScalar(rowNorm, c);
         }
@@ -120,7 +122,7 @@ export function createComplexEigs(_ref) {
           // find integer power closest to balancing the matrix
           // (we want to scale only by integer powers of radix,
           // so that we don't lose any precision due to round-off)
-          var f = one;
+          var f = realone;
           var _c = colNorm;
           var rowDivRadix = divideScalar(rowNorm, radix);
           var rowMulRadix = multiplyScalar(rowNorm, radix);

package/lib/esm/function/matrix/map.js

@@ -8,8 +8,15 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * Create a new matrix or array with the results of the callback function executed on
-   * each entry of the matrix/array.
+   * Create a new matrix or array with the results of a callback function executed on
+   * each entry of a given matrix/array.
+   *
+   * For each entry of the input, the callback is invoked with three arguments:
+   * the value of the entry, the index at which that entry occurs, and the full
+   * matrix/array being traversed. Note that because the matrix/array might be
+   * multidimensional, the "index" argument is always an array of numbers giving
+   * the index in each dimension. This is true even for vectors: the "index"
+   * argument is an array of length 1, rather than simply a number.
    *
    * Syntax:
    *
@@ -21,15 +28,25 @@ export var createMap = /* #__PURE__ */factory(name, dependencies, _ref => {
    *      return value * value
    *    })  // returns [1, 4, 9]
    *
+   *    // The calling convention for the callback can cause subtleties:
+   *    math.map([1, 2, 3], math.format)
+   *    // throws TypeError: map attempted to call 'format(1,[0])' but argument 2 of type Array does not match expected type number or function or Object or string or boolean
+   *    // [This happens because `format` _can_ take a second argument,
+   *    // but its semantics don't match that of the 2nd argument `map` provides]
+   *
+   *    // To avoid this error, use a function that takes exactly the
+   *    // desired arguments:
+   *    math.map([1, 2, 3], x => math.format(x)) // returns ['1', '2', '3']
+   *
    * See also:
    *
    *    filter, forEach, sort
    *
-   * @param {Matrix | Array} x    The matrix to iterate on.
-   * @param {Function} callback   The callback method is invoked with three
-   *                              parameters: the value of the element, the index
-   *                              of the element, and the matrix being traversed.
-   * @return {Matrix | array}     Transformed map of x
+   * @param {Matrix | Array} x    The input to iterate on.
+   * @param {Function} callback
+   *     The function to call (as described above) on each entry of the input
+   * @return {Matrix | array}
+   *     Transformed map of x; always has the same type and shape as x
    */
   return typed(name, {
     'Array, function': _map,
@@ -57,14 +74,35 @@ function _map(array, callback) {
         return recurse(child, index.concat(i));
       });
     } else {
-      // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        return callback(value);
-      } else if (args === 2) {
-        return callback(value, index);
-      } else {
-        // 3 or -1
-        return callback(value, index, array);
+      try {
+        // invoke the callback function with the right number of arguments
+        if (args === 1) {
+          return callback(value);
+        } else if (args === 2) {
+          return callback(value, index);
+        } else {
+          // 3 or -1
+          return callback(value, index, array);
+        }
+      } catch (err) {
+        // But maybe the arguments still weren't right
+        if (err instanceof TypeError && 'data' in err && err.data.category === 'wrongType') {
+          var newmsg = "map attempted to call '".concat(err.data.fn, "(").concat(value);
+          var indexString = JSON.stringify(index);
+
+          if (args === 2) {
+            newmsg += ',' + indexString;
+          } else if (args !== 1) {
+            newmsg += ",".concat(indexString, ",").concat(array);
+          }
+
+          newmsg += ")' but argument ".concat(err.data.index + 1, " of type ");
+          newmsg += "".concat(err.data.actual, " does not match expected type ");
+          newmsg += err.data.expected.join(' or ');
+          throw new TypeError(newmsg);
+        }
+
+        throw err;
       }
     }
   };

package/lib/esm/function/matrix/subset.js

@@ -28,16 +28,26 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *     // replace a subset
    *     const e = []
-   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]] and e = [[5, 0, 6]]
    *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
    *
+   *     // get submatrix using ranges
+   *     const M = [
+   *       [1,2,3],
+   *       [4,5,6],
+   *       [7,8,9]
+   *     ]
+   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1,2,3],[4,5,6]]
+   *
    * See also:
    *
    *     size, resize, squeeze, index
    *
    * @param {Array | Matrix | string} matrix  An array, matrix, or string
-   * @param {Index} index                     An index containing ranges for each
-   *                                          dimension
+   * @param {Index} index
+   *    For each dimension of the target, specifies an index or a list of
+   *    indices to fetch or set. `subset` uses the cartesian product of
+   *    the indices specified in each dimension.
    * @param {*} [replacement]                 An array, matrix, or scalar.
    *                                          If provided, the subset is replaced with replacement.
    *                                          If not provided, the subset is returned
@@ -80,7 +90,7 @@ export var createSubset = /* #__PURE__ */factory(name, dependencies, _ref => {
 /**
  * Retrieve a subset of a string
  * @param {string} str            string from which to get a substring
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @returns {string} substring
  * @private
  */
@@ -109,7 +119,7 @@ function _getSubstring(str, index) {
 /**
  * Replace a substring in a string
  * @param {string} str            string to be replaced
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @param {string} replacement    Replacement string
  * @param {string} [defaultValue] Default value to be uses when resizing
  *                                the string. is ' ' by default

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.1.0'; // Note: This file is automatically generated when building math.js.
+export var version = '10.3.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.1.0",
+  "version": "10.3.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,7 +126,7 @@
     "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",
@@ -161,5 +163,8 @@
     "src": "./src",
     "test": "./test"
   },
+  "browserslist": [
+    "IE 11"
+  ],
   "sideEffects": false
 }