mathjs 10.4.2 → 10.5.1

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

@@ -3,26 +3,63 @@ 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 { ceilNumber } from '../../plain/number/index.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';
 var name = 'ceil';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
-export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createCeilNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.ceil(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref2 => {
   var {
     typed,
     config,
     round,
     matrix,
-    equalScalar
-  } = _ref;
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
   var algorithm11 = createAlgorithm11({
     typed,
     equalScalar
   });
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
   var algorithm14 = createAlgorithm14({
     typed
   });
+  var ceilNumber = createCeilNumber({
+    typed,
+    config,
+    round
+  });
   /**
    * Round a value towards plus infinity
    * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
@@ -62,29 +99,17 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed('ceil', {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
-        return round(x);
-      } else {
-        return ceilNumber(x);
-      }
-    },
-    'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
-      }
-    },
+    number: ceilNumber.signatures.number,
+    'number,number': ceilNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return x.ceil();
     },
     'Complex, number': function ComplexNumber(x, n) {
       return x.ceil(n);
     },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
     BigNumber: function BigNumber(x) {
       if (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x);
@@ -105,11 +130,14 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Fraction, number': function FractionNumber(x, n) {
       return x.ceil(n);
     },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, this, true);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, i => this(i, n), true);
     },
@@ -119,9 +147,18 @@ export var createCeil = /* #__PURE__ */factory(name, dependencies, _ref => {
     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
       return algorithm14(x, y, this, false);
     },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
     }
   });
 });

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

@@ -1,19 +1,47 @@
 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';
 var name = 'fix';
-var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor'];
-export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
+var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createFixNumber = /* #__PURE__ */factory(name, ['typed', 'ceil', 'floor'], _ref => {
   var {
     typed,
-    Complex: _Complex,
-    matrix,
     ceil,
     floor
   } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      return x > 0 ? floor(x) : ceil(x);
+    },
+    'number, number': function numberNumber(x, n) {
+      return x > 0 ? floor(x, n) : ceil(x, n);
+    }
+  });
+});
+export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
+  var {
+    typed,
+    Complex: _Complex,
+    matrix,
+    ceil,
+    floor,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
   var algorithm14 = createAlgorithm14({
     typed
   });
+  var fixNumber = createFixNumber({
+    typed,
+    ceil,
+    floor
+  });
   /**
    * Round a value towards zero.
    * For matrices, the function is evaluated element wise.
@@ -21,6 +49,7 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
    * Syntax:
    *
    *    math.fix(x)
+   *    math.fix(x,n)
    *
    * Examples:
    *
@@ -51,16 +80,16 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed('fix', {
-    number: function number(x) {
-      return x > 0 ? floor(x) : ceil(x);
-    },
-    'number, number | BigNumber': function numberNumberBigNumber(x, n) {
-      return x > 0 ? floor(x, n) : ceil(x, n);
-    },
+    number: fixNumber.signatures.number,
+    'number, number | BigNumber': fixNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return new _Complex(x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re), x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im));
     },
-    'Complex, number | BigNumber': function ComplexNumberBigNumber(x, n) {
+    'Complex, number': function ComplexNumber(x, n) {
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, bn) {
+      var n = bn.toNumber();
       return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
     },
     BigNumber: function BigNumber(x) {
@@ -73,7 +102,7 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
       return x.s < 0 ? x.ceil() : x.floor();
     },
     'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
-      return x.s < 0 ? x.ceil(n) : x.floor(n);
+      return x.s < 0 ? ceil(x, n) : floor(x, n);
     },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since fix(0) = 0
@@ -83,9 +112,18 @@ export var createFix = /* #__PURE__ */factory(name, dependencies, _ref => {
       // deep map collection, skip zeros since fix(0) = 0
       return deepMap(x, i => this(i, n), true);
     },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
     }
   });
 });

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

@@ -4,24 +4,62 @@ 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';
 var name = 'floor';
-var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar'];
-export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.floor(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
   var {
     typed,
     config,
     round,
     matrix,
-    equalScalar
-  } = _ref;
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
   var algorithm11 = createAlgorithm11({
     typed,
     equalScalar
   });
+  var algorithm12 = createAlgorithm12({
+    typed,
+    DenseMatrix
+  });
   var algorithm14 = createAlgorithm14({
     typed
   });
+  var floorNumber = createFloorNumber({
+    typed,
+    config,
+    round
+  });
   /**
    * Round a value towards minus infinity.
    * For matrices, the function is evaluated element wise.
@@ -50,6 +88,10 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    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]
    *
+   *    math.floor(math.tau, [2, 3])  // returns Array [6.28, 6.283]
+   *
+   *    // Note that floor(array, array) currently not implemented.
+   *
    * See also:
    *
    *    ceil, fix, round
@@ -60,29 +102,17 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
    */
 
   return typed('floor', {
-    number: function number(x) {
-      if (nearlyEqual(x, round(x), config.epsilon)) {
-        return round(x);
-      } else {
-        return Math.floor(x);
-      }
-    },
-    'number, number': function numberNumber(x, n) {
-      if (nearlyEqual(x, round(x, n), config.epsilon)) {
-        return round(x, n);
-      } else {
-        var [number, exponent] = "".concat(x, "e").split('e');
-        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
-        [number, exponent] = "".concat(result, "e").split('e');
-        return Number("".concat(number, "e").concat(Number(exponent) - n));
-      }
-    },
+    number: floorNumber.signatures.number,
+    'number,number': floorNumber.signatures['number,number'],
     Complex: function Complex(x) {
       return x.floor();
     },
     'Complex, number': function ComplexNumber(x, n) {
       return x.floor(n);
     },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
     BigNumber: function BigNumber(x) {
       if (bigNearlyEqual(x, round(x), config.epsilon)) {
         return round(x);
@@ -103,11 +133,14 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
     'Fraction, number': function FractionNumber(x, n) {
       return x.floor(n);
     },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since floor(0) = 0
       return deepMap(x, this, true);
     },
-    'Array | Matrix, number': function ArrayMatrixNumber(x, n) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, n) {
       // deep map collection, skip zeros since ceil(0) = 0
       return deepMap(x, i => this(i, n), true);
     },
@@ -117,9 +150,18 @@ export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref => {
     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
       return algorithm14(x, y, this, false);
     },
-    'number | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | Fraction | BigNumber, Array': function numberComplexFractionBigNumberArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
+    },
+    'number | Complex | Fraction | BigNumber, Matrix': function numberComplexFractionBigNumberMatrix(x, y) {
+      if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+
+      if (y.storage() === 'dense') {
+        return algorithm14(y, x, this, true);
+      }
+
+      return algorithm12(y, x, this, true);
     }
   });
 });

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

@@ -68,9 +68,7 @@ export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   var complexErr = '' + 'Complex number not supported in function nthRoot. ' + 'Use nthRoots instead.';
   return typed(name, {
-    number: function number(x) {
-      return nthRootNumber(x, 2);
-    },
+    number: nthRootNumber,
     'number, number': nthRootNumber,
     BigNumber: function BigNumber(x) {
       return _bigNthRoot(x, new _BigNumber(2));

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

@@ -67,7 +67,7 @@ export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
 
       roots.push(new Complex({
-        r: r,
+        r,
         phi: (arg + 2 * Math.PI * k) / root
       }));
     }

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

@@ -3,7 +3,7 @@ import { isInteger } from '../../utils/number.js';
 import { arraySize as size } from '../../utils/array.js';
 import { powNumber } from '../../plain/number/index.js';
 var name = 'pow';
-var dependencies = ['typed', 'config', 'identity', 'multiply', 'matrix', 'fraction', 'number', 'Complex'];
+var dependencies = ['typed', 'config', 'identity', 'multiply', 'matrix', 'inv', 'fraction', 'number', 'Complex'];
 export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -11,6 +11,7 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
     identity,
     multiply,
     matrix,
+    inv,
     number,
     fraction,
     Complex
@@ -18,8 +19,11 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
 
   /**
    * Calculates the power of x to y, `x ^ y`.
-   * Matrix exponentiation is supported for square matrices `x`, and positive
-   * integer exponents `y`.
+   *
+   * Matrix exponentiation is supported for square matrices `x` and integers `y`:
+   * when `y` is nonnegative, `x` may be any square matrix; and when `y` is
+   * negative, `x` must be invertible, and then this function returns
+   * inv(x)^(-y).
    *
    * For cubic roots of negative numbers, the function returns the principal
    * root by default. In order to let the function return the real root,
@@ -40,6 +44,9 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
    *    const b = [[1, 2], [4, 3]]
    *    math.pow(b, 2)               // returns Array [[9, 8], [16, 17]]
    *
+   *    const c = [[1, 2], [4, 3]]
+   *    math.pow(c, -1)               // returns Array [[-0.6, 0.4], [0.8, -0.2]]
+   *
    * See also:
    *
    *    multiply, sqrt, cbrt, nthRoot
@@ -135,15 +142,15 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
   /**
    * Calculate the power of a 2d array
    * @param {Array} x     must be a 2 dimensional, square matrix
-   * @param {number} y    a positive, integer value
+   * @param {number} y    a integer value (positive if `x` is not invertible)
    * @returns {Array}
    * @private
    */
 
 
   function _powArray(x, y) {
-    if (!isInteger(y) || y < 0) {
-      throw new TypeError('For A^b, b must be a positive integer (value is ' + y + ')');
+    if (!isInteger(y)) {
+      throw new TypeError('For A^b, b must be an integer (value is ' + y + ')');
     } // verify that A is a 2 dimensional square matrix
 
 
@@ -157,6 +164,18 @@ export var createPow = /* #__PURE__ */factory(name, dependencies, _ref => {
       throw new Error('For A^b, A must be square (size is ' + s[0] + 'x' + s[1] + ')');
     }
 
+    if (y < 0) {
+      try {
+        return _powArray(inv(x), -y);
+      } catch (error) {
+        if (error.message === 'Cannot calculate inverse, determinant is zero') {
+          throw new TypeError('For A^b, when A is not invertible, b must be a positive integer (value is ' + y + ')');
+        }
+
+        throw error;
+      }
+    }
+
     var res = identity(s[0]).valueOf();
     var px = x;
 

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

@@ -1,12 +1,5 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 import { factory } from '../../utils/factory.js';
 import { deepMap } from '../../utils/collection.js';
-import { isInteger } from '../../utils/number.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';
@@ -70,7 +63,16 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
 
-  return typed(name, _objectSpread(_objectSpread({}, roundNumberSignatures), {}, {
+  return typed(name, {
+    number: roundNumber,
+    'number, number': roundNumber,
+    'number, BigNumber': function numberBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+
+      return new BigNumber(x).toDecimalPlaces(n.toNumber());
+    },
     Complex: function Complex(x) {
       return x.round();
     },
@@ -90,13 +92,6 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       return x.round(_n);
     },
-    'number, BigNumber': function numberBigNumber(x, n) {
-      if (!n.isInteger()) {
-        throw new TypeError(NO_INT);
-      }
-
-      return new BigNumber(x).toDecimalPlaces(n.toNumber());
-    },
     BigNumber: function BigNumber(x) {
       return x.toDecimalPlaces(0);
     },
@@ -117,6 +112,13 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       return x.round(n);
     },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+
+      return x.round(n.toNumber());
+    },
     'Array | Matrix': function ArrayMatrix(x) {
       // deep map collection, skip zeros since round(0) = 0
       return deepMap(x, this, true);
@@ -127,7 +129,11 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
     'DenseMatrix, number | BigNumber': function DenseMatrixNumberBigNumber(x, y) {
       return algorithm14(x, y, this, false);
     },
-    'number | Complex | BigNumber, SparseMatrix': function numberComplexBigNumberSparseMatrix(x, y) {
+    'Array, number | BigNumber': function ArrayNumberBigNumber(x, y) {
+      // use matrix implementation
+      return algorithm14(matrix(x), y, this, false).valueOf();
+    },
+    'number | Complex | BigNumber | Fraction, SparseMatrix': function numberComplexBigNumberFractionSparseMatrix(x, y) {
       // check scalar is zero
       if (equalScalar(x, 0)) {
         // do not execute algorithm, result will be a zero matrix
@@ -136,7 +142,7 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       return algorithm12(y, x, this, true);
     },
-    'number | Complex | BigNumber, DenseMatrix': function numberComplexBigNumberDenseMatrix(x, y) {
+    'number | Complex | BigNumber | Fraction, DenseMatrix': function numberComplexBigNumberFractionDenseMatrix(x, y) {
       // check scalar is zero
       if (equalScalar(x, 0)) {
         // do not execute algorithm, result will be a zero matrix
@@ -145,33 +151,9 @@ export var createRound = /* #__PURE__ */factory(name, dependencies, _ref => {
 
       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 | Complex | BigNumber, Array': function numberComplexBigNumberArray(x, y) {
+    'number | Complex | BigNumber | Fraction, Array': function numberComplexBigNumberFractionArray(x, y) {
       // use matrix implementation
       return algorithm14(matrix(y), x, this, true).valueOf();
     }
-  }));
-});
-var roundNumberSignatures = {
-  number: roundNumber,
-  'number, number': function numberNumber(x, n) {
-    if (!isInteger(n)) {
-      throw new TypeError(NO_INT);
-    }
-
-    if (n < 0 || n > 15) {
-      throw new Error('Number of decimals in function round must be in the range of 0-15');
-    }
-
-    return roundNumber(x, n);
-  }
-};
-export var createRoundNumber = /* #__PURE__ */factory(name, ['typed'], _ref2 => {
-  var {
-    typed
-  } = _ref2;
-  return typed(name, roundNumberSignatures);
+  });
 });