mathjs 10.6.4 → 11.1.0

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { expm1Number } from '../../plain/number/index.js';
 var name = 'expm1';
 var dependencies = ['typed', 'Complex'];
@@ -11,7 +10,10 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * Calculate the value of subtracting 1 from the exponential value.
-   * For matrices, the function is evaluated element wise.
+   * This function is more accurate than `math.exp(x)-1` when `x` is near 0
+   * To avoid ambiguity with the matrix exponential `expm`, this function
+   * does not operate on matrices; if you wish to apply it elementwise, see
+   * the examples.
    *
    * Syntax:
    *
@@ -21,9 +23,11 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    math.expm1(2)                      // returns number 6.38905609893065
    *    math.pow(math.e, 2) - 1            // returns number 6.3890560989306495
+   *    math.expm1(1e-8)                   // returns number 1.0000000050000001e-8
+   *    math.exp(1e-8) - 1                 // returns number 9.9999999392253e-9
    *    math.log(math.expm1(2) + 1)        // returns number 2
    *
-   *    math.expm1([1, 2, 3])
+   *    math.map([1, 2, 3], math.expm1)
    *    // returns Array [
    *    //   1.718281828459045,
    *    //   6.3890560989306495,
@@ -32,10 +36,10 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    * See also:
    *
-   *    exp, log, pow
+   *    exp, expm, log, pow
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x  A number or matrix to apply expm1
-   * @return {number | BigNumber | Complex | Array | Matrix} Exponent of `x`
+   * @param {number | BigNumber | Complex} x  A number or matrix to apply expm1
+   * @return {number | BigNumber | Complex} Exponential of `x`, minus one
    */
   return typed(name, {
     number: expm1Number,
@@ -45,9 +49,6 @@ export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
     },
     BigNumber: function BigNumber(x) {
       return x.exp().minus(1);
-    },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
     }
   });
 });

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

@@ -1,7 +1,7 @@
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'fix';
 var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor', 'equalScalar', 'zeros', 'DenseMatrix'];
 export var createFixNumber = /* #__PURE__ */factory(name, ['typed', 'ceil', 'floor'], _ref => {
@@ -30,11 +30,11 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     zeros,
     DenseMatrix
   } = _ref2;
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   var fixNumber = createFixNumber({
@@ -65,7 +65,7 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    const c = math.complex(3.22, -2.78)
    *    math.fix(c)                  // returns Complex 3 - 2i
-   *    math.fix(c, 1)               // returns Complex 3.2 - 2.7i
+   *    math.fix(c, 1)               // returns Complex 3.2 -2.7i
    *
    *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
    *    math.fix([3.2, 3.8, -4.7], 1)   // returns Array [3.2, 3.8, -4.7]
@@ -104,26 +104,26 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
       return x.s < 0 ? ceil(x, n) : floor(x, n);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
+    'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since fix(0) = 0
-      return deepMap(x, this, true);
-    },
-    'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(x, n) {
+      return deepMap(x, self, true);
+    }),
+    'Array | Matrix, number | BigNumber': typed.referToSelf(self => (x, n) => {
       // deep map collection, skip zeros since fix(0) = 0
-      return deepMap(x, i => this(i, n), true);
-    },
-    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
+      return deepMap(x, i => self(i, n), true);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (x, y) => {
       if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
 
       if (y.storage() === 'dense') {
-        return algorithm14(y, x, this, true);
+        return matAlgo14xDs(y, x, self, true);
       }
 
-      return algorithm12(y, x, this, true);
-    }
+      return matAlgo12xSfs(y, x, self, true);
+    })
   });
 });

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

@@ -3,9 +3,9 @@ import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
 import { nearlyEqual } from '../../utils/number.js';
 import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm12 } from '../../type/matrix/utils/algorithm12.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
 var name = 'floor';
 var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
 export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
