mathjs 10.4.2 → 10.5.1

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

@@ -1,20 +1,14 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createRoundNumber = exports.createRound = void 0;
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+exports.createRound = void 0;
 
 var _factory = require("../../utils/factory.js");
 
 var _collection = require("../../utils/collection.js");
 
-var _number = require("../../utils/number.js");
-
 var _algorithm = require("../../type/matrix/utils/algorithm11.js");
 
 var _algorithm2 = require("../../type/matrix/utils/algorithm12.js");
@@ -23,10 +17,6 @@ var _algorithm3 = require("../../type/matrix/utils/algorithm14.js");
 
 var _index = require("../../plain/number/index.js");
 
-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) { (0, _defineProperty2.default)(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; }
-
 var NO_INT = 'Number of decimals in function round must be an integer';
 var name = 'round';
 var dependencies = ['typed', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix'];
@@ -84,7 +74,16 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
    * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
    */
 
-  return typed(name, _objectSpread(_objectSpread({}, roundNumberSignatures), {}, {
+  return typed(name, {
+    number: _index.roundNumber,
+    'number, number': _index.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();
     },
@@ -104,13 +103,6 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       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);
     },
@@ -131,6 +123,13 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       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 (0, _collection.deepMap)(x, this, true);
@@ -141,7 +140,11 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
     '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
@@ -150,7 +153,7 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       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
@@ -159,33 +162,10 @@ var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, funct
 
       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();
     }
-  }));
-});
-exports.createRound = createRound;
-var roundNumberSignatures = {
-  number: _index.roundNumber,
-  'number, number': function numberNumber(x, n) {
-    if (!(0, _number.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 (0, _index.roundNumber)(x, n);
-  }
-};
-var createRoundNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed'], function (_ref2) {
-  var typed = _ref2.typed;
-  return typed(name, roundNumberSignatures);
+  });
 });
-exports.createRoundNumber = createRoundNumber;
+exports.createRound = createRound;

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

@@ -7,8 +7,10 @@ exports.createStirlingS2 = void 0;
 
 var _factory = require("../../utils/factory.js");
 
+var _is = require("../../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'];
 var createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       addScalar = _ref.addScalar,
@@ -20,15 +22,22 @@ var createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
       combinations = _ref.combinations,
       isNegative = _ref.isNegative,
       isInteger = _ref.isInteger,
+      number = _ref.number,
+      bignumber = _ref.bignumber,
       larger = _ref.larger;
-
+  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:
    *
@@ -46,26 +55,47 @@ var createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    * @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 = !((0, _is.isNumber)(n) && (0, _is.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/cjs/function/matrix/det.js

@@ -14,14 +14,15 @@ var _string = require("../../utils/string.js");
 var _factory = require("../../utils/factory.js");
 
 var name = 'det';
-var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'unaryMinus', 'lup'];
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
 var createDet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
       matrix = _ref.matrix,
       subtract = _ref.subtract,
       multiply = _ref.multiply,
-      unaryMinus = _ref.unaryMinus,
-      lup = _ref.lup;
+      divideScalar = _ref.divideScalar,
+      isZero = _ref.isZero,
+      unaryMinus = _ref.unaryMinus;
 
   /**
    * Calculate the determinant of a matrix.
@@ -115,42 +116,47 @@ var createDet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functio
       // 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(function (_, i) {
+        return 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/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;