mathjs 10.4.2 → 10.5.1

package/lib/esm/function/combinatorics/stirlingS2.js

@@ -1,6 +1,7 @@
 import { factory } from '../../utils/factory.js';
+import { isNumber } from '../../utils/is.js';
 var name = 'stirlingS2';
-var dependencies = ['typed', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'factorial', 'combinations', 'isNegative', 'isInteger', 'larger'];
+var dependencies = ['typed', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'factorial', 'combinations', 'isNegative', 'isInteger', 'number', '?bignumber', 'larger'];
 export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -13,16 +14,23 @@ export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref =>
     combinations,
     isNegative,
     isInteger,
+    number,
+    bignumber,
     larger
   } = _ref;
-
+  var smallCache = [];
+  var bigCache = [];
   /**
    * The Stirling numbers of the second kind, counts the number of ways to partition
    * a set of n labelled objects into k nonempty unlabelled subsets.
    * stirlingS2 only takes integer arguments.
    * The following condition must be enforced: k <= n.
    *
-   *  If n = k or k = 1, then s(n,k) = 1
+   *  If n = k or k = 1 <= n, then s(n,k) = 1
+   *  If k = 0 < n, then s(n,k) = 0
+   *
+   * Note that if either n or k is supplied as a BigNumber, the result will be
+   * as well.
    *
    * Syntax:
    *
@@ -40,26 +48,47 @@ export var createStirlingS2 = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @param {Number | BigNumber} k    Number of objects in the subset
    * @return {Number | BigNumber}     S(n,k)
    */
+
   return typed(name, {
     'number | BigNumber, number | BigNumber': function numberBigNumberNumberBigNumber(n, k) {
       if (!isInteger(n) || isNegative(n) || !isInteger(k) || isNegative(k)) {
         throw new TypeError('Non-negative integer value expected in function stirlingS2');
       } else if (larger(k, n)) {
         throw new TypeError('k must be less than or equal to n in function stirlingS2');
-      } // 1/k! Sum(i=0 -> k) [(-1)^(k-i)*C(k,j)* i^n]
+      }
+
+      var big = !(isNumber(n) && isNumber(k));
+      var cache = big ? bigCache : smallCache;
+      var make = big ? bignumber : number;
+      var nn = number(n);
+      var nk = number(k);
+      /* See if we already have the value: */
+
+      if (cache[nn] && cache[nn].length > nk) {
+        return cache[nn][nk];
+      }
+      /* Fill the cache */
+
 
+      for (var m = 0; m <= nn; ++m) {
+        if (!cache[m]) {
+          cache[m] = [m === 0 ? make(1) : make(0)];
+        }
 
-      var kFactorial = factorial(k);
-      var result = 0;
+        if (m === 0) continue;
+        var row = cache[m];
+        var prev = cache[m - 1];
 
-      for (var i = 0; i <= k; i++) {
-        var negativeOne = pow(-1, subtract(k, i));
-        var kChooseI = combinations(k, i);
-        var iPower = pow(i, n);
-        result = addScalar(result, multiplyScalar(multiplyScalar(kChooseI, iPower), negativeOne));
+        for (var i = row.length; i <= m && i <= nk; ++i) {
+          if (i === m) {
+            row[i] = 1;
+          } else {
+            row[i] = addScalar(multiplyScalar(make(i), prev[i]), prev[i - 1]);
+          }
+        }
       }
 
-      return divideScalar(result, kFactorial);
+      return cache[nn][nk];
     }
   });
 });

package/lib/esm/function/matrix/det.js

@@ -3,15 +3,16 @@ import { clone } from '../../utils/object.js';
 import { format } from '../../utils/string.js';
 import { factory } from '../../utils/factory.js';
 var name = 'det';
-var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'unaryMinus', 'lup'];
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
 export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     matrix,
     subtract,
     multiply,
