mathjs 12.4.3 → 13.0.1

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

@@ -1,12 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createGcd = void 0;
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _number = require("../../utils/number.js");
 var _factory = require("../../utils/factory.js");
 var _mod = require("./mod.js");
@@ -15,50 +12,50 @@ var _matAlgo04xSidSid = require("../../type/matrix/utils/matAlgo04xSidSid.js");
 var _matAlgo10xSids = require("../../type/matrix/utils/matAlgo10xSids.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 var _ArgumentsError = require("../../error/ArgumentsError.js");
-var name = 'gcd';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix', 'concat'];
-var gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
-var gcdManyTypesSignature = "".concat(gcdTypes, ", ").concat(gcdTypes, ", ...").concat(gcdTypes);
+const name = 'gcd';
+const dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix', 'concat'];
+const gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
+const gcdManyTypesSignature = `${gcdTypes}, ${gcdTypes}, ...${gcdTypes}`;
 function is1d(array) {
-  return !array.some(function (element) {
-    return Array.isArray(element);
-  });
+  return !array.some(element => Array.isArray(element));
 }
-var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    config = _ref.config,
-    round = _ref.round,
-    equalScalar = _ref.equalScalar,
-    zeros = _ref.zeros,
-    BigNumber = _ref.BigNumber,
-    DenseMatrix = _ref.DenseMatrix,
-    concat = _ref.concat;
-  var mod = (0, _mod.createMod)({
-    typed: typed,
-    config: config,
-    round: round,
-    matrix: matrix,
-    equalScalar: equalScalar,
-    zeros: zeros,
-    DenseMatrix: DenseMatrix,
-    concat: concat
+const createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    config,
+    round,
+    equalScalar,
+    zeros,
+    BigNumber,
+    DenseMatrix,
+    concat
+  } = _ref;
+  const mod = (0, _mod.createMod)({
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix,
+    concat
   });
-  var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
-    typed: typed
+  const matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
+    typed
   });