@@ -44,15 +44,15 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     zeros,
     DenseMatrix
   } = _ref2;
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm12 = createAlgorithm12({
+  var matAlgo12xSfs = createMatAlgo12xSfs({
     typed,
     DenseMatrix
   });
-  var algorithm14 = createAlgorithm14({
+  var matAlgo14xDs = createMatAlgo14xDs({
     typed
   });
   var floorNumber = createFloorNumber({
@@ -83,7 +83,7 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
    *
    *    const c = math.complex(3.24, -2.71)
    *    math.floor(c)                 // returns Complex 3 - 3i
-   *    math.floor(c, 1)              // returns Complex 3.2 - 2.8i
+   *    math.floor(c, 1)              // returns Complex 3.2 -2.8i
    *
    *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
    *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
@@ -136,32 +136,32 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
     'Fraction, BigNumber': function FractionBigNumber(x, n) {
       return x.floor(n.toNumber());
     },
-    'Array | Matrix': function ArrayMatrix(x) {
+    'Array | Matrix': typed.referToSelf(self => x => {
       // deep map collection, skip zeros since floor(0) = 0
-      return deepMap(x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
+      return deepMap(x, self, true);
+    }),
+    'Array, number | BigNumber': typed.referToSelf(self => (x, n) => {
       // deep map collection, skip zeros since ceil(0) = 0
-      return deepMap(x, i => this(i, n), true);
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
+      return deepMap(x, i => self(i, n), true);
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo11xS0s(x, y, self, false);
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo14xDs(x, y, self, false);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
       // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (x, y) => {
       if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
 
       if (y.storage() === 'dense') {
-        return algorithm14(y, x, this, true);
+        return matAlgo14xDs(y, x, self, true);
       }
 
-      return algorithm12(y, x, this, true);
-    }
+      return matAlgo12xSfs(y, x, self, true);
+    })
   });
 });

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

@@ -1,9 +1,8 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm01 } from '../../type/matrix/utils/algorithm01.js';
-import { createAlgorithm04 } from '../../type/matrix/utils/algorithm04.js';
-import { createAlgorithm10 } from '../../type/matrix/utils/algorithm10.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
+import { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
+import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { gcdNumber } from '../../plain/number/index.js';
 var name = 'gcd';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'DenseMatrix'];
@@ -15,22 +14,31 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
     BigNumber,
     DenseMatrix
   } = _ref;
-  var algorithm01 = createAlgorithm01({
+  var matAlgo01xDSid = createMatAlgo01xDSid({
     typed
   });
-  var algorithm04 = createAlgorithm04({
+  var matAlgo04xSidSid = createMatAlgo04xSidSid({
     typed,
     equalScalar
   });
-  var algorithm10 = createAlgorithm10({
+  var matAlgo10xSids = createMatAlgo10xSids({
     typed,
     DenseMatrix
   });
-  var algorithm13 = createAlgorithm13({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
+  var gcdManySignature = {};
+  gcdManySignature["".concat(gcdTypes, ", ").concat(gcdTypes, ", ...").concat(gcdTypes)] = typed.referToSelf(self => (a, b, args) => {
+    var res = self(a, b);
+
+    for (var i = 0; i < args.length; i++) {
+      res = self(res, args[i]);
+    }
+
+    return res;
   });
   /**
    * Calculate the greatest common divisor for two or more values or arrays.
@@ -61,64 +69,12 @@ export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     'number, number': gcdNumber,
     'BigNumber, BigNumber': _gcdBigNumber,
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.gcd(y);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm04(x, y, this);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm01(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm01(x, y, this, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      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));
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm10(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | BigNumber, SparseMatrix': function numberBigNumberSparseMatrix(x, y) {
-      return algorithm10(y, x, this, true);
-    },
-    'number | BigNumber, DenseMatrix': function numberBigNumberDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | BigNumber, Array': function numberBigNumberArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    // TODO: need a smarter notation here
-    'Array | Matrix | number | BigNumber, Array | Matrix | number | BigNumber, ...Array | Matrix | number | BigNumber': function ArrayMatrixNumberBigNumberArrayMatrixNumberBigNumberArrayMatrixNumberBigNumber(a, b, args) {
-      var res = this(a, b);
-
-      for (var i = 0; i < args.length; i++) {
-        res = this(res, args[i]);
-      }
-
-      return res;
-    }
-  });
+    'Fraction, Fraction': (x, y) => x.gcd(y)
+  }, matrixAlgorithmSuite({
+    SS: matAlgo04xSidSid,
+    DS: matAlgo01xDSid,
+    Ss: matAlgo10xSids
+  }), gcdManySignature);
   /**
    * Calculate gcd for BigNumbers
    * @param {BigNumber} a

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

@@ -1,5 +1,6 @@
 import { factory } from '../../utils/factory.js';
 import { flatten } from '../../utils/array.js';
+import { isComplex } from '../../utils/is.js';
 var name = 'hypot';
 var dependencies = ['typed', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'sqrt', 'smaller', 'isPositive'];
 export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -44,12 +45,8 @@ export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
   return typed(name, {
     '... number | BigNumber': _hypot,
-    Array: function Array(x) {
-      return this.apply(this, flatten(x));
-    },
-    Matrix: function Matrix(x) {
-      return this.apply(this, flatten(x.toArray()));
-    }
+    Array: _hypot,
+    Matrix: M => _hypot(flatten(M.toArray()))
   });
   /**
    * Calculate the hypotenusa for an Array with values
@@ -65,6 +62,10 @@ export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
     var largest = 0;
 
     for (var i = 0; i < args.length; i++) {
+      if (isComplex(args[i])) {
+        throw new TypeError('Unexpected type of argument to hypot');
+      }
+
       var value = abs(args[i]);
 
       if (smaller(largest, value)) {

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

@@ -25,7 +25,7 @@ export var createInvmod = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Examples:
    *
    *    math.invmod(8, 12)             // returns NaN
-   *    math.invmod(7, 13)             // return 2
+   *    math.invmod(7, 13)             // returns 2
    *    math.invmod(15151, 15122)      // returns 10429
    *
    * See also:

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

@@ -1,9 +1,8 @@
 import { factory } from '../../utils/factory.js';
-import { createAlgorithm02 } from '../../type/matrix/utils/algorithm02.js';
-import { createAlgorithm06 } from '../../type/matrix/utils/algorithm06.js';
-import { createAlgorithm11 } from '../../type/matrix/utils/algorithm11.js';
-import { createAlgorithm13 } from '../../type/matrix/utils/algorithm13.js';
-import { createAlgorithm14 } from '../../type/matrix/utils/algorithm14.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo06xS0S0 } from '../../type/matrix/utils/matAlgo06xS0S0.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
 import { lcmNumber } from '../../plain/number/index.js';
 var name = 'lcm';
 var dependencies = ['typed', 'matrix', 'equalScalar'];
@@ -13,23 +12,32 @@ export var createLcm = /* #__PURE__ */factory(name, dependencies, _ref => {
     matrix,
     equalScalar
   } = _ref;
-  var algorithm02 = createAlgorithm02({
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
     typed,
     equalScalar
   });
-  var algorithm06 = createAlgorithm06({
+  var matAlgo06xS0S0 = createMatAlgo06xS0S0({
     typed,
     equalScalar
   });
-  var algorithm11 = createAlgorithm11({
+  var matAlgo11xS0s = createMatAlgo11xS0s({
     typed,
     equalScalar
   });
-  var algorithm13 = createAlgorithm13({
-    typed
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix
   });
-  var algorithm14 = createAlgorithm14({
-    typed
+  var lcmTypes = 'number | BigNumber | Fraction | Matrix | Array';
+  var lcmManySignature = {};
+  lcmManySignature["".concat(lcmTypes, ", ").concat(lcmTypes, ", ...").concat(lcmTypes)] = typed.referToSelf(self => (a, b, args) => {
+    var res = self(a, b);
+
+    for (var i = 0; i < args.length; i++) {
+      res = self(res, args[i]);
+    }
+
+    return res;
   });
   /**
    * Calculate the least common multiple for two or more values or arrays.
@@ -64,64 +72,12 @@ export var createLcm = /* #__PURE__ */factory(name, dependencies, _ref => {
   return typed(name, {
     'number, number': lcmNumber,
     'BigNumber, BigNumber': _lcmBigNumber,
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.lcm(y);
-    },
-    'SparseMatrix, SparseMatrix': function SparseMatrixSparseMatrix(x, y) {
-      return algorithm06(x, y, this);
-    },
-    'SparseMatrix, DenseMatrix': function SparseMatrixDenseMatrix(x, y) {
-      return algorithm02(y, x, this, true);
-    },
-    'DenseMatrix, SparseMatrix': function DenseMatrixSparseMatrix(x, y) {
-      return algorithm02(x, y, this, false);
-    },
-    'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
-      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));
-    },
-    'SparseMatrix, number | BigNumber': function SparseMatrixNumberBigNumber(x, y) {
-      return algorithm11(x, y, this, false);
-    },
-    'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
-      return algorithm14(x, y, this, false);
-    },
-    'number | BigNumber, SparseMatrix': function numberBigNumberSparseMatrix(x, y) {
-      return algorithm11(y, x, this, true);
-    },
-    'number | BigNumber, DenseMatrix': function numberBigNumberDenseMatrix(x, y) {
-      return algorithm14(y, x, this, true);
-    },
-    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(x), y, this, false).valueOf();
-    },
-    'number | BigNumber, Array': function numberBigNumberArray(x, y) {
-      // use matrix implementation
-      return algorithm14(matrix(y), x, this, true).valueOf();
-    },
-    // TODO: need a smarter notation here
-    'Array | Matrix | number | BigNumber, Array | Matrix | number | BigNumber, ...Array | Matrix | number | BigNumber': function ArrayMatrixNumberBigNumberArrayMatrixNumberBigNumberArrayMatrixNumberBigNumber(a, b, args) {
-      var res = this(a, b);
-
-      for (var i = 0; i < args.length; i++) {
-        res = this(res, args[i]);
-      }
-
-      return res;
-    }
-  });
+    'Fraction, Fraction': (x, y) => x.lcm(y)
+  }, matrixAlgorithmSuite({
+    SS: matAlgo06xS0S0,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }), lcmManySignature);
   /**
    * Calculate lcm for two BigNumbers
    * @param {BigNumber} a

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

@@ -1,5 +1,4 @@
 import { factory } from '../../utils/factory.js';
-import { deepMap } from '../../utils/collection.js';
 import { logNumber } from '../../plain/number/index.js';
 var name = 'log';
 var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
@@ -14,7 +13,8 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Calculate the logarithm of a value.
    *
-   * For matrices, the function is evaluated element wise.
+   * To avoid confusion with the matrix logarithm, this function does not
+   * apply to matrices.
    *
    * Syntax:
    *
@@ -37,12 +37,12 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *    exp, log2, log10, log1p
    *
-   * @param {number | BigNumber | Complex | Array | Matrix} x
+   * @param {number | BigNumber | Complex} x
    *            Value for which to calculate the logarithm.
    * @param {number | BigNumber | Complex} [base=e]
    *            Optional base for the logarithm. If not provided, the natural
    *            logarithm of `x` is calculated.
-   * @return {number | BigNumber | Complex | Array | Matrix}
+   * @return {number | BigNumber | Complex}
    *            Returns the logarithm of `x`
    */
   return typed(name, {
@@ -65,12 +65,9 @@ export var createLog = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new Complex(x.toNumber(), 0).log();
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    },
-    'any, any': function anyAny(x, base) {
+    'any, any': typed.referToSelf(self => (x, base) => {
       // calculate logarithm for a specified base, log(x, base)
-      return divideScalar(this(x), this(base));
-    }
+      return divideScalar(self(x), self(base));
+    })
   });
 });

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

@@ -55,8 +55,6 @@ export var createLog10 = /* #__PURE__ */factory(name, dependencies, _ref => {
         return new _Complex(x.toNumber(), 0).log().div(Math.LN10);
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
 });

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

@@ -63,13 +63,11 @@ export var createLog1p = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _log1pComplex(new Complex(x.toNumber(), 0));
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    },
-    'any, any': function anyAny(x, base) {
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self)),
+    'any, any': typed.referToSelf(self => (x, base) => {
       // calculate logarithm for a specified base, log1p(x, base)
-      return divideScalar(this(x), log(base));
-    }
+      return divideScalar(self(x), log(base));
+    })
   });
   /**
    * Calculate the natural logarithm of a complex number + 1

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

@@ -53,9 +53,7 @@ export var createLog2 = /* #__PURE__ */factory(name, dependencies, _ref => {
         return _log2Complex(new Complex(x.toNumber(), 0));
       }
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return deepMap(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))
   });
   /**
    * Calculate log2 for a complex value