mathjs 10.1.0 → 10.3.0

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

@@ -5,12 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createSimplifyCore = void 0;
 
-var _is = require("../../../utils/is.js");
+var _is = require("../../utils/is.js");
 
-var _factory = require("../../../utils/factory.js");
+var _util = require("./simplify/util.js");
+
+var _factory = require("../../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'];
 var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var equal = _ref.equal,
       isZero = _ref.isZero,
@@ -26,15 +28,18 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       IndexNode = _ref.IndexNode,
       ObjectNode = _ref.ObjectNode,
       OperatorNode = _ref.OperatorNode,
-      ParenthesisNode = _ref.ParenthesisNode;
+      ParenthesisNode = _ref.ParenthesisNode,
+      SymbolNode = _ref.SymbolNode;
   var node0 = new ConstantNode(0);
   var node1 = new ConstantNode(1);
 
-  function mapSimplifyCore(nodeArray) {
-    return nodeArray.map(simplifyCore).map(function (arg) {
-      return (0, _is.isParenthesisNode)(arg) ? arg.content : arg;
-    });
-  }
+  var _createUtil = (0, _util.createUtil)({
+    FunctionNode: FunctionNode,
+    OperatorNode: OperatorNode,
+    SymbolNode: SymbolNode
+  }),
+      hasProperty = _createUtil.hasProperty,
+      isCommutative = _createUtil.isCommutative;
   /**
    * simplifyCore() performs single pass simplification suitable for
    * applications requiring ultimate performance. In contrast, simplify()
@@ -43,31 +48,54 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    *
    * 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 ((0, _is.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 ((0, _is.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(function (c) {
+        ++childCount;
+
+        if (childCount === 1) {
+          simpChild = simplifyCore(c, options);
+        }
+      });
+
+      if (childCount === 1) {
+        return simpChild;
       }
+    }
+
+    if ((0, _is.isOperatorNode)(node) && node.isUnary()) {
+      var a0 = simplifyCore(node.args[0], options);
 
       if (node.op === '-') {
         // unary minus
@@ -82,9 +110,9 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         return new OperatorNode(node.op, node.fn, [a0]);
       }
     } else if ((0, _is.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 ((0, _is.isConstantNode)(_a)) {
@@ -120,7 +148,7 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
 
           if ((0, _is.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]);
@@ -141,7 +169,7 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             return node0;
           } else if (equal(a1.value, 1)) {
             return _a;
-          } else if ((0, _is.isOperatorNode)(_a) && _a.isBinary() && _a.op === node.op) {
+          } else if ((0, _is.isOperatorNode)(_a) && _a.isBinary() && _a.op === node.op && isCommutative(node, context)) {
             var a00 = _a.args[0];
 
             if ((0, _is.isConstantNode)(a00)) {
@@ -150,7 +178,11 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             }
           }
 
-          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);
@@ -186,33 +218,25 @@ var createSimplifyCore = /* #__PURE__ */(0, _factory.factory)(name, dependencies
 
         return new OperatorNode(node.op, node.fn, [_a, a1]);
       }
-    } else if ((0, _is.isParenthesisNode)(node)) {
-      var c = simplifyCore(node.content);
-
-      if ((0, _is.isParenthesisNode)(c) || (0, _is.isSymbolNode)(c) || (0, _is.isConstantNode)(c)) {
-        return c;
-      }
-
-      return new ParenthesisNode(c);
     } else if ((0, _is.isFunctionNode)(node)) {
-      return new FunctionNode(simplifyCore(node.fn), mapSimplifyCore(node.args));
+      return new FunctionNode(simplifyCore(node.fn), node.args.map(function (n) {
+        return simplifyCore(n, options);
+      }));
     } else if ((0, _is.isArrayNode)(node)) {
-      return new ArrayNode(mapSimplifyCore(node.items));
+      return new ArrayNode(node.items.map(function (n) {
+        return simplifyCore(n, options);
+      }));
     } else if ((0, _is.isAccessorNode)(node)) {
-      var obj = mapSimplifyCore(node.object);
-
-      if ((0, _is.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 ((0, _is.isIndexNode)(node)) {
-      return new IndexNode(mapSimplifyCore(node.dimensions));
+      return new IndexNode(node.dimensions.map(function (n) {
+        return simplifyCore(n, options);
+      }));
     } else if ((0, _is.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/cjs/function/algebra/solver/lsolveAll.js

@@ -107,7 +107,7 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          var bNew = (0, _toConsumableArray2.default)(b);
           bNew[i] = 1;
 
           for (var _j = i + 1; _j < columns; _j++) {
@@ -187,7 +187,7 @@ var createLsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          var bNew = (0, _toConsumableArray2.default)(b);
           bNew[i] = 1;
 
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {

package/lib/cjs/function/algebra/solver/usolveAll.js

@@ -107,7 +107,7 @@ var createUsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          var bNew = (0, _toConsumableArray2.default)(b);
           bNew[i] = 1;
 
           for (var _j = i - 1; _j >= 0; _j--) {
@@ -187,7 +187,7 @@ var createUsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
           }
         } else if (k === 0) {
           // singular row, RHS is zero
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          var bNew = (0, _toConsumableArray2.default)(b);
           bNew[i] = 1; // loop upper triangular
 
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {

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

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSymbolicEqual = void 0;
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'symbolicEqual';
+var dependencies = ['parse', 'simplify', 'typed', 'OperatorNode'];
+var createSymbolicEqual = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var parse = _ref.parse,
+      simplify = _ref.simplify,
+      typed = _ref.typed,
+      OperatorNode = _ref.OperatorNode;
+
+  /**
+   * 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 (0, _is.isConstantNode)(simplified) && !simplified.value;
+    }
+  });
+});
+exports.createSymbolicEqual = createSymbolicEqual;

package/lib/cjs/function/arithmetic/ceil.js

@@ -91,7 +91,7 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         return round(x, n);
       } else {
         var _$split = "".concat(x, "e").split('e'),
-            _$split2 = (0, _slicedToArray2["default"])(_$split, 2),
+            _$split2 = (0, _slicedToArray2.default)(_$split, 2),
             number = _$split2[0],
             exponent = _$split2[1];
 
@@ -99,7 +99,7 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
 
         var _$split3 = "".concat(result, "e").split('e');
 
-        var _$split4 = (0, _slicedToArray2["default"])(_$split3, 2);
+        var _$split4 = (0, _slicedToArray2.default)(_$split3, 2);
 
         number = _$split4[0];
         exponent = _$split4[1];
@@ -123,7 +123,7 @@ var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
         return round(x, n);
       } else {
-        return x.toDecimalPlaces(n.toNumber(), _decimal["default"].ROUND_CEIL);
+        return x.toDecimalPlaces(n.toNumber(), _decimal.default.ROUND_CEIL);
       }
     },
     Fraction: function Fraction(x) {

package/lib/cjs/function/arithmetic/floor.js

@@ -88,7 +88,7 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
         return round(x, n);
       } else {
         var _$split = "".concat(x, "e").split('e'),
-            _$split2 = (0, _slicedToArray2["default"])(_$split, 2),
+            _$split2 = (0, _slicedToArray2.default)(_$split, 2),
             number = _$split2[0],
             exponent = _$split2[1];
 
@@ -96,7 +96,7 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
         var _$split3 = "".concat(result, "e").split('e');
 
-        var _$split4 = (0, _slicedToArray2["default"])(_$split3, 2);
+        var _$split4 = (0, _slicedToArray2.default)(_$split3, 2);
 
         number = _$split4[0];
         exponent = _$split4[1];
@@ -120,7 +120,7 @@ var createFloor = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
       if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
         return round(x, n);
       } else {
-        return x.toDecimalPlaces(n.toNumber(), _decimal["default"].ROUND_FLOOR);
+        return x.toDecimalPlaces(n.toNumber(), _decimal.default.ROUND_FLOOR);
       }
     },
     Fraction: function Fraction(x) {

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

@@ -60,7 +60,7 @@ var createInvmod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     res = res.valueOf();
 
     var _res = res,
-        _res2 = (0, _slicedToArray2["default"])(_res, 2),
+        _res2 = (0, _slicedToArray2.default)(_res, 2),
         gcd = _res2[0],
         inv = _res2[1];
 

package/lib/cjs/function/arithmetic/norm.js

@@ -71,7 +71,7 @@ var createNorm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
       // norm(x) = abs(x)
       return x.abs();
     },
-    "boolean": function boolean(x) {
+    boolean: function boolean(x) {
       // norm(x) = abs(x)
       return Math.abs(x);
     },

package/lib/cjs/function/arithmetic/round.js

@@ -25,7 +25,7 @@ var _index = require("../../plain/number/index.js");
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 var NO_INT = 'Number of decimals in function round must be an integer';
 var name = 'round';

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

@@ -11,7 +11,7 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 
 var _object = require("../../../utils/object.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 
@@ -80,7 +80,7 @@ function createComplexEigs(_ref) {
 
     if (findVectors) {
       vectors = findEigenvectors(arr, N, C, values, prec, type);
-      vectors = matrixFromColumns.apply(void 0, (0, _toConsumableArray2["default"])(vectors));
+      vectors = matrixFromColumns.apply(void 0, (0, _toConsumableArray2.default)(vectors));
     }
 
     return {
@@ -100,8 +100,9 @@ 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
@@ -122,12 +123,13 @@ 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);
         }
@@ -136,7 +138,7 @@ 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);
@@ -360,7 +362,7 @@ function createComplexEigs(_ref) {
       } else if (n === 2 || smaller(abs(arr[n - 2][n - 3]), prec)) {
         lastConvergenceBefore = 0;
         var ll = eigenvalues2x2(arr[n - 2][n - 2], arr[n - 2][n - 1], arr[n - 1][n - 2], arr[n - 1][n - 1]);
-        lambdas.push.apply(lambdas, (0, _toConsumableArray2["default"])(ll)); // keep track of transformations
+        lambdas.push.apply(lambdas, (0, _toConsumableArray2.default)(ll)); // keep track of transformations
 
         if (findVectors) {
           Sdiag.unshift(jordanBase2x2(arr[n - 2][n - 2], arr[n - 2][n - 1], arr[n - 1][n - 2], arr[n - 1][n - 1], ll[0], ll[1], prec, type));
@@ -488,7 +490,7 @@ function createComplexEigs(_ref) {
         solutions.push(approxVec);
       }
 
-      vectors.push.apply(vectors, (0, _toConsumableArray2["default"])(solutions.map(function (v) {
+      vectors.push.apply(vectors, (0, _toConsumableArray2.default)(solutions.map(function (v) {
         return flatten(v);
       })));
     }
@@ -568,7 +570,7 @@ function createComplexEigs(_ref) {
     for (var i = 0; i < arr.length; i++) {
       var _arr$i;
 
-      (_arr$i = arr[i]).push.apply(_arr$i, (0, _toConsumableArray2["default"])(Array(N - arr[i].length).fill(0)));
+      (_arr$i = arr[i]).push.apply(_arr$i, (0, _toConsumableArray2.default)(Array(N - arr[i].length).fill(0)));
     } // add rows
 
 

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

@@ -15,8 +15,15 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
   var typed = _ref.typed;
 
   /**
-   * 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:
    *
@@ -28,15 +35,25 @@ var createMap = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
    *      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,
@@ -66,14 +83,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/cjs/function/matrix/matrixFromColumns.js

@@ -7,7 +7,7 @@ exports.createMatrixFromColumns = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 

package/lib/cjs/function/matrix/matrixFromRows.js

@@ -7,7 +7,7 @@ exports.createMatrixFromRows = void 0;
 
 var _factory = require("../../utils/factory.js");
 
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }