mathjs 10.6.2 → 11.0.0

package/lib/esm/function/trigonometry/sinh.js

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { sinhNumber } from '../../plain/number/index.js';
 var name = 'sinh';
 var dependencies = ['typed'];
@@ -12,7 +11,8 @@ export var createSinh = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Calculate the hyperbolic sine of a value,
    * defined as `sinh(x) = 1/2 * (exp(x) - exp(-x))`.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix hyperbolic sine, this function does
+   * not apply to matrices.
    *
    * Syntax:
    *
@@ -26,27 +26,11 @@ export var createSinh = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    cosh, tanh
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
-   * @return {number | BigNumber | Complex | Array | Matrix} Hyperbolic sine of x
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic sine of x
    */
   return typed(name, {
     number: sinhNumber,
-    Complex: function Complex(x) {
-      return x.sinh();
-    },
-    BigNumber: function BigNumber(x) {
-      return x.sinh();
-    },
-    Unit: function Unit(x) {
-      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
-        throw new TypeError('Unit in function sinh is no angle');
-      }
-
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since sinh(0) = 0
-      return deepMap(x, this, true);
-    }
+    'Complex | BigNumber': x => x.sinh()
   });
 });

package/lib/esm/function/trigonometry/tan.js

@@ -1,16 +1,19 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
+import { createTrigUnit } from './trigUnit.js';
 var name = 'tan';
 var dependencies = ['typed'];
 export var createTan = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed
   } = _ref;
-
+  var trigUnit = createTrigUnit({
+    typed
+  });
   /**
    * Calculate the tangent of a value. `tan(x)` is equal to `sin(x) / cos(x)`.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix tangent, this function does not apply
+   * to matrices.
    *
    * Syntax:
    *
@@ -27,27 +30,12 @@ export var createTan = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    atan, sin, cos
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
-   * @return {number | BigNumber | Complex | Array | Matrix} Tangent of x
+   * @param {number | BigNumber | Complex | Unit} x  Function input
+   * @return {number | BigNumber | Complex} Tangent of x
    */
+
   return typed(name, {
     number: Math.tan,
-    Complex: function Complex(x) {
-      return x.tan();
-    },
-    BigNumber: function BigNumber(x) {
-      return x.tan();
-    },
-    Unit: function Unit(x) {
-      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
-        throw new TypeError('Unit in function tan is no angle');
-      }
-
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since tan(0) = 0
-      return deepMap(x, this, true);
-    }
-  });
+    'Complex | BigNumber': x => x.tan()
+  }, trigUnit);
 });

package/lib/esm/function/trigonometry/tanh.js

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { tanh as _tanh } from '../../utils/number.js';
 var name = 'tanh';
 var dependencies = ['typed'];
@@ -12,7 +11,8 @@ export var createTanh = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Calculate the hyperbolic tangent of a value,
    * defined as `tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1)`.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with matrix hyperbolic tangent, this function does
+   * not apply to matrices.
    *
    * Syntax:
    *
@@ -29,27 +29,11 @@ export var createTanh = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    sinh, cosh, coth
    *
-   * @param {number | BigNumber | Complex | Unit | Array | Matrix} x  Function input
-   * @return {number | BigNumber | Complex | Array | Matrix} Hyperbolic tangent of x
+   * @param {number | BigNumber | Complex} x  Function input
+   * @return {number | BigNumber | Complex} Hyperbolic tangent of x
    */
   return typed('tanh', {
     number: _tanh,
-    Complex: function Complex(x) {
-      return x.tanh();
-    },
-    BigNumber: function BigNumber(x) {
-      return x.tanh();
-    },
-    Unit: function Unit(x) {
-      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
-        throw new TypeError('Unit in function tanh is no angle');
-      }
-
-      return this(x.value);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      // deep map collection, skip zeros since tanh(0) = 0
-      return deepMap(x, this, true);
-    }
+    'Complex | BigNumber': x => x.tanh()
   });
 });

package/lib/esm/function/trigonometry/trigUnit.js