-  var matAlgo04xSidSid = (0, _matAlgo04xSidSid.createMatAlgo04xSidSid)({
-    typed: typed,
-    equalScalar: equalScalar
+  const matAlgo04xSidSid = (0, _matAlgo04xSidSid.createMatAlgo04xSidSid)({
+    typed,
+    equalScalar
   });
-  var matAlgo10xSids = (0, _matAlgo10xSids.createMatAlgo10xSids)({
-    typed: typed,
-    DenseMatrix: DenseMatrix
+  const matAlgo10xSids = (0, _matAlgo10xSids.createMatAlgo10xSids)({
+    typed,
+    DenseMatrix
   });
-  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
-    typed: typed,
-    matrix: matrix,
-    concat: concat
+  const matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed,
+    matrix,
+    concat
   });
 
   /**
@@ -89,36 +86,32 @@ var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, d
   return typed(name, {
     'number, number': _gcdNumber,
     'BigNumber, BigNumber': _gcdBigNumber,
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.gcd(y);
-    }
+    'Fraction, Fraction': (x, y) => x.gcd(y)
   }, matrixAlgorithmSuite({
     SS: matAlgo04xSidSid,
     DS: matAlgo01xDSid,
     Ss: matAlgo10xSids
-  }), (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, gcdManyTypesSignature, typed.referToSelf(function (self) {
-    return function (a, b, args) {
-      var res = self(a, b);
-      for (var i = 0; i < args.length; i++) {
+  }), {
+    [gcdManyTypesSignature]: typed.referToSelf(self => (a, b, args) => {
+      let res = self(a, b);
+      for (let i = 0; i < args.length; i++) {
         res = self(res, args[i]);
       }
       return res;
-    };
-  })), "Array", typed.referToSelf(function (self) {
-    return function (array) {
+    }),
+    Array: typed.referToSelf(self => array => {
       if (array.length === 1 && Array.isArray(array[0]) && is1d(array[0])) {
-        return self.apply(void 0, (0, _toConsumableArray2["default"])(array[0]));
+        return self(...array[0]);
       }
       if (is1d(array)) {
-        return self.apply(void 0, (0, _toConsumableArray2["default"])(array));
+        return self(...array);
       }
       throw new _ArgumentsError.ArgumentsError('gcd() supports only 1d matrices!');
-    };
-  })), "Matrix", typed.referToSelf(function (self) {
-    return function (matrix) {
+    }),
+    Matrix: typed.referToSelf(self => matrix => {
       return self(matrix.toArray());
-    };
-  })));
+    })
+  });
 
   /**
   * Calculate gcd for numbers
@@ -133,7 +126,7 @@ var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, d
     }
 
     // https://en.wikipedia.org/wiki/Euclidean_algorithm
-    var r;
+    let r;
     while (b !== 0) {
       r = mod(a, b);
       a = b;
@@ -155,9 +148,9 @@ var createGcd = exports.createGcd = /* #__PURE__ */(0, _factory.factory)(name, d
     }
 
     // https://en.wikipedia.org/wiki/Euclidean_algorithm
-    var zero = new BigNumber(0);
+    const zero = new BigNumber(0);
     while (!b.isZero()) {
-      var r = mod(a, b);
+      const r = mod(a, b);
       a = b;
       b = r;
     }

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

@@ -7,17 +7,19 @@ exports.createHypot = void 0;
 var _factory = require("../../utils/factory.js");
 var _array = require("../../utils/array.js");
 var _is = require("../../utils/is.js");
-var name = 'hypot';
-var dependencies = ['typed', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'sqrt', 'smaller', 'isPositive'];
-var createHypot = exports.createHypot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    abs = _ref.abs,
-    addScalar = _ref.addScalar,
-    divideScalar = _ref.divideScalar,
-    multiplyScalar = _ref.multiplyScalar,
-    sqrt = _ref.sqrt,
-    smaller = _ref.smaller,
-    isPositive = _ref.isPositive;
+const name = 'hypot';
+const dependencies = ['typed', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'sqrt', 'smaller', 'isPositive'];
+const createHypot = exports.createHypot = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    abs,
+    addScalar,
+    divideScalar,
+    multiplyScalar,
+    sqrt,
+    smaller,
+    isPositive
+  } = _ref;
   /**
    * Calculate the hypotenusa of a list with values. The hypotenusa is defined as:
    *
@@ -49,9 +51,7 @@ var createHypot = exports.createHypot = /* #__PURE__ */(0, _factory.factory)(nam
   return typed(name, {
     '... number | BigNumber': _hypot,
     Array: _hypot,
-    Matrix: function Matrix(M) {
-      return _hypot((0, _array.flatten)(M.toArray()));
-    }
+    Matrix: M => _hypot((0, _array.flatten)(M.toArray()))
   });
 
   /**
@@ -63,13 +63,13 @@ var createHypot = exports.createHypot = /* #__PURE__ */(0, _factory.factory)(nam
   function _hypot(args) {
     // code based on `hypot` from es6-shim:
     // https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1619-L1633
-    var result = 0;
-    var largest = 0;
-    for (var i = 0; i < args.length; i++) {
+    let result = 0;
+    let largest = 0;
+    for (let i = 0; i < args.length; i++) {
       if ((0, _is.isComplex)(args[i])) {
         throw new TypeError('Unexpected type of argument to hypot');
       }
-      var value = abs(args[i]);
+      const value = abs(args[i]);
       if (smaller(largest, value)) {
         result = multiplyScalar(result, multiplyScalar(divideScalar(largest, value), divideScalar(largest, value)));
         result = addScalar(result, 1);

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

@@ -1,24 +1,24 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createInvmod = void 0;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _factory = require("../../utils/factory.js");
-var name = 'invmod';
-var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
-var createInvmod = exports.createInvmod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    BigNumber = _ref.BigNumber,
-    xgcd = _ref.xgcd,
-    equal = _ref.equal,
-    smaller = _ref.smaller,
-    mod = _ref.mod,
-    add = _ref.add,
-    isInteger = _ref.isInteger;
+const name = 'invmod';
+const dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+const createInvmod = exports.createInvmod = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    BigNumber,
+    xgcd,
+    equal,
+    smaller,
+    mod,
+    add,
+    isInteger
+  } = _ref;
   /**
    * Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
    * See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
@@ -50,12 +50,9 @@ var createInvmod = exports.createInvmod = /* #__PURE__ */(0, _factory.factory)(n
     if (!isInteger(a) || !isInteger(b)) throw new Error('Parameters in function invmod must be integer numbers');
     a = mod(a, b);
     if (equal(b, 0)) throw new Error('Divisor must be non zero');
-    var res = xgcd(a, b);
+    let res = xgcd(a, b);
     res = res.valueOf();
-    var _res = res,
-      _res2 = (0, _slicedToArray2["default"])(_res, 2),
-      gcd = _res2[0],
-      inv = _res2[1];
+    let [gcd, inv] = res;
     if (!equal(gcd, BigNumber(1))) return NaN;
     inv = mod(inv, b);
     if (smaller(inv, BigNumber(0))) inv = add(inv, b);

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

@@ -10,40 +10,40 @@ var _matAlgo06xS0S = require("../../type/matrix/utils/matAlgo06xS0S0.js");
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 var _index = require("../../plain/number/index.js");
-var name = 'lcm';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'concat'];
-var createLcm = exports.createLcm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    equalScalar = _ref.equalScalar,
-    concat = _ref.concat;
-  var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
-    typed: typed,
-    equalScalar: equalScalar
+const name = 'lcm';
+const dependencies = ['typed', 'matrix', 'equalScalar', 'concat'];
+const createLcm = exports.createLcm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    equalScalar,
+    concat
+  } = _ref;
+  const matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
+    typed,
+    equalScalar
   });
-  var matAlgo06xS0S0 = (0, _matAlgo06xS0S.createMatAlgo06xS0S0)({
-    typed: typed,
-    equalScalar: equalScalar
+  const matAlgo06xS0S0 = (0, _matAlgo06xS0S.createMatAlgo06xS0S0)({
+    typed,
+    equalScalar
   });
-  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
-    typed: typed,
-    equalScalar: equalScalar
+  const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed,
+    equalScalar
   });
-  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
-    typed: typed,
-    matrix: matrix,
-    concat: concat
+  const matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed,
+    matrix,
+    concat
   });
-  var lcmTypes = 'number | BigNumber | Fraction | Matrix | Array';
-  var lcmManySignature = {};
-  lcmManySignature["".concat(lcmTypes, ", ").concat(lcmTypes, ", ...").concat(lcmTypes)] = typed.referToSelf(function (self) {
-    return function (a, b, args) {
-      var res = self(a, b);
-      for (var i = 0; i < args.length; i++) {
-        res = self(res, args[i]);
-      }
-      return res;
-    };
+  const lcmTypes = 'number | BigNumber | Fraction | Matrix | Array';
+  const lcmManySignature = {};
+  lcmManySignature[`${lcmTypes}, ${lcmTypes}, ...${lcmTypes}`] = typed.referToSelf(self => (a, b, args) => {
+    let res = self(a, b);
+    for (let i = 0; i < args.length; i++) {
+      res = self(res, args[i]);
+    }
+    return res;
   });
 
   /**
@@ -78,9 +78,7 @@ var createLcm = exports.createLcm = /* #__PURE__ */(0, _factory.factory)(name, d
   return typed(name, {
     'number, number': _index.lcmNumber,
     'BigNumber, BigNumber': _lcmBigNumber,
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.lcm(y);
-    }
+    'Fraction, Fraction': (x, y) => x.lcm(y)
   }, matrixAlgorithmSuite({
     SS: matAlgo06xS0S0,
     DS: matAlgo02xDS0,
@@ -107,9 +105,9 @@ var createLcm = exports.createLcm = /* #__PURE__ */(0, _factory.factory)(name, d
 
     // https://en.wikipedia.org/wiki/Euclidean_algorithm
     // evaluate lcm here inline to reduce overhead
-    var prod = a.times(b);
+    const prod = a.times(b);
     while (!b.isZero()) {
-      var t = b;
+      const t = b;
       b = a.mod(t);
       a = t;
     }

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

@@ -6,13 +6,15 @@ Object.defineProperty(exports, "__esModule", {
 exports.createLog = void 0;
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
-var name = 'log';
-var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
-var createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    divideScalar = _ref.divideScalar,
-    Complex = _ref.Complex;
+const name = 'log';
+const dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
+const createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    divideScalar,
+    Complex
+  } = _ref;
   /**
    * Calculate the logarithm of a value.
    *
@@ -49,7 +51,7 @@ var createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, d
    *            Returns the logarithm of `x`
    */
   return typed(name, {
-    number: function number(x) {
+    number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.logNumber)(x);
       } else {
@@ -57,10 +59,10 @@ var createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, d
         return new Complex(x, 0).log();
       }
     },
-    Complex: function Complex(x) {
+    Complex: function (x) {
       return x.log();
     },
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.ln();
       } else {
@@ -68,11 +70,9 @@ var createLog = exports.createLog = /* #__PURE__ */(0, _factory.factory)(name, d
         return new Complex(x.toNumber(), 0).log();
       }
     },
-    'any, any': typed.referToSelf(function (self) {
-      return function (x, base) {
-        // calculate logarithm for a specified base, log(x, base)
-        return divideScalar(self(x), self(base));
-      };
+    'any, any': typed.referToSelf(self => (x, base) => {
+      // calculate logarithm for a specified base, log(x, base)
+      return divideScalar(self(x), self(base));
     })
   });
 });

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

@@ -7,12 +7,14 @@ exports.createLog10 = void 0;
 var _factory = require("../../utils/factory.js");
 var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
-var name = 'log10';
-var dependencies = ['typed', 'config', 'Complex'];
-var createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    _Complex = _ref.Complex;
+const name = 'log10';
+const dependencies = ['typed', 'config', 'Complex'];
+const createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    Complex
+  } = _ref;
   /**
    * Calculate the 10-base logarithm of a value. This is the same as calculating `log(x, 10)`.
    *
@@ -39,29 +41,25 @@ var createLog10 = exports.createLog10 = /* #__PURE__ */(0, _factory.factory)(nam
    *            Returns the 10-base logarithm of `x`
    */
   return typed(name, {
-    number: function number(x) {
+    number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.log10Number)(x);
       } else {
         // negative value -> complex value computation
-        return new _Complex(x, 0).log().div(Math.LN10);
+        return new Complex(x, 0).log().div(Math.LN10);
       }
     },
-    Complex: function Complex(x) {
-      return new _Complex(x).log().div(Math.LN10);
+    Complex: function (x) {
+      return new Complex(x).log().div(Math.LN10);
     },
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.log();
       } else {
         // downgrade to number, return Complex valued result
-        return new _Complex(x.toNumber(), 0).log().div(Math.LN10);
+        return new Complex(x.toNumber(), 0).log().div(Math.LN10);
       }
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

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

@@ -7,14 +7,16 @@ exports.createLog1p = void 0;
 var _factory = require("../../utils/factory.js");
 var _collection = require("../../utils/collection.js");
 var _number = require("../../utils/number.js");
-var name = 'log1p';
-var dependencies = ['typed', 'config', 'divideScalar', 'log', 'Complex'];
-var createLog1p = exports.createLog1p = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    divideScalar = _ref.divideScalar,
-    log = _ref.log,
-    Complex = _ref.Complex;
+const name = 'log1p';
+const dependencies = ['typed', 'config', 'divideScalar', 'log', 'Complex'];
+const createLog1p = exports.createLog1p = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    divideScalar,
+    log,
+    Complex
+  } = _ref;
   /**
    * Calculate the logarithm of a `value+1`.
    *
@@ -47,7 +49,7 @@ var createLog1p = exports.createLog1p = /* #__PURE__ */(0, _factory.factory)(nam
    *            Returns the logarithm of `x+1`
    */
   return typed(name, {
-    number: function number(x) {
+    number: function (x) {
       if (x >= -1 || config.predictable) {
         return (0, _number.log1p)(x);
       } else {
@@ -56,8 +58,8 @@ var createLog1p = exports.createLog1p = /* #__PURE__ */(0, _factory.factory)(nam
       }
     },
     Complex: _log1pComplex,
-    BigNumber: function BigNumber(x) {
-      var y = x.plus(1);
+    BigNumber: function (x) {
+      const y = x.plus(1);
       if (!y.isNegative() || config.predictable) {
         return y.ln();
       } else {
@@ -65,16 +67,10 @@ var createLog1p = exports.createLog1p = /* #__PURE__ */(0, _factory.factory)(nam
         return _log1pComplex(new Complex(x.toNumber(), 0));
       }
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    }),
-    'any, any': typed.referToSelf(function (self) {
-      return function (x, base) {
-        // calculate logarithm for a specified base, log1p(x, base)
-        return divideScalar(self(x), log(base));
-      };
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self)),
+    'any, any': typed.referToSelf(self => (x, base) => {
+      // calculate logarithm for a specified base, log1p(x, base)
+      return divideScalar(self(x), log(base));
     })
   });
 
@@ -85,7 +81,7 @@ var createLog1p = exports.createLog1p = /* #__PURE__ */(0, _factory.factory)(nam
    * @private
    */
   function _log1pComplex(x) {
-    var xRe1p = x.re + 1;
+    const xRe1p = x.re + 1;
     return new Complex(Math.log(Math.sqrt(xRe1p * xRe1p + x.im * x.im)), Math.atan2(x.im, xRe1p));
   }
 });

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

@@ -7,12 +7,14 @@ exports.createLog2 = void 0;
 var _factory = require("../../utils/factory.js");
 var _collection = require("../../utils/collection.js");
 var _index = require("../../plain/number/index.js");
-var name = 'log2';
-var dependencies = ['typed', 'config', 'Complex'];
-var createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    Complex = _ref.Complex;
+const name = 'log2';
+const dependencies = ['typed', 'config', 'Complex'];
+const createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    Complex
+  } = _ref;
   /**
    * Calculate the 2-base of a value. This is the same as calculating `log(x, 2)`.
    *
@@ -39,7 +41,7 @@ var createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name,
    *            Returns the 2-base logarithm of `x`
    */
   return typed(name, {
-    number: function number(x) {
+    number: function (x) {
       if (x >= 0 || config.predictable) {
         return (0, _index.log2Number)(x);
       } else {
@@ -48,7 +50,7 @@ var createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name,
       }
     },
     Complex: _log2Complex,
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       if (!x.isNegative() || config.predictable) {
         return x.log(2);
       } else {
@@ -56,11 +58,7 @@ var createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name,
         return _log2Complex(new Complex(x.toNumber(), 0));
       }
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 
   /**
@@ -70,7 +68,7 @@ var createLog2 = exports.createLog2 = /* #__PURE__ */(0, _factory.factory)(name,
    * @private
    */
   function _log2Complex(x) {
-    var newX = Math.sqrt(x.re * x.re + x.im * x.im);
+    const newX = Math.sqrt(x.re * x.re + x.im * x.im);
     return new Complex(Math.log2 ? Math.log2(newX) : Math.log(newX) / Math.LN2, Math.atan2(x.im, x.re) / Math.LN2);
   }
 });