mathjs 10.4.2 → 10.5.1

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/header.js

@@ -6,8 +6,8 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 10.4.2
- * @date    2022-03-29
+ * @version 10.5.1
+ * @date    2022-05-02
  *
  * @license
  * Copyright (C) 2013-2022 Jos de Jong <wjosdejong@gmail.com>

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

@@ -6,13 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.absNumber = absNumber;
 exports.addNumber = addNumber;
 exports.cbrtNumber = cbrtNumber;
-exports.ceilNumber = ceilNumber;
 exports.cubeNumber = cubeNumber;
 exports.divideNumber = divideNumber;
 exports.expNumber = expNumber;
 exports.expm1Number = expm1Number;
-exports.fixNumber = fixNumber;
-exports.floorNumber = floorNumber;
 exports.gcdNumber = gcdNumber;
 exports.lcmNumber = lcmNumber;
 exports.log10Number = log10Number;
@@ -86,12 +83,6 @@ function cbrtNumber(x) {
 
 cbrtNumber.signature = n1;
 
-function ceilNumber(x) {
-  return Math.ceil(x);
-}
-
-ceilNumber.signature = n1;
-
 function cubeNumber(x) {
   return x * x * x;
 }
@@ -109,18 +100,6 @@ function expm1Number(x) {
 }
 
 expm1Number.signature = n1;
-
-function fixNumber(x) {
-  return x > 0 ? Math.floor(x) : Math.ceil(x);
-}
-
-fixNumber.signature = n1;
-
-function floorNumber(x) {
-  return Math.floor(x);
-}
-
-floorNumber.signature = n1;
 /**
  * Calculate gcd for numbers
  * @param {number} a
@@ -178,22 +157,26 @@ 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}
  */
 
-function logNumber(x) {
+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
  * @return {number}
  */
 
+
 function log10Number(x) {
   return (0, _number.log10)(x);
 }
@@ -249,11 +232,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
  */
 
-function nthRootNumber(a, root) {
+function nthRootNumber(a) {
+  var root = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
   var inv = root < 0;
 
   if (inv) {
@@ -304,8 +288,6 @@ function nthRootNumber(a, root) {
   */
 }
 
-nthRootNumber.signature = n2;
-
 function signNumber(x) {
   return (0, _number.sign)(x);
 }
@@ -401,16 +383,20 @@ powNumber.signature = n2;
 
 function roundNumber(value) {
   var decimals = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+
+  if (!(0, _number.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((0, _number.toFixed)(value, decimals));
 }
-
-roundNumber.signature = n2;
 /**
  * Calculate the norm of a number, the absolute value.
  * @param {number} x
  * @return {number}
  */
 
+
 function normNumber(x) {
   return Math.abs(x);
 }

package/lib/cjs/plain/number/probability.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.gammaG = void 0;
 exports.gammaNumber = gammaNumber;
-exports.gammaP = void 0;
+exports.lgammaN = exports.lgammaG = exports.gammaP = void 0;
+exports.lgammaNumber = lgammaNumber;
+exports.lnSqrt2PI = exports.lgammaSeries = void 0;
 
 var _number = require("../../utils/number.js");
 
@@ -59,5 +61,43 @@ gammaNumber.signature = 'number'; // TODO: comment on the variables g and p
 
 var gammaG = 4.7421875;
 exports.gammaG = gammaG;
-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];
-exports.gammaP = gammaP;
+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
+
+exports.gammaP = gammaP;
+var lnSqrt2PI = 0.91893853320467274178;
+exports.lnSqrt2PI = lnSqrt2PI;
+var lgammaG = 5; // Lanczos parameter "g"
+
+exports.lgammaG = lgammaG;
+var lgammaN = 7; // Range of coefficients "n"
+
+exports.lgammaN = lgammaN;
+var lgammaSeries = [1.000000000190015, 76.18009172947146, -86.50532032941677, 24.01409824083091, -1.231739572450155, 0.1208650973866179e-2, -0.5395239384953e-5];
+exports.lgammaSeries = lgammaSeries;
+
+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/cjs/type/matrix/function/sparse.js

@@ -17,6 +17,9 @@ var createSparse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    * Create a Sparse Matrix. The function creates a new `math.Matrix` object from
    * an `Array`. A Matrix has utility functions to manipulate the data in the
    * matrix, like getting the size and getting or setting values in the matrix.
+   * Note that a Sparse Matrix is always 2-dimensional, so for example if
+   * you create one from a plain array of _n_ numbers, you get an _n_ by 1
+   * Sparse "column vector".
    *
    * Syntax:
    *
@@ -31,6 +34,9 @@ var createSparse = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *    m.resize([3, 2], 5)
    *    m.valueOf()                     // Array [[1, 2], [3, 4], [5, 5]]
    *    m.get([1, 0])                    // number 3
+   *    let v = math.sparse([0, 0, 1])
+   *    v.size()                        // Array [3, 1]
+   *    v.get([2, 0])                   // number 1
    *
    * See also:
    *

package/lib/cjs/utils/latex.js

@@ -300,6 +300,9 @@ 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}}")
   },
@@ -322,6 +325,9 @@ 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/cjs/utils/lruQueue.js

@@ -67,6 +67,4 @@ function lruQueue(limit) {
       map = Object.create(null);
     }
   };
-}
-
-;
+}

