mathjs 10.6.2 → 11.0.0

package/lib/cjs/function/utils/isNegative.js

@@ -53,12 +53,16 @@ var createIsNegative = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     Fraction: function Fraction(x) {
       return x.s < 0; // It's enough to decide on the sign
     },
-    Unit: function Unit(x) {
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsNegative = createIsNegative;

package/lib/cjs/function/utils/isNumeric.js

@@ -50,9 +50,11 @@ var createIsNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     'Complex | Unit | string | null | undefined | Node': function ComplexUnitStringNullUndefinedNode() {
       return false;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsNumeric = createIsNumeric;

package/lib/cjs/function/utils/isPositive.js

@@ -55,12 +55,16 @@ var createIsPositive = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     Fraction: function Fraction(x) {
       return x.s > 0 && x.n > 0;
     },
-    Unit: function Unit(x) {
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsPositive = createIsPositive;

package/lib/cjs/function/utils/isPrime.js

@@ -144,9 +144,11 @@ var createIsPrime = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
 
       return true;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsPrime = createIsPrime;

package/lib/cjs/function/utils/isZero.js

@@ -60,12 +60,16 @@ var createIsZero = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     Fraction: function Fraction(x) {
       return x.d === 1 && x.n === 0;
     },
-    Unit: function Unit(x) {
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        return typed.find(self, x.valueType())(x.value);
+      };
+    }),
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createIsZero = createIsZero;

package/lib/cjs/function/utils/numeric.js

@@ -44,12 +44,12 @@ var createNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *
    * Examples:
    *
-   *    math.numeric('4')                           // returns number 4
-   *    math.numeric('4', 'number')                 // returns number 4
+   *    math.numeric('4')                           // returns 4
+   *    math.numeric('4', 'number')                 // returns 4
    *    math.numeric('4', 'BigNumber')              // returns BigNumber 4
    *    math.numeric('4', 'Fraction')               // returns Fraction 4
    *    math.numeric(4, 'Fraction')                 // returns Fraction 4
-   *    math.numeric(math.fraction(2, 5), 'number') // returns number 0.4
+   *    math.numeric(math.fraction(2, 5), 'number') // returns 0.4
    *
    * See also:
    *
@@ -64,7 +64,14 @@ var createNumeric = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    *              Returns an instance of the numeric in the requested type
    */
 
-  return function numeric(value, outputType) {
+  return function numeric(value) {
+    var outputType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'number';
+    var check = arguments.length > 2 ? arguments[2] : undefined;
+
+    if (check !== undefined) {
+      throw new SyntaxError('numeric() takes one or two arguments');
+    }
+
     var inputType = (0, _is.typeOf)(value);
 
     if (!(inputType in validInputTypes)) {

package/lib/cjs/function/utils/typeOf.js

@@ -15,46 +15,7 @@ var createTypeOf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
   var typed = _ref.typed;
 
   /**
-   * Determine the type of a variable.
-   *
-   * Function `typeOf` recognizes the following types of objects:
-   *
-   * Object                 | Returns       | Example
-   * ---------------------- | ------------- | ------------------------------------------
-   * null                   | `'null'`      | `math.typeOf(null)`
-   * number                 | `'number'`    | `math.typeOf(3.5)`
-   * boolean                | `'boolean'`   | `math.typeOf(true)`
-   * string                 | `'string'`    | `math.typeOf('hello world')`
-   * Array                  | `'Array'`     | `math.typeOf([1, 2, 3])`
-   * Date                   | `'Date'`      | `math.typeOf(new Date())`
-   * Function               | `'Function'`  | `math.typeOf(function () {})`
-   * Object                 | `'Object'`    | `math.typeOf({a: 2, b: 3})`
-   * RegExp                 | `'RegExp'`    | `math.typeOf(/a regexp/)`
-   * undefined              | `'undefined'` | `math.typeOf(undefined)`
-   * math.BigNumber         | `'BigNumber'` | `math.typeOf(math.bignumber('2.3e500'))`
-   * math.Chain             | `'Chain'`     | `math.typeOf(math.chain(2))`
-   * math.Complex           | `'Complex'`   | `math.typeOf(math.complex(2, 3))`
-   * math.Fraction          | `'Fraction'`  | `math.typeOf(math.fraction(1, 3))`
-   * math.Help              | `'Help'`      | `math.typeOf(math.help('sqrt'))`
-   * math.Help              | `'Help'`      | `math.typeOf(math.help('sqrt'))`
-   * math.Index             | `'Index'`     | `math.typeOf(math.index(1, 3))`
-   * math.Matrix            | `'Matrix'`    | `math.typeOf(math.matrix([[1,2], [3, 4]]))`
-   * math.Range             | `'Range'`     | `math.typeOf(math.range(0, 10))`
-   * math.ResultSet         | `'ResultSet'` | `math.typeOf(math.evaluate('a=2\nb=3'))`
-   * math.Unit              | `'Unit'`      | `math.typeOf(math.unit('45 deg'))`
-   * math.AccessorNode            | `'AccessorNode'`            | `math.typeOf(math.parse('A[2]'))`
-   * math.ArrayNode               | `'ArrayNode'`               | `math.typeOf(math.parse('[1,2,3]'))`
-   * math.AssignmentNode          | `'AssignmentNode'`          | `math.typeOf(math.parse('x=2'))`
-   * math.BlockNode               | `'BlockNode'`               | `math.typeOf(math.parse('a=2; b=3'))`
-   * math.ConditionalNode         | `'ConditionalNode'`         | `math.typeOf(math.parse('x<0 ? -x : x'))`
-   * math.ConstantNode            | `'ConstantNode'`            | `math.typeOf(math.parse('2.3'))`
-   * math.FunctionAssignmentNode  | `'FunctionAssignmentNode'`  | `math.typeOf(math.parse('f(x)=x^2'))`
-   * math.FunctionNode            | `'FunctionNode'`            | `math.typeOf(math.parse('sqrt(4)'))`
-   * math.IndexNode               | `'IndexNode'`               | `math.typeOf(math.parse('A[2]').index)`
-   * math.ObjectNode              | `'ObjectNode'`              | `math.typeOf(math.parse('{a:2}'))`
-   * math.ParenthesisNode         | `'ParenthesisNode'`         | `math.typeOf(math.parse('(2+3)'))`
-   * math.RangeNode               | `'RangeNode'`               | `math.typeOf(math.parse('1:10'))`
-   * math.SymbolNode              | `'SymbolNode'`              | `math.typeOf(math.parse('x'))`
+   * Determine the type of an entity.
    *
    * Syntax:
    *
@@ -62,10 +23,43 @@ var createTypeOf = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    * Examples:
    *
-   *    math.typeOf(3.5)                     // returns 'number'
-   *    math.typeOf(math.complex('2-4i'))    // returns 'Complex'
-   *    math.typeOf(math.unit('45 deg'))     // returns 'Unit'
-   *    math.typeOf('hello world')           // returns 'string'
+   *    // This list is intended to include all relevant types, for testing
+   *    // purposes:
+   *    math.typeOf(3.5)                      // returns 'number'
+   *    math.typeOf(math.complex('2-4i'))     // returns 'Complex'
+   *    math.typeOf(math.unit('45 deg'))      // returns 'Unit'
+   *    math.typeOf('hello world')            // returns 'string'
+   *    math.typeOf(null)                     // returns 'null'
+   *    math.typeOf(true)                     // returns 'boolean'
+   *    math.typeOf([1, 2, 3])                // returns 'Array'
+   *    math.typeOf(new Date())               // returns 'Date'
+   *    math.typeOf(function () {})           // returns 'function'
+   *    math.typeOf({a: 2, b: 3})             // returns 'Object'
+   *    math.typeOf(/a regexp/)               // returns 'RegExp'
+   *    math.typeOf(undefined)                // returns 'undefined'
+   *    math.typeOf(math.bignumber('23e99'))  // returns 'BigNumber'
+   *    math.typeOf(math.chain(2))            // returns 'Chain'
+   *    math.typeOf(math.fraction(1, 3))      // returns 'Fraction'
+   *    math.typeOf(math.help('sqrt'))        // returns 'Help'
+   *    math.typeOf(math.index(1, 3))         // returns 'Index'
+   *    math.typeOf(math.matrix([[1],[3]]))   // returns 'DenseMatrix'
+   *    math.typeOf(math.matrix([],'sparse')) // returns 'SparseMatrix'
+   *    math.typeOf(new math.Range(0, 10))    // returns 'Range'
+   *    math.typeOf(math.evaluate('a=2\na'))  // returns 'ResultSet'
+   *    math.typeOf(math.parse('A[2]'))       // returns 'AccessorNode'
+   *    math.typeOf(math.parse('[1,2,3]'))    // returns 'ArrayNode'
+   *    math.typeOf(math.parse('x=2'))        // returns 'AssignmentNode'
+   *    math.typeOf(math.parse('a=2; b=3'))   // returns 'BlockNode'
+   *    math.typeOf(math.parse('x<0?-1:1'))   // returns 'ConditionalNode'
+   *    math.typeOf(math.parse('2.3'))        // returns 'ConstantNode'
+   *    math.typeOf(math.parse('f(x)=x^2'))   // returns 'FunctionAssignmentNode'
+   *    math.typeOf(math.parse('sqrt(4)'))    // returns 'FunctionNode'
+   *    math.typeOf(math.parse('A[2]').index) // returns 'IndexNode'
+   *    math.typeOf(math.parse('{a:2}'))      // returns 'ObjectNode'
+   *    math.typeOf(math.parse('(2+3)'))      // returns 'ParenthesisNode'
+   *    math.typeOf(math.parse('1:10'))       // returns 'RangeNode'
+   *    math.typeOf(math.parse('a<b<c'))      // returns 'RelationalNode'
+   *    math.typeOf(math.parse('x'))          // returns 'SymbolNode'
    *
    * @param {*} x     The variable for which to test the type.
    * @return {string} Returns the name of the type. Primitive types are lower case,

package/lib/cjs/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 10.6.2
- * @date    2022-06-24
+ * @version 11.0.0
+ * @date    2022-07-23
  *
  * @license
  * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>

package/lib/cjs/plain/bignumber/index.js

@@ -27,7 +27,7 @@ Object.keys(_arithmetic).forEach(function (key) {
 });
 
 // TODO: this is ugly. Instead, be able to pass your own isBigNumber function to typed?
-var BigNumber = _decimal.default.clone();
+var BigNumber = _decimal["default"].clone();
 
 BigNumber.prototype.isBigNumber = true;
 

package/lib/cjs/type/bignumber/BigNumber.js

@@ -17,9 +17,9 @@ var createBigNumberClass = /* #__PURE__ */(0, _factory.factory)(name, dependenci
   var on = _ref.on,
       config = _ref.config;
 
-  var BigNumber = _decimal.default.clone({
+  var BigNumber = _decimal["default"].clone({
     precision: config.precision,
-    modulo: _decimal.default.EUCLID
+    modulo: _decimal["default"].EUCLID
   });
 
   BigNumber.prototype = Object.create(BigNumber.prototype);

package/lib/cjs/type/bignumber/function/bignumber.js

@@ -79,12 +79,14 @@ var createBignumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     Fraction: function Fraction(x) {
       return new BigNumber(x.n).div(x.d).times(x.s);
     },
-    null: function _null(x) {
+    "null": function _null(x) {
       return new BigNumber(0);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createBignumber = createBignumber;

package/lib/cjs/type/boolean.js

@@ -45,13 +45,13 @@ var createBoolean = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
     '': function _() {
       return false;
     },
-    boolean: function boolean(x) {
+    "boolean": function boolean(x) {
       return x;
     },
     number: function number(x) {
       return !!x;
     },
-    null: function _null(x) {
+    "null": function _null(x) {
       return false;
     },
     BigNumber: function BigNumber(x) {
@@ -76,9 +76,11 @@ var createBoolean = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
 
       throw new Error('Cannot convert "' + x + '" to a boolean');
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createBoolean = createBoolean;

package/lib/cjs/type/chain/Chain.js

@@ -14,10 +14,11 @@ var _object = require("../../utils/object.js");
 var _factory = require("../../utils/factory.js");
 
 var name = 'Chain';
-var dependencies = ['?on', 'math'];
+var dependencies = ['?on', 'math', 'typed'];
 var createChainClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var on = _ref.on,
-      math = _ref.math;
+      math = _ref.math,
+      typed = _ref.typed;
 
   /**
    * @constructor Chain
@@ -151,12 +152,31 @@ var createChainClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
 
   function chainify(fn) {
     return function () {
-      var args = [this.value]; // `this` will be the context of a Chain instance
+      // Here, `this` will be the context of a Chain instance
+      if (arguments.length === 0) {
+        return new Chain(fn(this.value));
+      }
+
+      var args = [this.value];
 
       for (var i = 0; i < arguments.length; i++) {
         args[i + 1] = arguments[i];
       }
 
+      if (typed.isTypedFunction(fn)) {
+        var sigObject = typed.resolve(fn, args); // We want to detect if a rest parameter has matched across the
+        // value in the chain and the current arguments of this call.
+        // That is the case if and only if the matching signature has
+        // exactly one parameter (which then must be a rest parameter
+        // as it is matching at least two actual arguments).
+
+        if (sigObject.params.length === 1) {
+          throw new Error('chain function ' + fn.name + ' cannot match rest parameter between chain value and additional arguments.');
+        }
+
+        return new Chain(sigObject.implementation.apply(fn, args));
+      }
+
       return new Chain(fn.apply(fn, args));
     };
   }

package/lib/cjs/type/complex/Complex.js

@@ -23,15 +23,19 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
   /**
    * Attach type information
    */
-  _complex.default.prototype.type = 'Complex';
-  _complex.default.prototype.isComplex = true;
+  Object.defineProperty(_complex["default"], 'name', {
+    value: 'Complex'
+  });
+  _complex["default"].prototype.constructor = _complex["default"];
+  _complex["default"].prototype.type = 'Complex';
+  _complex["default"].prototype.isComplex = true;
   /**
    * Get a JSON representation of the complex number
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Complex", "re": 2, "im": 3}`
    */
 
-  _complex.default.prototype.toJSON = function () {
+  _complex["default"].prototype.toJSON = function () {
     return {
       mathjs: 'Complex',
       re: this.re,
@@ -45,7 +49,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex.default.prototype.toPolar = function () {
+  _complex["default"].prototype.toPolar = function () {
     return {
       r: this.abs(),
       phi: this.arg()
@@ -62,7 +66,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex.default.prototype.format = function (options) {
+  _complex["default"].prototype.format = function (options) {
     var str = '';
     var im = this.im;
     var re = this.re;
@@ -127,14 +131,14 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex.default.fromPolar = function (args) {
+  _complex["default"].fromPolar = function (args) {
     switch (arguments.length) {
       case 1:
         {
           var arg = arguments[0];
 
-          if ((0, _typeof2.default)(arg) === 'object') {
-            return (0, _complex.default)(arg);
+          if ((0, _typeof2["default"])(arg) === 'object') {
+            return (0, _complex["default"])(arg);
           } else {
             throw new TypeError('Input has to be an object with r and phi keys.');
           }
@@ -152,7 +156,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             }
 
             if ((0, _is.isNumber)(phi)) {
-              return new _complex.default({
+              return new _complex["default"]({
                 r: r,
                 phi: phi
               });
@@ -169,7 +173,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     }
   };
 
-  _complex.default.prototype.valueOf = _complex.default.prototype.toString;
+  _complex["default"].prototype.valueOf = _complex["default"].prototype.toString;
   /**
    * Create a Complex number from a JSON object
    * @param {Object} json  A JSON Object structured as
@@ -179,8 +183,8 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    * @return {Complex} Returns a new Complex number
    */
 
-  _complex.default.fromJSON = function (json) {
-    return new _complex.default(json);
+  _complex["default"].fromJSON = function (json) {
+    return new _complex["default"](json);
   };
   /**
    * Compare two complex numbers, `a` and `b`:
@@ -199,7 +203,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
 
 
-  _complex.default.compare = function (a, b) {
+  _complex["default"].compare = function (a, b) {
     if (a.re > b.re) {
       return 1;
     }
@@ -219,7 +223,7 @@ var createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     return 0;
   };
 
-  return _complex.default;
+  return _complex["default"];
 }, {
   isClass: true
 });

package/lib/cjs/type/complex/function/complex.js

@@ -76,7 +76,7 @@ var createComplex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
     string: function string(x) {
       return Complex(x); // for example '2 + 3i'
     },
-    null: function _null(x) {
+    "null": function _null(x) {
       return Complex(0);
     },
     Object: function Object(x) {
@@ -90,9 +90,11 @@ var createComplex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
 
       throw new Error('Expected object with properties (re and im) or (r and phi) or (abs and arg)');
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createComplex = createComplex;

package/lib/cjs/type/fraction/Fraction.js

@@ -17,15 +17,19 @@ var createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencie
   /**
    * Attach type information
    */
-  _fraction.default.prototype.type = 'Fraction';
-  _fraction.default.prototype.isFraction = true;
+  Object.defineProperty(_fraction["default"], 'name', {
+    value: 'Fraction'
+  });
+  _fraction["default"].prototype.constructor = _fraction["default"];
+  _fraction["default"].prototype.type = 'Fraction';
+  _fraction["default"].prototype.isFraction = true;
   /**
    * Get a JSON representation of a Fraction containing type information
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Fraction", "n": 3, "d": 8}`
    */
 
-  _fraction.default.prototype.toJSON = function () {
+  _fraction["default"].prototype.toJSON = function () {
     return {
       mathjs: 'Fraction',
       n: this.s * this.n,
@@ -40,11 +44,11 @@ var createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencie
    */
 
 
-  _fraction.default.fromJSON = function (json) {
-    return new _fraction.default(json);
+  _fraction["default"].fromJSON = function (json) {
+    return new _fraction["default"](json);
   };
 
-  return _fraction.default;
+  return _fraction["default"];
 }, {
   isClass: true
 });

package/lib/cjs/type/fraction/function/fraction.js

@@ -66,7 +66,7 @@ var createFraction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     'number, number': function numberNumber(numerator, denominator) {
       return new Fraction(numerator, denominator);
     },
-    null: function _null(x) {
+    "null": function _null(x) {
       return new Fraction(0);
     },
     BigNumber: function BigNumber(x) {
@@ -78,9 +78,11 @@ var createFraction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
     Object: function Object(x) {
       return new Fraction(x);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createFraction = createFraction;

package/lib/cjs/type/matrix/DenseMatrix.js

@@ -23,7 +23,9 @@ var _DimensionError = require("../../error/DimensionError.js");
 
 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; } } }; }
+var _function = require("../../utils/function.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 _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); }
 
@@ -101,6 +103,10 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
    */
 
 
+  Object.defineProperty(DenseMatrix, 'name', {
+    value: 'DenseMatrix'
+  });
+  DenseMatrix.prototype.constructor = DenseMatrix;
   DenseMatrix.prototype.type = 'DenseMatrix';
   DenseMatrix.prototype.isDenseMatrix = true;
   /**
@@ -600,6 +606,7 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     var me = this;
+    var args = (0, _function.maxArgumentCount)(callback);
 
     var recurse = function recurse(value, index) {
       if ((0, _is.isArray)(value)) {
@@ -607,7 +614,15 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
           return recurse(child, index.concat(i));
         });
       } else {
-        return callback(value, index, me);
+        // 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, me);
+        }
       }
     }; // determine the new datatype when the original matrix has datatype defined
     // TODO: should be done in matrix constructor instead
@@ -648,15 +663,15 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
    */
 
 
-  DenseMatrix.prototype[Symbol.iterator] = /*#__PURE__*/_regenerator.default.mark(function _callee() {
+  DenseMatrix.prototype[Symbol.iterator] = /*#__PURE__*/_regenerator["default"].mark(function _callee() {
     var recurse;
-    return _regenerator.default.wrap(function _callee$(_context2) {
+    return _regenerator["default"].wrap(function _callee$(_context2) {
       while (1) {
         switch (_context2.prev = _context2.next) {
           case 0:
-            recurse = /*#__PURE__*/_regenerator.default.mark(function recurse(value, index) {
+            recurse = /*#__PURE__*/_regenerator["default"].mark(function recurse(value, index) {
               var i;
-              return _regenerator.default.wrap(function recurse$(_context) {
+              return _regenerator["default"].wrap(function recurse$(_context) {
                 while (1) {
                   switch (_context.prev = _context.next) {
                     case 0: