mathjs 10.5.0 → 10.5.1

package/lib/esm/factoriesNumber.js

@@ -1,4 +1,4 @@
-import { absNumber, acoshNumber, acosNumber, acothNumber, acotNumber, acschNumber, acscNumber, addNumber, andNumber, asechNumber, asecNumber, asinhNumber, asinNumber, atan2Number, atanhNumber, atanNumber, bitAndNumber, bitNotNumber, bitOrNumber, bitXorNumber, cbrtNumber, ceilNumber, combinationsNumber, coshNumber, cosNumber, cothNumber, cotNumber, cschNumber, cscNumber, cubeNumber, divideNumber, expm1Number, expNumber, fixNumber, floorNumber, gammaNumber, gcdNumber, isIntegerNumber, isNaNNumber, isNegativeNumber, isPositiveNumber, isZeroNumber, lcmNumber, leftShiftNumber, lgammaNumber, log10Number, log1pNumber, log2Number, logNumber, modNumber, multiplyNumber, normNumber, notNumber, orNumber, powNumber, rightArithShiftNumber, rightLogShiftNumber, sechNumber, secNumber, signNumber, sinhNumber, sinNumber, sqrtNumber, squareNumber, subtractNumber, tanhNumber, tanNumber, unaryMinusNumber, unaryPlusNumber, xgcdNumber, xorNumber } from './plain/number/index.js';
+import { absNumber, acoshNumber, acosNumber, acothNumber, acotNumber, acschNumber, acscNumber, addNumber, andNumber, asechNumber, asecNumber, asinhNumber, asinNumber, atan2Number, atanhNumber, atanNumber, bitAndNumber, bitNotNumber, bitOrNumber, bitXorNumber, cbrtNumber, combinationsNumber, coshNumber, cosNumber, cothNumber, cotNumber, cschNumber, cscNumber, cubeNumber, divideNumber, expm1Number, expNumber, gammaNumber, gcdNumber, isIntegerNumber, isNaNNumber, isNegativeNumber, isPositiveNumber, isZeroNumber, lcmNumber, leftShiftNumber, lgammaNumber, log10Number, log1pNumber, log2Number, logNumber, modNumber, multiplyNumber, normNumber, notNumber, nthRootNumber, orNumber, powNumber, rightArithShiftNumber, rightLogShiftNumber, roundNumber, sechNumber, secNumber, signNumber, sinhNumber, sinNumber, sqrtNumber, squareNumber, subtractNumber, tanhNumber, tanNumber, unaryMinusNumber, unaryPlusNumber, xgcdNumber, xorNumber } from './plain/number/index.js';
 import { factory } from './utils/factory.js';
 import { noIndex, noMatrix, noSubset } from './utils/noop.js'; // ----------------------------------------------------------------------------
 // classes and functions