-    unaryMinus,
-    lup
+    divideScalar,
+    isZero,
+    unaryMinus
   } = _ref;
 
   /**
@@ -106,42 +107,45 @@ export var createDet = /* #__PURE__ */factory(name, dependencies, _ref => {
       // the determinant of [a11,a12;a21,a22] is det = a11*a22-a21*a12
       return subtract(multiply(matrix[0][0], matrix[1][1]), multiply(matrix[1][0], matrix[0][1]));
     } else {
-      // Compute the LU decomposition
-      var decomp = lup(matrix); // The determinant is the product of the diagonal entries of U (and those of L, but they are all 1)
-
-      var det = decomp.U[0][0];
-
-      for (var _i = 1; _i < rows; _i++) {
-        det = multiply(det, decomp.U[_i][_i]);
-      } // The determinant will be multiplied by 1 or -1 depending on the parity of the permutation matrix.
-      // This can be determined by counting the cycles. This is roughly a linear time algorithm.
-
-
-      var evenCycles = 0;
-      var i = 0;
-      var visited = [];
+      // Bareiss algorithm
+      // this algorithm have same complexity as LUP decomposition (O(n^3))
+      // but it preserve precision of floating point more relative to the LUP decomposition
+      var negated = false;
+      var rowIndices = new Array(rows).fill(0).map((_, i) => i); // matrix index of row i
+
+      for (var k = 0; k < rows; k++) {
+        var k_ = rowIndices[k];
+
+        if (isZero(matrix[k_][k])) {
+          var _k = void 0;
+
+          for (_k = k + 1; _k < rows; _k++) {
+            if (!isZero(matrix[rowIndices[_k]][k])) {
+              k_ = rowIndices[_k];
+              rowIndices[_k] = rowIndices[k];
+              rowIndices[k] = k_;
+              negated = !negated;
+              break;
+            }
+          }
 
-      while (true) {
-        while (visited[i]) {
-          i++;
+          if (_k === rows) return matrix[k_][k]; // some zero of the type
         }
 
-        if (i >= rows) break;
-        var j = i;
-        var cycleLen = 0;
+        var piv = matrix[k_][k];
+        var piv_ = k === 0 ? 1 : matrix[rowIndices[k - 1]][k - 1];
 
-        while (!visited[decomp.p[j]]) {
-          visited[decomp.p[j]] = true;
-          j = decomp.p[j];
-          cycleLen++;
-        }
+        for (var i = k + 1; i < rows; i++) {
+          var i_ = rowIndices[i];
 
-        if (cycleLen % 2 === 0) {
-          evenCycles++;
+          for (var j = k + 1; j < rows; j++) {
+            matrix[i_][j] = divideScalar(subtract(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
+          }
         }
       }
 
-      return evenCycles % 2 === 0 ? det : unaryMinus(det);
+      var det = matrix[rowIndices[rows - 1]][rows - 1];
+      return negated ? unaryMinus(det) : det;
     }
   }
 });

package/lib/esm/function/matrix/expm.js

@@ -132,8 +132,8 @@ export var createExpm = /* #__PURE__ */factory(name, dependencies, _ref => {
 
         if (errorEstimate(infNorm, q, j) < eps) {
           return {
-            q: q,
-            j: j
+            q,
+            j
           };
         }
       }

package/lib/esm/function/matrix/pinv.js

@@ -0,0 +1,205 @@
+import { isMatrix } from '../../utils/is.js';
+import { arraySize } from '../../utils/array.js';
+import { factory } from '../../utils/factory.js';
+import { format } from '../../utils/string.js';
+import { clone } from '../../utils/object.js';
+var name = 'pinv';
+var dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
+export var createPinv = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    inv,
+    deepEqual,
+    equal,
+    dotDivide,
+    dot,
+    ctranspose,
+    divideScalar,
+    multiply,
+    add,
+    Complex
+  } = _ref;
+
+  /**
+   * Calculate the Moore–Penrose inverse of a matrix.
+   *
+   * Syntax:
+   *
+   *     math.pinv(x)
+   *
+   * Examples:
+   *
+   *     math.pinv([[1, 2], [3, 4]])          // returns [[-2, 1], [1.5, -0.5]]
+   *     math.pinv([[1, 0], [0, 1], [0, 1]])  // returns [[1, 0, 0], [0, 0.5, 0.5]]
+   *     math.pinv(4)                         // returns 0.25
+   *
+   * See also:
+   *
+   *     inv
+   *
+   * @param {number | Complex | Array | Matrix} x     Matrix to be inversed
+   * @return {number | Complex | Array | Matrix} The inverse of `x`.
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(x) {
+      var size = isMatrix(x) ? x.size() : arraySize(x);
+
+      switch (size.length) {
+        case 1:
+          // vector
+          if (_isZeros(x)) return ctranspose(x); // null vector
+
+          if (size[0] === 1) {
+            return inv(x); // invertible matrix
+          } else {
+            return dotDivide(ctranspose(x), dot(x, x));
+          }
+
+        case 2:
+          // two dimensional array
+          {
+            if (_isZeros(x)) return ctranspose(x); // zero matrixx
+
+            var rows = size[0];
+            var cols = size[1];
+
+            if (rows === cols) {
+              try {
+                return inv(x); // invertible matrix
+              } catch (err) {
+                if (err instanceof Error && err.message.match(/Cannot calculate inverse, determinant is zero/)) {// Expected
+                } else {
+                  throw err;
+                }
+              }
+            }
+
+            if (isMatrix(x)) {
+              return matrix(_pinv(x.valueOf(), rows, cols), x.storage());
+            } else {
+              // return an Array
+              return _pinv(x, rows, cols);
+            }
+          }
+
+        default:
+          // multi dimensional array
+          throw new RangeError('Matrix must be two dimensional ' + '(size: ' + format(size) + ')');
+      }
+    },
+    any: function any(x) {
+      // scalar
+      if (equal(x, 0)) return clone(x); // zero
+
+      return divideScalar(1, x);
+    }
+  });
+  /**
+   * Calculate the Moore–Penrose inverse of a matrix
+   * @param {Array[]} mat     A matrix
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns
+   * @return {Array[]} pinv    Pseudoinverse matrix
+   * @private
+   */
+
+  function _pinv(mat, rows, cols) {
+    var {
+      C,
+      F
+    } = _rankFact(mat, rows, cols); // TODO: Use SVD instead (may improve precision)
+
+
+    var Cpinv = multiply(inv(multiply(ctranspose(C), C)), ctranspose(C));
+    var Fpinv = multiply(ctranspose(F), inv(multiply(F, ctranspose(F))));
+    return multiply(Fpinv, Cpinv);
+  }
+  /**
+   * Calculate the reduced row echelon form of a matrix
+   *
+   * Modified from https://rosettacode.org/wiki/Reduced_row_echelon_form
+   *
+   * @param {Array[]} mat     A matrix
+   * @param {number} rows     Number of rows
+   * @param {number} cols     Number of columns
+   * @return {Array[]}        Reduced row echelon form
+   * @private
+   */
+
+
+  function _rref(mat, rows, cols) {
+    var M = clone(mat);
+    var lead = 0;
+
+    for (var r = 0; r < rows; r++) {
+      if (cols <= lead) {
+        return M;
+      }
+
+      var i = r;
+
+      while (_isZero(M[i][lead])) {
+        i++;
+
+        if (rows === i) {
+          i = r;
+          lead++;
+
+          if (cols === lead) {
+            return M;
+          }
+        }
+      }
+
+      [M[i], M[r]] = [M[r], M[i]];
+      var val = M[r][lead];
+
+      for (var j = 0; j < cols; j++) {
+        M[r][j] = dotDivide(M[r][j], val);
+      }
+
+      for (var _i = 0; _i < rows; _i++) {
+        if (_i === r) continue;
+        val = M[_i][lead];
+
+        for (var _j = 0; _j < cols; _j++) {
+          M[_i][_j] = add(M[_i][_j], multiply(-1, multiply(val, M[r][_j])));
+        }
+      }
+
+      lead++;
+    }
+
+    return M;
+  }
+  /**
+   * Calculate the rank factorization of a matrix
+   *
+   * @param {Array[]} mat                  A matrix (M)
+   * @param {number} rows                  Number of rows
+   * @param {number} cols                  Number of columns
+   * @return {{C: Array, F: Array}}        rank factorization where M = C F
+   * @private
+   */
+
+
+  function _rankFact(mat, rows, cols) {
+    var rref = _rref(mat, rows, cols);
+
+    var C = mat.map((_, i) => _.filter((_, j) => j < rows && !_isZero(dot(rref[j], rref[j]))));
+    var F = rref.filter((_, i) => !_isZero(dot(rref[i], rref[i])));
+    return {
+      C,
+      F
+    };
+  }
+
+  function _isZero(x) {
+    return equal(add(x, Complex(1, 1)), add(0, Complex(1, 1)));
+  }
+
+  function _isZeros(arr) {
+    return deepEqual(add(arr, Complex(1, 1)), add(multiply(arr, 0), Complex(1, 1)));
+  }
+});

package/lib/esm/function/probability/gamma.js

@@ -107,7 +107,7 @@ export var createGamma = /* #__PURE__ */factory(name, dependencies, _ref => {
     var precision = config.precision + (Math.log(n.toNumber()) | 0);
 
     var Big = _BigNumber.clone({
-      precision: precision
+      precision
     });
 
     if (n % 2 === 1) {

package/lib/esm/function/probability/lgamma.js

@@ -0,0 +1,137 @@
+/* eslint-disable no-loss-of-precision */
+// References
+// ----------
+// [1] Hare, "Computing the Principal Branch of log-Gamma", Journal of Algorithms, 1997.
+// [2] https://math.stackexchange.com/questions/1338753/how-do-i-calculate-values-for-gamma-function-with-complex-arguments
+import { lgammaNumber, lnSqrt2PI } from '../../plain/number/index.js';
+import { factory } from '../../utils/factory.js';
+import { copysign } from '../../utils/number.js';
+var name = 'lgamma';
+var dependencies = ['Complex', 'typed'];
+export var createLgamma = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    Complex: _Complex,
+    typed
+  } = _ref;
+  // Stirling series is non-convergent, we need to use the recurrence `lgamma(z) = lgamma(z+1) - log z` to get
+  // sufficient accuracy.
+  //
+  // These two values are copied from Scipy implementation:
+  // https://github.com/scipy/scipy/blob/v1.8.0/scipy/special/_loggamma.pxd#L37
+  var SMALL_RE = 7;
+  var SMALL_IM = 7;
+  /**
+   * The coefficients are B[2*n]/(2*n*(2*n - 1)) where B[2*n] is the (2*n)th Bernoulli number. See (1.1) in [1].
+   *
+   * If you cannot access the paper, can also get these values from the formula in [2].
+   *
+   *    1 /     12 = 0.00833333333333333333333333333333
+   *    1 /    360 = 0.00277777777777777777777777777778
+   * ...
+   * 3617 / 133400 = 0.02955065359477124183006535947712
+   */
+
+  var coeffs = [-2.955065359477124183e-2, 6.4102564102564102564e-3, -1.9175269175269175269e-3, 8.4175084175084175084e-4, -5.952380952380952381e-4, 7.9365079365079365079e-4, -2.7777777777777777778e-3, 8.3333333333333333333e-2];
+  /**
+   * Logarithm of the gamma function for real, positive numbers and complex numbers,
+   * using Lanczos approximation for numbers and Stirling series for complex numbers.
+   *
+   * Syntax:
+   *
+   *    math.lgamma(n)
+   *
+   * Examples:
+   *
+   *    math.lgamma(5)       // returns 3.178053830347945
+   *    math.lgamma(0)       // returns Infinity
+   *    math.lgamma(-0.5)    // returns NaN
+   *    math.lgamma(math.i)  // returns -0.6509231993018536 - 1.8724366472624294i
+   *
+   * See also:
+   *
+   *    gamma
+   *
+   * @param {number | Complex} n   A real or complex number
+   * @return {number | Complex}    The log gamma of `n`
+   */
+
+  return typed(name, {
+    number: lgammaNumber,
+    Complex: function Complex(n) {
+      var TWOPI = 6.2831853071795864769252842; // 2*pi
+
+      var LOGPI = 1.1447298858494001741434262; // log(pi)
+
+      var REFLECTION = 0.1;
+
+      if (n.isNaN()) {
+        return new _Complex(NaN, NaN);
+      } else if (n.im === 0) {
+        return new _Complex(lgammaNumber(n.re), 0);
+      } else if (n.re >= SMALL_RE || Math.abs(n.im) >= SMALL_IM) {
+        return lgammaStirling(n);
+      } else if (n.re <= REFLECTION) {
+        // Reflection formula. see Proposition 3.1 in [1]
+        var tmp = copysign(TWOPI, n.im) * Math.floor(0.5 * n.re + 0.25); // TODO: `complex.js sin` doesn't have extremely high precision, so this value `a` may lose a little precision,
+        // causing the computation results to be less accurate than the lgamma of real numbers
+
+        var a = n.mul(Math.PI).sin().log();
+        var b = this(new _Complex(1 - n.re, -n.im));
+        return new _Complex(LOGPI, tmp).sub(a).sub(b);
+      } else if (n.im >= 0) {
+        return lgammaRecurrence(n);
+      } else {
+        return lgammaRecurrence(n.conjugate()).conjugate();
+      }
+    },
+    BigNumber: function BigNumber() {
+      throw new Error("mathjs doesn't yet provide an implementation of the algorithm lgamma for BigNumber");
+    }
+  });
+
+  function lgammaStirling(z) {
+    // formula ref in [2]
+    // computation ref:
+    // https://github.com/scipy/scipy/blob/v1.8.0/scipy/special/_loggamma.pxd#L101
+    // left part
+    // x (log(x) - 1) + 1/2 (log(2PI) - log(x))
+    // => (x - 0.5) * log(x) - x + log(2PI) / 2
+    var leftPart = z.sub(0.5).mul(z.log()).sub(z).add(lnSqrt2PI); // right part
+
+    var rz = new _Complex(1, 0).div(z);
+    var rzz = rz.div(z);
+    var a = coeffs[0];
+    var b = coeffs[1];
+    var r = 2 * rzz.re;
+    var s = rzz.re * rzz.re + rzz.im * rzz.im;
+
+    for (var i = 2; i < 8; i++) {
+      var tmp = b;
+      b = -s * a + coeffs[i];
+      a = r * a + tmp;
+    }
+
+    var rightPart = rz.mul(rzz.mul(a).add(b)); // plus left and right
+
+    return leftPart.add(rightPart);
+  }
+
+  function lgammaRecurrence(z) {
+    // computation ref:
+    // https://github.com/scipy/scipy/blob/v1.8.0/scipy/special/_loggamma.pxd#L78
+    var signflips = 0;
+    var sb = 0;
+    var shiftprod = z;
+    z = z.add(1);
+
+    while (z.re <= SMALL_RE) {
+      shiftprod = shiftprod.mul(z);
+      var nsb = shiftprod.im < 0 ? 1 : 0;
+      if (nsb !== 0 && sb === 0) signflips++;
+      sb = nsb;
+      z = z.add(1);
+    }
+
+    return lgammaStirling(z).sub(shiftprod.log()).sub(new _Complex(0, signflips * 2 * Math.PI * 1));
+  }
+});

package/lib/esm/function/string/bin.js

@@ -37,7 +37,7 @@ export var createBin = factory(name, dependencies, _ref => {
     'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
       return format(n, {
         notation: 'bin',
-        wordSize: wordSize
+        wordSize
       });
     }
   });

