mathjs 10.0.0 → 10.6.4

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

@@ -0,0 +1,223 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPinv = void 0;
+
+var _is = require("../../utils/is.js");
+
+var _array = require("../../utils/array.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _string = require("../../utils/string.js");
+
+var _object = require("../../utils/object.js");
+
+var name = 'pinv';
+var dependencies = ['typed', 'matrix', 'inv', 'deepEqual', 'equal', 'dotDivide', 'dot', 'ctranspose', 'divideScalar', 'multiply', 'add', 'Complex'];
+var createPinv = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      matrix = _ref.matrix,
+      inv = _ref.inv,
+      deepEqual = _ref.deepEqual,
+      equal = _ref.equal,
+      dotDivide = _ref.dotDivide,
+      dot = _ref.dot,
+      ctranspose = _ref.ctranspose,
+      divideScalar = _ref.divideScalar,
+      multiply = _ref.multiply,
+      add = _ref.add,
+      Complex = _ref.Complex;
+
+  /**
+   * 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 = (0, _is.isMatrix)(x) ? x.size() : (0, _array.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 ((0, _is.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: ' + (0, _string.format)(size) + ')');
+      }
+    },
+    any: function any(x) {
+      // scalar
+      if (equal(x, 0)) return (0, _object.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 _rankFact2 = _rankFact(mat, rows, cols),
+        C = _rankFact2.C,
+        F = _rankFact2.F; // 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 = (0, _object.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;
+          }
+        }
+      }
+
+      var _ref2 = [M[r], M[i]];
+      M[i] = _ref2[0];
+      M[r] = _ref2[1];
+      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(function (_, i) {
+      return _.filter(function (_, j) {
+        return j < rows && !_isZero(dot(rref[j], rref[j]));
+      });
+    });
+    var F = rref.filter(function (_, i) {
+      return !_isZero(dot(rref[i], rref[i]));
+    });
+    return {
+      C: C,
+      F: 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)));
+  }
+});
+exports.createPinv = createPinv;

package/lib/cjs/function/matrix/subset.js

@@ -39,16 +39,26 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *
    *     // replace a subset
    *     const e = []
-   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]]
+   *     const f = math.subset(e, math.index(0, [0, 2]), [5, 6])  // f = [[5, 6]] and e = [[5, 0, 6]]
    *     const g = math.subset(f, math.index(1, 1), 7, 0)         // g = [[5, 6], [0, 7]]
    *
+   *     // get submatrix using ranges
+   *     const M = [
+   *       [1,2,3],
+   *       [4,5,6],
+   *       [7,8,9]
+   *     ]
+   *     math.subset(M, math.index(math.range(0,2), math.range(0,3))) // [[1,2,3],[4,5,6]]
+   *
    * See also:
    *
    *     size, resize, squeeze, index
    *
    * @param {Array | Matrix | string} matrix  An array, matrix, or string
-   * @param {Index} index                     An index containing ranges for each
-   *                                          dimension
+   * @param {Index} index
+   *    For each dimension of the target, specifies an index or a list of
+   *    indices to fetch or set. `subset` uses the cartesian product of
+   *    the indices specified in each dimension.
    * @param {*} [replacement]                 An array, matrix, or scalar.
    *                                          If provided, the subset is replaced with replacement.
    *                                          If not provided, the subset is returned
@@ -91,7 +101,7 @@ var createSubset = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
 /**
  * Retrieve a subset of a string
  * @param {string} str            string from which to get a substring
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @returns {string} substring
  * @private
  */
@@ -122,7 +132,7 @@ function _getSubstring(str, index) {
 /**
  * Replace a substring in a string
  * @param {string} str            string to be replaced
- * @param {Index} index           An index containing ranges for each dimension
+ * @param {Index} index           An index or list of indices (character positions)
  * @param {string} replacement    Replacement string
  * @param {string} [defaultValue] Default value to be uses when resizing
  *                                the string. is ' ' by default

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

@@ -49,44 +49,42 @@ var createGamma = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     Complex: function Complex(n) {
       if (n.im === 0) {
         return this(n.re);
-      }
+      } // Lanczos approximation doesn't work well with real part lower than 0.5
+      // So reflection formula is required
+
+
+      if (n.re < 0.5) {
+        // Euler's reflection formula
+        // gamma(1-z) * gamma(z) = PI / sin(PI * z)
+        // real part of Z should not be integer [sin(PI) == 0 -> 1/0 - undefined]
+        // thanks to imperfect sin implementation sin(PI * n) != 0
+        // we can safely use it anyway
+        var _t = new _Complex(1 - n.re, -n.im);
+
+        var r = new _Complex(Math.PI * n.re, Math.PI * n.im);
+        return new _Complex(Math.PI).div(r.sin()).div(this(_t));
+      } // Lanczos approximation
+      // z -= 1
+
 
-      n = new _Complex(n.re - 1, n.im);
-      var x = new _Complex(_index.gammaP[0], 0);
+      n = new _Complex(n.re - 1, n.im); // x = gammaPval[0]
+
+      var x = new _Complex(_index.gammaP[0], 0); // for (i, gammaPval) in enumerate(gammaP):
 
       for (var i = 1; i < _index.gammaP.length; ++i) {
-        var real = n.re + i; // x += p[i]/(n+i)
+        // x += gammaPval / (z + i)
+        var gammaPval = new _Complex(_index.gammaP[i], 0);
+        x = x.add(gammaPval.div(n.add(i)));
+      } // t = z + gammaG + 0.5
 
-        var den = real * real + n.im * n.im;
 
-        if (den !== 0) {
-          x.re += _index.gammaP[i] * real / den;
-          x.im += -(_index.gammaP[i] * n.im) / den;
-        } else {
-          x.re = _index.gammaP[i] < 0 ? -Infinity : Infinity;
-        }
-      }
+      var t = new _Complex(n.re + _index.gammaG + 0.5, n.im); // y = sqrt(2 * pi) * t ** (z + 0.5) * exp(-t) * x
 
-      var t = new _Complex(n.re + _index.gammaG + 0.5, n.im);
       var twoPiSqrt = Math.sqrt(2 * Math.PI);
-      n.re += 0.5;
-      var result = pow(t, n);
-
-      if (result.im === 0) {
-        // sqrt(2*PI)*result
-        result.re *= twoPiSqrt;
-      } else if (result.re === 0) {
-        result.im *= twoPiSqrt;
-      } else {
-        result.re *= twoPiSqrt;
-        result.im *= twoPiSqrt;
-      }
-
-      var r = Math.exp(-t.re); // exp(-t)
+      var tpow = t.pow(n.add(0.5));
+      var expt = t.neg().exp(); // y = [x] * [sqrt(2 * pi)] * [t ** (z + 0.5)] * [exp(-t)]
 
-      t.re = r * Math.cos(-t.im);
-      t.im = r * Math.sin(-t.im);
-      return multiplyScalar(multiplyScalar(result, t), x);
+      return x.mul(twoPiSqrt).mul(tpow).mul(expt);
     },
     BigNumber: function BigNumber(n) {
       if (n.isInteger()) {

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

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLgamma = void 0;
+
+var _index = require("../../plain/number/index.js");
+
+var _factory = require("../../utils/factory.js");
+
+var _number = require("../../utils/number.js");
+
+/* 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
+var name = 'lgamma';
+var dependencies = ['Complex', 'typed'];
+var createLgamma = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var _Complex = _ref.Complex,
+      typed = _ref.typed;
+  // 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: _index.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((0, _index.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 = (0, _number.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(_index.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));
+  }
+});
+exports.createLgamma = createLgamma;

package/lib/cjs/function/probability/util/seededRNG.js

@@ -9,13 +9,13 @@ exports.createRng = createRng;
 
 var _seedrandom = _interopRequireDefault(require("seedrandom"));
 
-var singletonRandom = /* #__PURE__ */(0, _seedrandom["default"])(Date.now());
+var singletonRandom = /* #__PURE__ */(0, _seedrandom.default)(Date.now());
 
 function createRng(randomSeed) {
   var random; // create a new random generator with given seed
 
   function setSeed(seed) {
-    random = seed === null ? singletonRandom : (0, _seedrandom["default"])(String(seed));
+    random = seed === null ? singletonRandom : (0, _seedrandom.default)(String(seed));
   } // initialize a seeded pseudo random number generator with config's random seed
 
 

package/lib/cjs/function/relational/compareNatural.js

@@ -101,7 +101,7 @@ var createCompareNatural = /* #__PURE__ */(0, _factory.factory)(name, dependenci
           // c can be number, BigNumber, or Fraction
           return c > 0 ? 1 : -1; // return a number
         } else {
-          return (0, _javascriptNaturalSort["default"])(typeX, typeY);
+          return (0, _javascriptNaturalSort.default)(typeX, typeY);
         }
       } // matrix types
 
@@ -112,13 +112,13 @@ var createCompareNatural = /* #__PURE__ */(0, _factory.factory)(name, dependenci
         if (c !== 0) {
           return c;
         } else {
-          return (0, _javascriptNaturalSort["default"])(typeX, typeY);
+          return (0, _javascriptNaturalSort.default)(typeX, typeY);
         }
       } // in case of different types, order by name of type, i.e. 'BigNumber' < 'Complex'
 
 
       if (typeX !== typeY) {
-        return (0, _javascriptNaturalSort["default"])(typeX, typeY);
+        return (0, _javascriptNaturalSort.default)(typeX, typeY);
       }
 
       if (typeX === 'Complex') {
@@ -139,7 +139,7 @@ var createCompareNatural = /* #__PURE__ */(0, _factory.factory)(name, dependenci
       }
 
       if (typeX === 'string') {
-        return (0, _javascriptNaturalSort["default"])(x, y);
+        return (0, _javascriptNaturalSort.default)(x, y);
       }
 
       if (typeX === 'Object') {
@@ -252,8 +252,8 @@ var createCompareNatural = /* #__PURE__ */(0, _factory.factory)(name, dependenci
     var keysX = Object.keys(x);
     var keysY = Object.keys(y); // compare keys
 
-    keysX.sort(_javascriptNaturalSort["default"]);
-    keysY.sort(_javascriptNaturalSort["default"]);
+    keysX.sort(_javascriptNaturalSort.default);
+    keysY.sort(_javascriptNaturalSort.default);
     var c = compareArrays(compareNatural, keysX, keysY);
 
     if (c !== 0) {