mathjs 10.4.3 → 10.5.0

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, 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, 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 { factory } from './utils/factory.js';
 import { noIndex, noMatrix, noSubset } from './utils/noop.js'; // ----------------------------------------------------------------------------
 // classes and functions
@@ -118,6 +118,7 @@ export { createPartitionSelect } from './function/matrix/partitionSelect.js'; //
 
 export var createCombinations = createNumberFactory('combinations', combinationsNumber);
 export var createGamma = createNumberFactory('gamma', gammaNumber);
+export var createLgamma = createNumberFactory('lgamma', lgammaNumber);
 export { createCombinationsWithRep } from './function/probability/combinationsWithRep.js';
 export { createFactorial } from './function/probability/factorial.js';
 export { createMultinomial } from './function/probability/multinomial.js';

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/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/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/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/plain/number/probability.js

@@ -46,4 +46,36 @@ export function gammaNumber(n) {
 gammaNumber.signature = 'number'; // TODO: comment on the variables g and p
 
 export var gammaG = 4.7421875;
-export var gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5];
+export var gammaP = [0.99999999999999709182, 57.156235665862923517, -59.597960355475491248, 14.136097974741747174, -0.49191381609762019978, 0.33994649984811888699e-4, 0.46523628927048575665e-4, -0.98374475304879564677e-4, 0.15808870322491248884e-3, -0.21026444172410488319e-3, 0.21743961811521264320e-3, -0.16431810653676389022e-3, 0.84418223983852743293e-4, -0.26190838401581408670e-4, 0.36899182659531622704e-5]; // lgamma implementation ref: https://mrob.com/pub/ries/lanczos-gamma.html#code
+// log(2 * pi) / 2
+
+export var lnSqrt2PI = 0.91893853320467274178;
+export var lgammaG = 5; // Lanczos parameter "g"
+
+export var lgammaN = 7; // Range of coefficients "n"
+
+export var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+export function lgammaNumber(n) {
+  if (n < 0) return NaN;
+  if (n === 0) return Infinity;
+  if (!isFinite(n)) return n;
+
+  if (n < 0.5) {
+    // Use Euler's reflection formula:
+    // gamma(z) = PI / (sin(PI * z) * gamma(1 - z))
+    return Math.log(Math.PI / Math.sin(Math.PI * n)) - lgammaNumber(1 - n);
+  } // Compute the logarithm of the Gamma function using the Lanczos method
+
+
+  n = n - 1;
+  var base = n + lgammaG + 0.5; // Base of the Lanczos exponential
+
+  var sum = lgammaSeries[0]; // We start with the terms that have the smallest coefficients and largest denominator
+
+  for (var i = lgammaN - 1; i >= 1; i--) {
+    sum += lgammaSeries[i] / (n + i);
+  }
+
+  return lnSqrt2PI + (n + 0.5) * Math.log(base) - base + Math.log(sum);
+}
+lgammaNumber.signature = 'number';

package/lib/esm/utils/latex.js

@@ -284,6 +284,9 @@ export var latexFunctions = {
   inv: {
     1: '\\left(${args[0]}\\right)^{-1}'
   },
+  pinv: {
+    1: '\\left(${args[0]}\\right)^{+}'
+  },
   sqrtm: {
     1: "{${args[0]}}".concat(latexOperators.pow, "{\\frac{1}{2}}")
   },
@@ -306,6 +309,9 @@ export var latexFunctions = {
   gamma: {
     1: '\\Gamma\\left(${args[0]}\\right)'
   },
+  lgamma: {
+    1: '\\ln\\Gamma\\left(${args[0]}\\right)'
+  },
   // relational
   equal: {
     2: "\\left(${args[0]}".concat(latexOperators.equal, "${args[1]}\\right)")

package/lib/esm/utils/number.js

@@ -685,4 +685,16 @@ export var sinh = Math.sinh || function (x) {
 export var tanh = Math.tanh || function (x) {
   var e = Math.exp(2 * x);
   return (e - 1) / (e + 1);
-};
+};
+/**
+ * Returns a value with the magnitude of x and the sign of y.
+ * @param {number} x
+ * @param {number} y
+ * @returns {number}
+ */
+
+export function copysign(x, y) {
+  var signx = x > 0 ? true : x < 0 ? false : 1 / x === Infinity;
+  var signy = y > 0 ? true : y < 0 ? false : 1 / y === Infinity;
+  return signx ^ signy ? -x : x;
+}

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '10.4.3'; // Note: This file is automatically generated when building math.js.
+export var version = '10.5.0'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "10.4.3",
+  "version": "10.5.0",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,8 +25,8 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.17.8",
-    "complex.js": "^2.1.0",
+    "@babel/runtime": "^7.17.9",
+    "complex.js": "^2.1.1",
     "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
     "fraction.js": "^4.2.0",
@@ -36,7 +36,7 @@
     "typed-function": "^2.1.0"
   },
   "devDependencies": {
-    "@babel/core": "7.17.8",
+    "@babel/core": "7.17.9",
     "@babel/plugin-transform-object-assign": "7.16.7",
     "@babel/plugin-transform-runtime": "7.17.0",
     "@babel/preset-env": "7.16.11",
@@ -46,7 +46,7 @@
     "babel-loader": "8.2.4",
     "benchmark": "2.1.4",
     "codecov": "3.8.3",
-    "core-js": "3.21.1",
+    "core-js": "3.22.0",
     "del": "6.0.0",
     "dtslint": "4.2.1",
     "expect-type": "^0.13.0",
@@ -58,7 +58,7 @@
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
     "jsep": "1.3.4",
-    "karma": "6.3.17",
+    "karma": "6.3.18",
     "karma-browserstack-launcher": "1.6.0",
     "karma-firefox-launcher": "2.1.2",
     "karma-mocha": "2.0.1",
@@ -79,7 +79,7 @@
     "standard": "16.0.4",
     "sylvester": "0.0.21",
     "ts-node": "10.7.0",
-    "typescript": "4.6.2",
+    "typescript": "4.6.3",
     "webpack": "4.46.0",
     "zeros": "1.0.0"
   },