package/lib/cjs/utils/number.js

@@ -3,7 +3,9 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.cosh = exports.cbrt = exports.atanh = exports.asinh = exports.acosh = exports.DBL_EPSILON = void 0;
+exports.cbrt = exports.atanh = exports.asinh = exports.acosh = exports.DBL_EPSILON = void 0;
+exports.copysign = copysign;
+exports.cosh = void 0;
 exports.digits = digits;
 exports.expm1 = void 0;
 exports.format = format;
@@ -752,5 +754,18 @@ 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}
+ */
+
+
+exports.tanh = tanh;
 
-exports.tanh = tanh;
+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/cjs/utils/object.js

@@ -232,7 +232,9 @@ function canDefineProperty() {
   try {
     if (Object.defineProperty) {
       Object.defineProperty({}, 'x', {
-        get: function get() {}
+        get: function get() {
+          return null;
+        }
       });
       return true;
     }

package/lib/cjs/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = '10.4.2'; // Note: This file is automatically generated when building math.js.
+var version = '10.5.1'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.
 
 exports.version = version;

package/lib/esm/entry/dependenciesAny/dependenciesCeil.generated.js

@@ -2,15 +2,19 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
 import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { roundDependencies } from './dependenciesRound.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
+import { zerosDependencies } from './dependenciesZeros.generated.js';
 import { createCeil } from '../../factoriesAny.js';
 export var ceilDependencies = {
+  DenseMatrixDependencies,
   equalScalarDependencies,
   matrixDependencies,
   roundDependencies,
   typedDependencies,
+  zerosDependencies,
   createCeil
 };

package/lib/esm/entry/dependenciesAny/dependenciesDet.generated.js

@@ -2,7 +2,8 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
-import { lupDependencies } from './dependenciesLup.generated.js';
+import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
+import { isZeroDependencies } from './dependenciesIsZero.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { subtractDependencies } from './dependenciesSubtract.generated.js';
@@ -10,7 +11,8 @@ import { typedDependencies } from './dependenciesTyped.generated.js';
 import { unaryMinusDependencies } from './dependenciesUnaryMinus.generated.js';
 import { createDet } from '../../factoriesAny.js';
 export var detDependencies = {
-  lupDependencies,
+  divideScalarDependencies,
+  isZeroDependencies,
   matrixDependencies,
   multiplyDependencies,
   subtractDependencies,

package/lib/esm/entry/dependenciesAny/dependenciesFix.generated.js

@@ -3,16 +3,22 @@
  * DON'T MAKE CHANGES HERE
  */
 import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
 import { ceilDependencies } from './dependenciesCeil.generated.js';
+import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
 import { floorDependencies } from './dependenciesFloor.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
+import { zerosDependencies } from './dependenciesZeros.generated.js';
 import { createFix } from '../../factoriesAny.js';
 export var fixDependencies = {
   ComplexDependencies,
+  DenseMatrixDependencies,
   ceilDependencies,
+  equalScalarDependencies,
   floorDependencies,
   matrixDependencies,
   typedDependencies,
+  zerosDependencies,
   createFix
 };

package/lib/esm/entry/dependenciesAny/dependenciesFloor.generated.js

@@ -2,15 +2,19 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { DenseMatrixDependencies } from './dependenciesDenseMatrixClass.generated.js';
 import { equalScalarDependencies } from './dependenciesEqualScalar.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { roundDependencies } from './dependenciesRound.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
+import { zerosDependencies } from './dependenciesZeros.generated.js';
 import { createFloor } from '../../factoriesAny.js';
 export var floorDependencies = {
+  DenseMatrixDependencies,
   equalScalarDependencies,
   matrixDependencies,
   roundDependencies,
   typedDependencies,
+  zerosDependencies,
   createFloor
 };

package/lib/esm/entry/dependenciesAny/dependenciesIndexNode.generated.js

@@ -3,12 +3,10 @@
  * DON'T MAKE CHANGES HERE
  */
 import { NodeDependencies } from './dependenciesNode.generated.js';
-import { RangeDependencies } from './dependenciesRangeClass.generated.js';
 import { sizeDependencies } from './dependenciesSize.generated.js';
 import { createIndexNode } from '../../factoriesAny.js';
 export var IndexNodeDependencies = {
   NodeDependencies,
-  RangeDependencies,
   sizeDependencies,
   createIndexNode
 };

package/lib/esm/entry/dependenciesAny/dependenciesLgamma.generated.js

@@ -0,0 +1,12 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createLgamma } from '../../factoriesAny.js';
+export var lgammaDependencies = {
+  ComplexDependencies,
+  typedDependencies,
+  createLgamma
+};

package/lib/esm/entry/dependenciesAny/dependenciesPinv.generated.js

@@ -0,0 +1,32 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
+import { addDependencies } from './dependenciesAdd.generated.js';
+import { ctransposeDependencies } from './dependenciesCtranspose.generated.js';
+import { deepEqualDependencies } from './dependenciesDeepEqual.generated.js';
+import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
+import { dotDependencies } from './dependenciesDot.generated.js';
+import { dotDivideDependencies } from './dependenciesDotDivide.generated.js';
+import { equalDependencies } from './dependenciesEqual.generated.js';
+import { invDependencies } from './dependenciesInv.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { multiplyDependencies } from './dependenciesMultiply.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createPinv } from '../../factoriesAny.js';
+export var pinvDependencies = {
+  ComplexDependencies,
+  addDependencies,
+  ctransposeDependencies,
+  deepEqualDependencies,
+  divideScalarDependencies,
+  dotDependencies,
+  dotDivideDependencies,
+  equalDependencies,
+  invDependencies,
+  matrixDependencies,
+  multiplyDependencies,
+  typedDependencies,
+  createPinv
+};

package/lib/esm/entry/dependenciesAny/dependenciesPow.generated.js

@@ -5,6 +5,7 @@
 import { ComplexDependencies } from './dependenciesComplexClass.generated.js';
 import { fractionDependencies } from './dependenciesFraction.generated.js';
 import { identityDependencies } from './dependenciesIdentity.generated.js';
+import { invDependencies } from './dependenciesInv.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { numberDependencies } from './dependenciesNumber.generated.js';
@@ -14,6 +15,7 @@ export var powDependencies = {
   ComplexDependencies,
   fractionDependencies,
   identityDependencies,
+  invDependencies,
   matrixDependencies,
   multiplyDependencies,
   numberDependencies,

package/lib/esm/entry/dependenciesAny/dependenciesStirlingS2.generated.js

@@ -2,6 +2,7 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { bignumberDependencies } from './dependenciesBignumber.generated.js';
 import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
 import { combinationsDependencies } from './dependenciesCombinations.generated.js';
 import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
@@ -10,11 +11,13 @@ import { isIntegerDependencies } from './dependenciesIsInteger.generated.js';
 import { isNegativeDependencies } from './dependenciesIsNegative.generated.js';
 import { largerDependencies } from './dependenciesLarger.generated.js';
 import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
 import { powDependencies } from './dependenciesPow.generated.js';
 import { subtractDependencies } from './dependenciesSubtract.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createStirlingS2 } from '../../factoriesAny.js';
 export var stirlingS2Dependencies = {
+  bignumberDependencies,
   addScalarDependencies,
   combinationsDependencies,
   divideScalarDependencies,
@@ -23,6 +26,7 @@ export var stirlingS2Dependencies = {
   isNegativeDependencies,
   largerDependencies,
   multiplyScalarDependencies,
+  numberDependencies,
   powDependencies,
   subtractDependencies,
   typedDependencies,

package/lib/esm/entry/dependenciesAny.generated.js

@@ -170,6 +170,7 @@ export { largerEqDependencies } from './dependenciesAny/dependenciesLargerEq.gen
 export { lcmDependencies } from './dependenciesAny/dependenciesLcm.generated.js';
 export { leafCountDependencies } from './dependenciesAny/dependenciesLeafCount.generated.js';
 export { leftShiftDependencies } from './dependenciesAny/dependenciesLeftShift.generated.js';
+export { lgammaDependencies } from './dependenciesAny/dependenciesLgamma.generated.js';
 export { logDependencies } from './dependenciesAny/dependenciesLog.generated.js';
 export { log10Dependencies } from './dependenciesAny/dependenciesLog10.generated.js';
 export { log1pDependencies } from './dependenciesAny/dependenciesLog1p.generated.js';
@@ -230,6 +231,7 @@ export { permutationsDependencies } from './dependenciesAny/dependenciesPermutat
 export { phiDependencies } from './dependenciesAny/dependenciesPhi.generated.js';
 export { piDependencies } from './dependenciesAny/dependenciesPi.generated.js';
 export { pickRandomDependencies } from './dependenciesAny/dependenciesPickRandom.generated.js';
+export { pinvDependencies } from './dependenciesAny/dependenciesPinv.generated.js';
 export { planckChargeDependencies } from './dependenciesAny/dependenciesPlanckCharge.generated.js';
 export { planckConstantDependencies } from './dependenciesAny/dependenciesPlanckConstant.generated.js';
 export { planckLengthDependencies } from './dependenciesAny/dependenciesPlanckLength.generated.js';

package/lib/esm/entry/dependenciesNumber/dependenciesCeil.generated.js

@@ -2,9 +2,11 @@
  * THIS FILE IS AUTO-GENERATED
  * DON'T MAKE CHANGES HERE
  */
+import { roundDependencies } from './dependenciesRound.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
 import { createCeil } from '../../factoriesNumber.js';
 export var ceilDependencies = {
+  roundDependencies,
   typedDependencies,
   createCeil
 };