package/lib/esm/function/string/hex.js

@@ -37,7 +37,7 @@ export var createHex = factory(name, dependencies, _ref => {
     'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
       return format(n, {
         notation: 'hex',
-        wordSize: wordSize
+        wordSize
       });
     }
   });

package/lib/esm/function/string/oct.js

@@ -37,7 +37,7 @@ export var createOct = factory(name, dependencies, _ref => {
     'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
       return format(n, {
         notation: 'oct',
-        wordSize: wordSize
+        wordSize
       });
     }
   });

package/lib/esm/plain/number/arithmetic.js

@@ -1,4 +1,4 @@
-import { isInteger, log2, log10, cbrt, expm1, sign, toFixed, log1p } from '../../utils/number.js';
+import { cbrt, expm1, isInteger, log10, log1p, log2, sign, toFixed } from '../../utils/number.js';
 var n1 = 'number';
 var n2 = 'number, number';
 export function absNumber(a) {
@@ -33,10 +33,6 @@ export function cbrtNumber(x) {
   return cbrt(x);
 }
 cbrtNumber.signature = n1;
-export function ceilNumber(x) {
-  return Math.ceil(x);
-}
-ceilNumber.signature = n1;
 export function cubeNumber(x) {
   return x * x * x;
 }
@@ -49,14 +45,6 @@ export function expm1Number(x) {
   return expm1(x);
 }
 expm1Number.signature = n1;
-export function fixNumber(x) {
-  return x > 0 ? Math.floor(x) : Math.ceil(x);
-}
-fixNumber.signature = n1;
-export function floorNumber(x) {
-  return Math.floor(x);
-}
-floorNumber.signature = n1;
 /**
  * Calculate gcd for numbers
  * @param {number} a
@@ -112,15 +100,19 @@ export function lcmNumber(a, b) {
 }
 lcmNumber.signature = n2;
 /**
- * Calculate the logarithm of a value.
+ * Calculate the logarithm of a value, optionally to a given base.
  * @param {number} x
+ * @param {number | null | undefined} base
  * @return {number}
  */
 
-export function logNumber(x) {
+export function logNumber(x, y) {
+  if (y) {
+    return Math.log(x) / Math.log(y);
+  }
+
   return Math.log(x);
 }
-logNumber.signature = n1;
 /**
  * Calculate the 10-base logarithm of a number
  * @param {number} x
@@ -178,11 +170,12 @@ modNumber.signature = n2;
  * Calculate the nth root of a, solve x^root == a
  * http://rosettacode.org/wiki/Nth_root#JavaScript
  * @param {number} a
- * @param {number} root
+ * @param {number} [2] root
  * @private
  */
 
-export function nthRootNumber(a, root) {
+export function nthRootNumber(a) {
+  var root = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
   var inv = root < 0;
 
   if (inv) {
@@ -232,7 +225,6 @@ export function nthRootNumber(a, root) {
    return inv ? 1 / x : x
   */
 }
-nthRootNumber.signature = n2;
 export function signNumber(x) {
   return sign(x);
 }
@@ -321,9 +313,13 @@ powNumber.signature = n2;
 
 export function roundNumber(value) {
   var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+  if (!isInteger(decimals) || decimals < 0 || decimals > 15) {
+    throw new Error('Number of decimals in function round must be an integer from 0 to 15 inclusive');
+  }
+
   return parseFloat(toFixed(value, decimals));
 }
-roundNumber.signature = n2;
 /**
  * Calculate the norm of a number, the absolute value.
  * @param {number} x