@@ -0,0 +1,15 @@
+import { factory } from '../../utils/factory.js';
+export var createTrigUnit = /* #__PURE__ */factory('trigUnit', ['typed'], _ref => {
+  var {
+    typed
+  } = _ref;
+  return {
+    Unit: typed.referToSelf(self => x => {
+      if (!x.hasBase(x.constructor.BASE_UNITS.ANGLE)) {
+        throw new TypeError('Unit in function cot is no angle');
+      }
+
+      return typed.find(self, x.valueType())(x.value);
+    })
+  };
+});

package/lib/esm/function/unit/to.js

@@ -1,6 +1,5 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 var name = 'to';
 var dependencies = ['typed', 'matrix'];
 export var createTo = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -8,11 +7,9 @@ export var createTo = /* #__PURE__ */factory(name, dependencies, _ref => {
     typed,
     matrix
   } = _ref;
-  var algorithm13 = createAlgorithm13({
-    typed
-  });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
   /**
    * Change the unit of a value.
@@ -40,40 +37,8 @@ export var createTo = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed(name, {
-    'Unit, Unit | string': function UnitUnitString(x, unit) {
-      return x.to(unit);
-    },
-    'Matrix, Matrix': function MatrixMatrix(x, y) {
-      // SparseMatrix does not support Units
-      return algorithm13(x, y, this);
-    },
-    'Array, Array': function ArrayArray(x, y) {
-      // use matrix implementation
-      return this(matrix(x), matrix(y)).valueOf();
-    },
-    'Array, Matrix': function ArrayMatrix(x, y) {
-      // use matrix implementation
-      return this(matrix(x), y);
-    },
-    'Matrix, Array': function MatrixArray(x, y) {
-      // use matrix implementation
-      return this(x, matrix(y));
-    },
-    'Matrix, any': function MatrixAny(x, y) {
-      // SparseMatrix does not support Units
-      return algorithm14(x, y, this, false);
-    },
-    'any, Matrix': function anyMatrix(x, y) {
-      // SparseMatrix does not support Units
-      return algorithm14(y, x, this, true);
-    },
-    'Array, any': function ArrayAny(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'any, Array': function anyArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    }
-  });
+    'Unit, Unit | string': (x, unit) => x.to(unit)
+  }, matrixAlgorithmSuite({
+    Ds: true
+  }));
 });

package/lib/esm/function/utils/hasNumericValue.js

@@ -25,6 +25,7 @@ export var createHasNumericValue = /* #__PURE__ */factory(name, dependencies, _r
    *    math.hasNumericValue(math.bignumber(500))   // returns true
    *    math.hasNumericValue(math.fraction(4))      // returns true
    *    math.hasNumericValue(math.complex('2-4i')   // returns false
+   *    math.hasNumericValue(false)                 // returns true
    *    math.hasNumericValue([2.3, 'foo', false])   // returns [true, false, true]
    *
    * See also:
@@ -37,6 +38,7 @@ export var createHasNumericValue = /* #__PURE__ */factory(name, dependencies, _r
    *                    Throws an error in case of unknown types.
    */
   return typed(name, {
+    boolean: () => true,
     string: function string(x) {
       return x.trim().length > 0 && !isNaN(Number(x));
     },

package/lib/esm/function/utils/isInteger.js

@@ -46,8 +46,6 @@ export var createIsInteger = /* #__PURE__ */factory(name, dependencies, _ref =>
     Fraction: function Fraction(x) {
       return x.d === 1 && isFinite(x.n);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -45,11 +45,7 @@ export var createIsNegative = /* #__PURE__ */factory(name, dependencies, _ref =>
     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 deepMap(x, this);
-    }
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -37,14 +37,8 @@ export var createIsNumeric = /* #__PURE__ */factory(name, dependencies, _ref =>
    *                    Throws an error in case of unknown types.
    */
   return typed(name, {
-    'number | BigNumber | Fraction | boolean': function numberBigNumberFractionBoolean() {
-      return true;
-    },
-    'Complex | Unit | string | null | undefined | Node': function ComplexUnitStringNullUndefinedNode() {
-      return false;
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'number | BigNumber | Fraction | boolean': () => true,
+    'Complex | Unit | string | null | undefined | Node': () => false,
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -47,11 +47,7 @@ export var createIsPositive = /* #__PURE__ */factory(name, dependencies, _ref =>
     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 deepMap(x, this);
-    }
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -135,8 +135,6 @@ export var createIsPrime = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       return true;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -52,11 +52,7 @@ export var createIsZero = /* #__PURE__ */factory(name, dependencies, _ref => {
     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 deepMap(x, this);
-    }
+    Unit: typed.referToSelf(self => x => typed.find(self, x.valueType())(x.value)),
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -30,12 +30,12 @@ export var createNumeric = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * 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:
    *
@@ -50,7 +50,14 @@ export var createNumeric = /* #__PURE__ */factory(name, dependencies, _ref => {
    *              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 = typeOf(value);
 
     if (!(inputType in validInputTypes)) {

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

@@ -8,46 +8,7 @@ export var createTypeOf = /* #__PURE__ */factory(name, dependencies, _ref => {
   } = _ref;
 
   /**
-   * 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:
    *
@@ -55,10 +16,43 @@ export var createTypeOf = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * 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/esm/type/bignumber/function/bignumber.js

@@ -75,8 +75,6 @@ export var createBignumber = /* #__PURE__ */factory(name, dependencies, _ref =>
     null: function _null(x) {
       return new BigNumber(0);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

package/lib/esm/type/boolean.js

@@ -69,8 +69,6 @@ export var createBoolean = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       throw new Error('Cannot convert "' + x + '" to a boolean');
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -3,11 +3,12 @@ import { format } from '../../utils/string.js';
 import { hasOwnProperty, lazy } from '../../utils/object.js';
 import { factory } from '../../utils/factory.js';
 var name = 'Chain';
-var dependencies = ['?on', 'math'];
+var dependencies = ['?on', 'math', 'typed'];
 export var createChainClass = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     on,
-    math
+    math,
+    typed
   } = _ref;
 
   /**
@@ -142,12 +143,31 @@ export var createChainClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
   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/esm/type/complex/Complex.js

@@ -8,6 +8,10 @@ export var createComplexClass = /* #__PURE__ */factory(name, dependencies, () =>
   /**
    * Attach type information
    */
+  Object.defineProperty(Complex, 'name', {
+    value: 'Complex'
+  });
+  Complex.prototype.constructor = Complex;
   Complex.prototype.type = 'Complex';
   Complex.prototype.isComplex = true;
   /**

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

@@ -83,8 +83,6 @@ export var createComplex = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       throw new Error('Expected object with properties (re and im) or (r and phi) or (abs and arg)');
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -6,6 +6,10 @@ export var createFractionClass = /* #__PURE__ */factory(name, dependencies, () =
   /**
    * Attach type information
    */
+  Object.defineProperty(Fraction, 'name', {
+    value: 'Fraction'
+  });
+  Fraction.prototype.constructor = Fraction;
   Fraction.prototype.type = 'Fraction';
   Fraction.prototype.isFraction = true;
   /**

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

@@ -71,8 +71,6 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
     Object: function Object(x) {
       return new Fraction(x);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -5,6 +5,7 @@ import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
+import { maxArgumentCount } from '../../utils/function.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -79,6 +80,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    */
 
 
+  Object.defineProperty(DenseMatrix, 'name', {
+    value: 'DenseMatrix'
+  });
+  DenseMatrix.prototype.constructor = DenseMatrix;
   DenseMatrix.prototype.type = 'DenseMatrix';
   DenseMatrix.prototype.isDenseMatrix = true;
   /**
@@ -576,6 +581,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     var me = this;
+    var args = maxArgumentCount(callback);
 
     var recurse = function recurse(value, index) {
       if (isArray(value)) {
@@ -583,7 +589,15 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
           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