@@ -24,12 +24,12 @@ export var createUnaryPlus = /* #__PURE__ */createNumberFactory('unaryPlus', una
 export var createAbs = /* #__PURE__ */createNumberFactory('abs', absNumber);
 export var createAddScalar = /* #__PURE__ */createNumberFactory('addScalar', addNumber);
 export var createCbrt = /* #__PURE__ */createNumberFactory('cbrt', cbrtNumber);
-export var createCeil = /* #__PURE__ */createNumberFactory('ceil', ceilNumber);
+export { createCeilNumber as createCeil } from './function/arithmetic/ceil.js';
 export var createCube = /* #__PURE__ */createNumberFactory('cube', cubeNumber);
 export var createExp = /* #__PURE__ */createNumberFactory('exp', expNumber);
 export var createExpm1 = /* #__PURE__ */createNumberFactory('expm1', expm1Number);
-export var createFix = /* #__PURE__ */createNumberFactory('fix', fixNumber);
-export var createFloor = /* #__PURE__ */createNumberFactory('floor', floorNumber);
+export { createFixNumber as createFix } from './function/arithmetic/fix.js';
+export { createFloorNumber as createFloor } from './function/arithmetic/floor.js';
 export var createGcd = /* #__PURE__ */createNumberFactory('gcd', gcdNumber);
 export var createLcm = /* #__PURE__ */createNumberFactory('lcm', lcmNumber);
 export var createLog10 = /* #__PURE__ */createNumberFactory('log10', log10Number);
@@ -37,7 +37,7 @@ export var createLog2 = /* #__PURE__ */createNumberFactory('log2', log2Number);
 export var createMod = /* #__PURE__ */createNumberFactory('mod', modNumber);
 export var createMultiplyScalar = /* #__PURE__ */createNumberFactory('multiplyScalar', multiplyNumber);
 export var createMultiply = /* #__PURE__ */createNumberFactory('multiply', multiplyNumber);
-export { createNthRootNumber as createNthRoot } from './function/arithmetic/nthRoot.js';
+export var createNthRoot = /* #__PURE__ */createNumberOptionalSecondArgFactory('nthRoot', nthRootNumber);
 export var createSign = /* #__PURE__ */createNumberFactory('sign', signNumber);
 export var createSqrt = /* #__PURE__ */createNumberFactory('sqrt', sqrtNumber);
 export var createSquare = /* #__PURE__ */createNumberFactory('square', squareNumber);
@@ -45,7 +45,7 @@ export var createSubtract = /* #__PURE__ */createNumberFactory('subtract', subtr
 export var createXgcd = /* #__PURE__ */createNumberFactory('xgcd', xgcdNumber);
 export var createDivideScalar = /* #__PURE__ */createNumberFactory('divideScalar', divideNumber);
 export var createPow = /* #__PURE__ */createNumberFactory('pow', powNumber);
-export { createRoundNumber as createRound } from './function/arithmetic/round.js';
+export var createRound = /* #__PURE__ */createNumberOptionalSecondArgFactory('round', roundNumber);
 export var createLog = /* #__PURE__ */createNumberOptionalSecondArgFactory('log', logNumber);
 export var createLog1p = /* #__PURE__ */createNumberFactory('log1p', log1pNumber);
 export var createAdd = /* #__PURE__ */createNumberFactory('add', addNumber);

package/lib/esm/function/algebra/decomposition/qr.js

@@ -204,8 +204,8 @@ export var createQr = /* #__PURE__ */factory(name, dependencies, _ref => {
 
 
     return {
-      Q: Q,
-      R: R,
+      Q,
+      R,
       toString: function toString() {
         return 'Q: ' + this.Q.toString() + '\nR: ' + this.R.toString();
       }

package/lib/esm/function/algebra/resolve.js

@@ -29,11 +29,11 @@ export var createResolve = /* #__PURE__ */factory(name, dependencies, _ref => {
    *
    *     simplify, evaluate
    *
-   * @param {Node} node
-   *     The expression tree to be simplified
+   * @param {Node | Node[]} node
+   *     The expression tree (or trees) to be simplified
    * @param {Object} scope
    *     Scope specifying variables to be resolved
-   * @return {Node} Returns `node` with variables recursively substituted.
+   * @return {Node | Node[]} Returns `node` with variables recursively substituted.
    * @throws {ReferenceError}
    *     If there is a cyclic dependency among the variables in `scope`,
    *     resolution is impossible and a ReferenceError is thrown.

package/lib/esm/function/algebra/solver/utils/solveValidation.js

@@ -45,7 +45,7 @@ export function createSolveValidation(_ref) {
         }
 
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1],
           datatype: b._datatype
         });
@@ -66,7 +66,7 @@ export function createSolveValidation(_ref) {
             }
 
             return new DenseMatrix({
-              data: data,
+              data,
               size: [rows, 1],
               datatype: b._datatype
             });
@@ -90,7 +90,7 @@ export function createSolveValidation(_ref) {
           }
 
           return new DenseMatrix({
-            data: data,
+            data,
             size: [rows, 1],
             datatype: b._datatype
           });
@@ -113,7 +113,7 @@ export function createSolveValidation(_ref) {
         }
 
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }
@@ -128,7 +128,7 @@ export function createSolveValidation(_ref) {
         }
 
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }

package/lib/esm/function/algebra/sparse/csChol.js

@@ -161,8 +161,8 @@ export var createCsChol = /* #__PURE__ */factory(name, dependencies, _ref => {
 
 
     return {
-      L: L,
-      P: P
+      L,
+      P
     };
   };
 });

package/lib/esm/function/algebra/sparse/csLeaf.js

@@ -50,7 +50,7 @@ export function csLeaf(i, j, w, first, maxfirst, prevleaf, ancestor) {
   }
 
   return {
-    jleaf: jleaf,
-    q: q
+    jleaf,
+    q
   };
 }

package/lib/esm/function/algebra/sparse/csLu.js

@@ -190,9 +190,9 @@ export var createCsLu = /* #__PURE__ */factory(name, dependencies, _ref => {
     uindex.splice(unz, uindex.length - unz); // return LU factor
 
     return {
-      L: L,
-      U: U,
-      pinv: pinv
+      L,
+      U,
+      pinv
     };
   };
 });

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
       }));
     }