mathjs 12.4.3 → 13.0.0

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createAddScalar = void 0;
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
-var name = 'addScalar';
-var dependencies = ['typed'];
-var createAddScalar = exports.createAddScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'addScalar';
+const dependencies = ['typed'];
+const createAddScalar = exports.createAddScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Add two scalar values, `x + y`.
    * This function is meant for internal use: it is used by the public function
@@ -17,36 +19,37 @@ var createAddScalar = exports.createAddScalar = /* #__PURE__ */(0, _factory.fact
    *
    * This function does not support collections (Array or Matrix).
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x   First value to add
-   * @param  {number | BigNumber | Fraction | Complex} y          Second value to add
-   * @return {number | BigNumber | Fraction | Complex | Unit}     Sum of `x` and `y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x   First value to add
+   * @param  {number | BigNumber | bigint | Fraction | Complex} y          Second value to add
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit}     Sum of `x` and `y`
    * @private
    */
   return typed(name, {
     'number, number': _index.addNumber,
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function (x, y) {
       return x.add(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function (x, y) {
       return x.plus(y);
     },
-    'Fraction, Fraction': function FractionFraction(x, y) {
+    'bigint, bigint': function (x, y) {
+      return x + y;
+    },
+    'Fraction, Fraction': function (x, y) {
       return x.add(y);
     },
-    'Unit, Unit': typed.referToSelf(function (self) {
-      return function (x, y) {
-        if (x.value === null || x.value === undefined) {
-          throw new Error('Parameter x contains a unit with undefined value');
-        }
-        if (y.value === null || y.value === undefined) {
-          throw new Error('Parameter y contains a unit with undefined value');
-        }
-        if (!x.equalBase(y)) throw new Error('Units do not match');
-        var res = x.clone();
-        res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
-        res.fixPrefix = false;
-        return res;
-      };
+    'Unit, Unit': typed.referToSelf(self => (x, y) => {
+      if (x.value === null || x.value === undefined) {
+        throw new Error('Parameter x contains a unit with undefined value');
+      }
+      if (y.value === null || y.value === undefined) {
+        throw new Error('Parameter y contains a unit with undefined value');
+      }
+      if (!x.equalBase(y)) throw new Error('Units do not match');
+      const res = x.clone();
+      res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
+      res.fixPrefix = false;
+      return res;
     })
   });
 });

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

@@ -7,17 +7,19 @@ exports.createCbrt = void 0;
 var _factory = require("../../utils/factory.js");
 var _is = require("../../utils/is.js");
 var _index = require("../../plain/number/index.js");
-var name = 'cbrt';
-var dependencies = ['config', 'typed', 'isNegative', 'unaryMinus', 'matrix', 'Complex', 'BigNumber', 'Fraction'];
-var createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var config = _ref.config,
-    typed = _ref.typed,
-    isNegative = _ref.isNegative,
-    unaryMinus = _ref.unaryMinus,
-    matrix = _ref.matrix,
-    Complex = _ref.Complex,
-    BigNumber = _ref.BigNumber,
-    Fraction = _ref.Fraction;
+const name = 'cbrt';
+const dependencies = ['config', 'typed', 'isNegative', 'unaryMinus', 'matrix', 'Complex', 'BigNumber', 'Fraction'];
+const createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    config,
+    typed,
+    isNegative,
+    unaryMinus,
+    matrix,
+    Complex,
+    BigNumber,
+    Fraction
+  } = _ref;
   /**
    * Calculate the cubic root of a value.
    *
@@ -66,7 +68,7 @@ var createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(name,
 
     Complex: _cbrtComplex,
     'Complex, boolean': _cbrtComplex,
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       return x.cbrt();
     },
     Unit: _cbrtUnit
@@ -84,13 +86,13 @@ var createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(name,
   function _cbrtComplex(x, allRoots) {
     // https://www.wikiwand.com/en/Cube_root#/Complex_numbers
 
-    var arg3 = x.arg() / 3;
-    var abs = x.abs();
+    const arg3 = x.arg() / 3;
+    const abs = x.abs();
 
     // principal root:
-    var principal = new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3).exp());
+    const principal = new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3).exp());
     if (allRoots) {
-      var all = [principal, new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3 + Math.PI * 2 / 3).exp()), new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3 - Math.PI * 2 / 3).exp())];
+      const all = [principal, new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3 + Math.PI * 2 / 3).exp()), new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3 - Math.PI * 2 / 3).exp())];
       return config.matrix === 'Array' ? all : matrix(all);
     } else {
       return principal;
@@ -105,19 +107,19 @@ var createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(name,
    */
   function _cbrtUnit(x) {
     if (x.value && (0, _is.isComplex)(x.value)) {
-      var result = x.clone();
+      let result = x.clone();
       result.value = 1.0;
       result = result.pow(1.0 / 3); // Compute the units
       result.value = _cbrtComplex(x.value); // Compute the value
       return result;
     } else {
-      var negate = isNegative(x.value);
+      const negate = isNegative(x.value);
       if (negate) {
         x.value = unaryMinus(x.value);
       }
 
       // TODO: create a helper function for this
-      var third;
+      let third;
       if ((0, _is.isBigNumber)(x.value)) {
         third = new BigNumber(1).div(3);
       } else if ((0, _is.isFraction)(x.value)) {
@@ -125,11 +127,11 @@ var createCbrt = exports.createCbrt = /* #__PURE__ */(0, _factory.factory)(name,
       } else {
         third = 1 / 3;
       }
-      var _result = x.pow(third);
+      const result = x.pow(third);
       if (negate) {
-        _result.value = unaryMinus(_result.value);
+        result.value = unaryMinus(result.value);
       }
-      return _result;
+      return result;
     }
   }
 });

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

@@ -5,7 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createCeilNumber = exports.createCeil = void 0;
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _decimal = _interopRequireDefault(require("decimal.js"));
 var _factory = require("../../utils/factory.js");
 var _collection = require("../../utils/collection.js");
@@ -14,61 +13,59 @@ var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
-var name = 'ceil';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
-var createCeilNumber = exports.createCeilNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', 'round'], function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    round = _ref.round;
+const name = 'ceil';
+const dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+const createCeilNumber = exports.createCeilNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', 'round'], _ref => {
+  let {
+    typed,
+    config,
+    round
+  } = _ref;
   return typed(name, {
-    number: function number(x) {
-      if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
+    number: function (x) {
+      if ((0, _number.nearlyEqual)(x, round(x), config.relTol, config.absTol)) {
         return round(x);
       } else {
         return Math.ceil(x);
       }
     },
-    'number, number': function numberNumber(x, n) {
-      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+    'number, number': function (x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
-        var _split = "".concat(x, "e").split('e'),
-          _split2 = (0, _slicedToArray2["default"])(_split, 2),
-          number = _split2[0],
-          exponent = _split2[1];
-        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        var _split3 = "".concat(result, "e").split('e');
-        var _split4 = (0, _slicedToArray2["default"])(_split3, 2);
-        number = _split4[0];
-        exponent = _split4[1];
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
+        let [number, exponent] = `${x}e`.split('e');
+        const result = Math.ceil(Number(`${number}e${Number(exponent) + n}`));
+        [number, exponent] = `${result}e`.split('e');
+        return Number(`${number}e${Number(exponent) - n}`);
       }
     }
   });
 });
-var createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref2) {
-  var typed = _ref2.typed,
-    config = _ref2.config,
-    round = _ref2.round,
-    matrix = _ref2.matrix,
-    equalScalar = _ref2.equalScalar,
-    zeros = _ref2.zeros,
-    DenseMatrix = _ref2.DenseMatrix;
-  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
-    typed: typed,
-    equalScalar: equalScalar
+const createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref2 => {
+  let {
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed,
+    equalScalar
   });
-  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
-    typed: typed,
-    DenseMatrix: DenseMatrix
+  const matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed,
+    DenseMatrix
   });
-  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
-    typed: typed
+  const matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed
   });
-  var ceilNumber = createCeilNumber({
-    typed: typed,
-    config: config,
-    round: round
+  const ceilNumber = createCeilNumber({
+    typed,
+    config,
+    round
   });
   /**
    * Round a value towards plus infinity
@@ -110,76 +107,62 @@ var createCeil = exports.createCeil = /* #__PURE__ */(0, _factory.factory)(name,
   return typed('ceil', {
     number: ceilNumber.signatures.number,
     'number,number': ceilNumber.signatures['number,number'],
-    Complex: function Complex(x) {
+    Complex: function (x) {
       return x.ceil();
     },
-    'Complex, number': function ComplexNumber(x, n) {
+    'Complex, number': function (x, n) {
       return x.ceil(n);
     },
-    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+    'Complex, BigNumber': function (x, n) {
       return x.ceil(n.toNumber());
     },
-    BigNumber: function BigNumber(x) {
-      if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
+    BigNumber: function (x) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.relTol, config.absTol)) {
         return round(x);
       } else {
         return x.ceil();
       }
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
-      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
+    'BigNumber, BigNumber': function (x, n) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.relTol, config.absTol)) {
         return round(x, n);
       } else {
-        return x.toDecimalPlaces(n.toNumber(), _decimal["default"].ROUND_CEIL);
+        return x.toDecimalPlaces(n.toNumber(), _decimal.default.ROUND_CEIL);
       }
     },
-    Fraction: function Fraction(x) {
+    Fraction: function (x) {
       return x.ceil();
     },
-    'Fraction, number': function FractionNumber(x, n) {
+    'Fraction, number': function (x, n) {
       return x.ceil(n);
     },
-    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+    'Fraction, BigNumber': function (x, n) {
       return x.ceil(n.toNumber());
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        // deep map collection, skip zeros since ceil(0) = 0
-        return (0, _collection.deepMap)(x, self, true);
-      };
+    'Array | Matrix': typed.referToSelf(self => x => {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return (0, _collection.deepMap)(x, self, true);
     }),
-    'Array, number | BigNumber': typed.referToSelf(function (self) {
-      return function (x, n) {
-        // deep map collection, skip zeros since ceil(0) = 0
-        return (0, _collection.deepMap)(x, function (i) {
-          return self(i, n);
-        }, true);
-      };
+    'Array, number | BigNumber': typed.referToSelf(self => (x, n) => {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return (0, _collection.deepMap)(x, i => self(i, n), true);
     }),
-    'SparseMatrix, number | BigNumber': typed.referToSelf(function (self) {
-      return function (x, y) {
-        return matAlgo11xS0s(x, y, self, false);
-      };
+    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo11xS0s(x, y, self, false);
     }),
-    'DenseMatrix, number | BigNumber': typed.referToSelf(function (self) {
-      return function (x, y) {
-        return matAlgo14xDs(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(function (self) {
-      return function (x, y) {
-        // use matrix implementation
-        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
-      };
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
+      // use matrix implementation
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
     }),
-    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(function (self) {
-      return function (x, y) {
-        if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
-        if (y.storage() === 'dense') {
-          return matAlgo14xDs(y, x, self, true);
-        }
-        return matAlgo12xSfs(y, x, self, true);
-      };
+    '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 matAlgo14xDs(y, x, self, true);
+      }
+      return matAlgo12xSfs(y, x, self, true);
     })
   });
 });

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

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createCube = void 0;
 var _factory = require("../../utils/factory.js");
 var _index = require("../../plain/number/index.js");
-var name = 'cube';
-var dependencies = ['typed'];
-var createCube = exports.createCube = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'cube';
+const dependencies = ['typed'];
+const createCube = exports.createCube = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Compute the cube of a value, `x * x * x`.
    * To avoid confusion with `pow(M,3)`, this function does not apply to matrices.
@@ -32,21 +34,24 @@ var createCube = exports.createCube = /* #__PURE__ */(0, _factory.factory)(name,
    *
    *    multiply, square, pow, cbrt
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x  Number for which to calculate the cube
-   * @return {number | BigNumber | Fraction | Complex | Unit} Cube of x
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x  Number for which to calculate the cube
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit} Cube of x
    */
   return typed(name, {
     number: _index.cubeNumber,
-    Complex: function Complex(x) {
+    Complex: function (x) {
       return x.mul(x).mul(x); // Is faster than pow(x, 3)
     },
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       return x.times(x).times(x);
     },
-    Fraction: function Fraction(x) {
+    bigint: function (x) {
+      return x * x * x;
+    },
+    Fraction: function (x) {
       return x.pow(3); // Is faster than mul()mul()mul()
     },
-    Unit: function Unit(x) {
+    Unit: function (x) {
       return x.pow(3);
     }
   });

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

@@ -8,21 +8,23 @@ var _factory = require("../../utils/factory.js");
 var _object = require("../../utils/object.js");
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
-var name = 'divide';
-var dependencies = ['typed', 'matrix', 'multiply', 'equalScalar', 'divideScalar', 'inv'];
-var createDivide = exports.createDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    multiply = _ref.multiply,
-    equalScalar = _ref.equalScalar,
-    divideScalar = _ref.divideScalar,
-    inv = _ref.inv;
-  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
-    typed: typed,
-    equalScalar: equalScalar
+const name = 'divide';
+const dependencies = ['typed', 'matrix', 'multiply', 'equalScalar', 'divideScalar', 'inv'];
+const createDivide = exports.createDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    multiply,
+    equalScalar,
+    divideScalar,
+    inv
+  } = _ref;
+  const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed,
+    equalScalar
   });
-  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
-    typed: typed
+  const matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed
   });
 
   /**
@@ -52,31 +54,31 @@ var createDivide = exports.createDivide = /* #__PURE__ */(0, _factory.factory)(n
    *
    *    multiply
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x   Numerator
-   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} y          Denominator
-   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix} x   Numerator
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Array | Matrix} y          Denominator
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
    */
   return typed('divide', (0, _object.extend)({
     // we extend the signatures of divideScalar with signatures dealing with matrices
 
-    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(x, y) {
+    'Array | Matrix, Array | Matrix': function (x, y) {
       // TODO: implement matrix right division using pseudo inverse
       // https://www.mathworks.nl/help/matlab/ref/mrdivide.html
       // https://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html
       // https://stackoverflow.com/questions/12263932/how-does-gnu-octave-matrix-division-work-getting-unexpected-behaviour
       return multiply(x, inv(y));
     },
-    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+    'DenseMatrix, any': function (x, y) {
       return matAlgo14xDs(x, y, divideScalar, false);
     },
-    'SparseMatrix, any': function SparseMatrixAny(x, y) {
+    'SparseMatrix, any': function (x, y) {
       return matAlgo11xS0s(x, y, divideScalar, false);
     },
-    'Array, any': function ArrayAny(x, y) {
+    'Array, any': function (x, y) {
       // use matrix implementation
       return matAlgo14xDs(matrix(x), y, divideScalar, false).valueOf();
     },
-    'any, Array | Matrix': function anyArrayMatrix(x, y) {
+    'any, Array | Matrix': function (x, y) {
       return multiply(x, inv(y));
     }
   }, divideScalar.signatures));

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

@@ -5,11 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createDivideScalar = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'divideScalar';
-var dependencies = ['typed', 'numeric'];
-var createDivideScalar = exports.createDivideScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    numeric = _ref.numeric;
+const name = 'divideScalar';
+const dependencies = ['typed', 'numeric'];
+const createDivideScalar = exports.createDivideScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    numeric
+  } = _ref;
   /**
    * Divide two scalar values, `x / y`.
    * This function is meant for internal use: it is used by the public functions
@@ -17,29 +19,28 @@ var createDivideScalar = exports.createDivideScalar = /* #__PURE__ */(0, _factor
    *
    * This function does not support collections (Array or Matrix).
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit} x   Numerator
-   * @param  {number | BigNumber | Fraction | Complex} y          Denominator
-   * @return {number | BigNumber | Fraction | Complex | Unit}     Quotient, `x / y`
+   * @param  {number | BigNumber | bigint | Fraction | Complex | Unit} x   Numerator
+   * @param  {number | BigNumber | bigint | Fraction | Complex} y          Denominator
+   * @return {number | BigNumber | bigint | Fraction | Complex | Unit}     Quotient, `x / y`
    * @private
    */
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
+    'number, number': function (x, y) {
       return x / y;
     },
-    'Complex, Complex': function ComplexComplex(x, y) {
+    'Complex, Complex': function (x, y) {
       return x.div(y);
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+    'BigNumber, BigNumber': function (x, y) {
       return x.div(y);
     },
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.div(y);
+    'bigint, bigint': function (x, y) {
+      return x / y;
     },
-    'Unit, number | Complex | Fraction | BigNumber | Unit': function UnitNumberComplexFractionBigNumberUnit(x, y) {
-      return x.divide(y);
+    'Fraction, Fraction': function (x, y) {
+      return x.div(y);
     },
-    'number | Fraction | Complex | BigNumber, Unit': function numberFractionComplexBigNumberUnit(x, y) {
-      return y.divideInto(x);
-    }
+    'Unit, number | Complex | Fraction | BigNumber | Unit': (x, y) => x.divide(y),
+    'number | Fraction | Complex | BigNumber, Unit': (x, y) => y.divideInto(x)
   });
 });

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

@@ -11,38 +11,40 @@ var _matAlgo07xSSf = require("../../type/matrix/utils/matAlgo07xSSf.js");
 var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
-var name = 'dotDivide';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat'];
-var createDotDivide = exports.createDotDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    equalScalar = _ref.equalScalar,
-    divideScalar = _ref.divideScalar,
-    DenseMatrix = _ref.DenseMatrix,
-    concat = _ref.concat;
-  var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
-    typed: typed,
-    equalScalar: equalScalar
+const name = 'dotDivide';
+const dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat'];
+const createDotDivide = exports.createDotDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    equalScalar,
+    divideScalar,
+    DenseMatrix,
+    concat
+  } = _ref;
+  const matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
+    typed,
+    equalScalar
   });
-  var matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
-    typed: typed
+  const matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
+    typed
   });
-  var matAlgo07xSSf = (0, _matAlgo07xSSf.createMatAlgo07xSSf)({
-    typed: typed,
-    DenseMatrix: DenseMatrix
+  const matAlgo07xSSf = (0, _matAlgo07xSSf.createMatAlgo07xSSf)({
+    typed,
+    DenseMatrix
   });
-  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
-    typed: typed,
-    equalScalar: equalScalar
+  const matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed,
+    equalScalar
   });
-  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
-    typed: typed,
-    DenseMatrix: DenseMatrix
+  const matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed,
+    DenseMatrix
   });
-  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
-    typed: typed,
-    matrix: matrix,
-    concat: concat
+  const matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed,
+    matrix,
+    concat
   });
 
   /**