@danielsimonjr/mathts-functions 0.13.3 → 0.15.0

package/dist/index.js

@@ -48,6 +48,7 @@ __export(typed_exports, {
   autoCorrelation: () => autoCorrelation,
   bandpassFilter: () => bandpassFilter,
   bartlettPSD: () => bartlettPSD,
+  bartlettTest: () => bartlettTest,
   bernoulli: () => bernoulli,
   bernoulliPMF: () => bernoulliPMF,
   besselI: () => besselI,
@@ -67,6 +68,7 @@ __export(typed_exports, {
   bin: () => bin,
   binomialDist: () => binomialDist,
   binomialPMF: () => binomialPMF,
+  binomialTest: () => binomialTest,
   bitAnd: () => bitAnd,
   bitNot: () => bitNot,
   bitOr: () => bitOr,
@@ -205,6 +207,7 @@ __export(typed_exports, {
   hex: () => hex,
   highpassFilter: () => highpassFilter,
   hilbertTransform: () => hilbertTransform,
+  hypergeometricDist: () => hypergeometricDist,
   hypot: () => hypot,
   idct: () => idct,
   idst: () => idst,
@@ -223,6 +226,7 @@ __export(typed_exports, {
   jsDivergence: () => jsDivergence,
   kdTree: () => kdTree,
   kdTreeNearest: () => kdTreeNearest,
+  kolmogorovSmirnov2Test: () => kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest: () => kolmogorovSmirnovTest,
   lagrangeInterp: () => lagrangeInterp,
   laguerreL: () => laguerreL,
@@ -234,6 +238,7 @@ __export(typed_exports, {
   leftShift: () => leftShift,
   legendreFit: () => legendreFit,
   legendreP: () => legendreP,
+  leveneTest: () => leveneTest,
   lgamma: () => lgamma,
   linearInterp: () => linearInterp,
   linprog: () => linprog,
@@ -277,6 +282,7 @@ __export(typed_exports, {
   multinomial: () => multinomial,
   multiply: () => multiply,
   nearestNeighbor: () => nearestNeighbor,
+  negativeBinomialDist: () => negativeBinomialDist,
   newtonInterp: () => newtonInterp,
   nextPrime: () => nextPrime,
   nintegrate: () => nintegrate,
@@ -354,6 +360,7 @@ __export(typed_exports, {
   principalComponentAnalysis: () => principalComponentAnalysis,
   print: () => print,
   projectVector: () => projectVector,
+  proportionZTest: () => proportionZTest,
   quadprog: () => quadprog,
   quickSelect: () => quickSelect,
   random: () => random,
@@ -410,6 +417,7 @@ __export(typed_exports, {
   stronglyConnectedComponents: () => stronglyConnectedComponents,
   studentTPDF: () => studentTPDF,
   studentTTest: () => studentTTest,
+  studentTTestPaired: () => studentTTestPaired,
   subfactorial: () => subfactorial,
   substitute: () => substitute,
   subtract: () => subtract,
@@ -12813,12 +12821,7 @@ function _normalQuantileStd(p) {
     4.374664141464968,
     2.938163982698783
   ];
-  const d = [
-    0.007784695709041462,
-    0.3224671290700398,
-    2.445134137142996,
-    3.754408661907416
-  ];
+  const d = [0.007784695709041462, 0.3224671290700398, 2.445134137142996, 3.754408661907416];
   const pLow = 0.02425;
   let x;
   if (p < pLow) {
@@ -13489,6 +13492,109 @@ function weibullDist(k, lambda = 1) {
     })
   };
 }
+function _logChoose(n, r) {
+  if (r < 0 || r > n) return -Infinity;
+  return _logFactorial2(n) - _logFactorial2(r) - _logFactorial2(n - r);
+}
+function _choose(n, r) {
+  if (r < 0 || r > n) return 0;
+  const k = Math.min(r, n - r);
+  let c = 1;
+  for (let i = 0; i < k; i++) c = c * (n - i) / (i + 1);
+  return c;
+}
+function _discreteSample(cdf, rng, cap) {
+  const u = rng();
+  for (let k = 0; k <= cap; k++) {
+    if (cdf(k) >= u) return k;
+  }
+  return cap;
+}
+function hypergeometricDist(population, successes, draws) {
+  if (![population, successes, draws].every((v) => Number.isInteger(v) && v >= 0)) {
+    throw new Error(
+      "hypergeometricDist: population, successes, draws must be non-negative integers"
+    );
+  }
+  if (successes > population || draws > population) {
+    throw new Error("hypergeometricDist: successes and draws cannot exceed population");
+  }
+  const M = population;
+  const K = successes;
+  const N = draws;
+  const kMin = Math.max(0, N - (M - K));
+  const kMax = Math.min(K, N);
+  const useExact = M <= 1e3;
+  const pmf = (k) => {
+    if (!Number.isInteger(k) || k < kMin || k > kMax) return 0;
+    return useExact ? _choose(K, k) * _choose(M - K, N - k) / _choose(M, N) : Math.exp(_logChoose(K, k) + _logChoose(M - K, N - k) - _logChoose(M, N));
+  };
+  const cdf = (k) => {
+    if (k < kMin) return 0;
+    const kk = Math.min(Math.floor(k), kMax);
+    let sum3 = 0;
+    for (let i = kMin; i <= kk; i++) sum3 += pmf(i);
+    return Math.min(1, sum3);
+  };
+  const mean6 = N * K / M;
+  const variance2 = N * (K / M) * ((M - K) / M) * ((M - N) / (M - 1));
+  return {
+    pdf: pmf,
+    cdf,
+    quantile: (p) => {
+      if (p <= 0) return kMin;
+      if (p >= 1) return kMax;
+      for (let k = kMin; k <= kMax; k++) if (cdf(k) >= p) return k;
+      return kMax;
+    },
+    mean: mean6,
+    variance: variance2,
+    sample: () => _discreteSample(cdf, Math.random, kMax),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = _discreteSample(cdf, rng, kMax);
+      return out;
+    })
+  };
+}
+function negativeBinomialDist(r, p) {
+  if (!Number.isInteger(r) || r < 1)
+    throw new Error("negativeBinomialDist: r must be a positive integer");
+  if (p <= 0 || p > 1) throw new Error("negativeBinomialDist: p must be in (0, 1]");
+  const pmf = (k) => {
+    if (!Number.isInteger(k) || k < 0) return 0;
+    return Math.exp(_logChoose(k + r - 1, k) + r * Math.log(p) + k * Math.log(1 - p));
+  };
+  const cdf = (k) => {
+    if (k < 0) return 0;
+    return Math.min(1, _betainc(p, r, Math.floor(k) + 1));
+  };
+  const mean6 = r * (1 - p) / p;
+  const variance2 = r * (1 - p) / (p * p);
+  return {
+    pdf: pmf,
+    cdf,
+    quantile: (prob) => {
+      if (prob <= 0) return 0;
+      if (prob >= 1) return Infinity;
+      let cumul = 0;
+      for (let k = 0; k < 1e5; k++) {
+        cumul += pmf(k);
+        if (cumul >= prob) return k;
+      }
+      return Infinity;
+    },
+    mean: mean6,
+    variance: variance2,
+    sample: () => _discreteSample(cdf, Math.random, Math.ceil(mean6 + 20 * Math.sqrt(variance2) + 20)),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      const cap = Math.ceil(mean6 + 20 * Math.sqrt(variance2) + 20);
+      for (let j = 0; j < count2; j++) out[j] = _discreteSample(cdf, rng, cap);
+      return out;
+    })
+  };
+}
 
 // src/typed/hypothesis.ts
 import { computePool as computePool10 } from "@danielsimonjr/mathts-parallel";
@@ -14252,6 +14358,140 @@ function principalComponentAnalysis(data, k) {
   });
   return { components: eigenvectors, explained, scores };
 }
+function _kstwobignSf(x) {
+  if (x <= 0) return 1;
+  let sum3 = 0;
+  for (let k = 1; k <= 100; k++) {
+    const term = 2 * (k % 2 === 1 ? 1 : -1) * Math.exp(-2 * k * k * x * x);
+    sum3 += term;
+    if (Math.abs(term) < 1e-15) break;
+  }
+  return Math.max(0, Math.min(1, sum3));
+}
+function kolmogorovSmirnov2Test(sample1, sample2) {
+  const n16 = sample1.length;
+  const n26 = sample2.length;
+  if (n16 < 1 || n26 < 1) {
+    throw new Error("kolmogorovSmirnov2Test: both samples must be non-empty");
+  }
+  const a = sample1.slice().sort((x, y) => x - y);
+  const b = sample2.slice().sort((x, y) => x - y);
+  let i = 0;
+  let j = 0;
+  let d = 0;
+  while (i < n16 && j < n26) {
+    const x = Math.min(a[i], b[j]);
+    while (i < n16 && a[i] <= x) i++;
+    while (j < n26 && b[j] <= x) j++;
+    d = Math.max(d, Math.abs(i / n16 - j / n26));
+  }
+  const en = Math.sqrt(n16 * n26 / (n16 + n26));
+  return { statistic: d, pValue: _kstwobignSf(en * d) };
+}
+function _median(arr7) {
+  const s = arr7.slice().sort((a, b) => a - b);
+  const n = s.length;
+  const m = n >> 1;
+  return n % 2 === 1 ? s[m] : (s[m - 1] + s[m]) / 2;
+}
+function leveneTest(groups, center = "median") {
+  const k = groups.length;
+  if (k < 2) throw new Error("leveneTest: need at least 2 groups");
+  let N = 0;
+  for (const g of groups) {
+    if (g.length < 1) throw new Error("leveneTest: every group must be non-empty");
+    N += g.length;
+  }
+  const z = groups.map((g) => {
+    const c = center === "median" ? _median(g) : _mean(g);
+    return g.map((x) => Math.abs(x - c));
+  });
+  const allZ = [];
+  for (const zi of z) for (const v of zi) allZ.push(v);
+  const zBarAll = _mean(allZ);
+  let num2 = 0;
+  let den = 0;
+  for (const zi of z) {
+    const zBarI = _mean(zi);
+    num2 += zi.length * (zBarI - zBarAll) * (zBarI - zBarAll);
+    for (const v of zi) den += (v - zBarI) * (v - zBarI);
+  }
+  const W = (N - k) / (k - 1) * (num2 / den);
+  return { statistic: W, pValue: _fPValue(W, k - 1, N - k), degreesOfFreedom: [k - 1, N - k] };
+}
+function bartlettTest(groups) {
+  const k = groups.length;
+  if (k < 2) throw new Error("bartlettTest: need at least 2 groups");
+  let N = 0;
+  for (const g of groups) {
+    if (g.length < 2) throw new Error("bartlettTest: every group needs \u22652 observations");
+    N += g.length;
+  }
+  let pooledNum = 0;
+  let sumLnVar = 0;
+  let sumInv = 0;
+  for (const g of groups) {
+    const ni = g.length;
+    const si2 = _variance(g, 1);
+    pooledNum += (ni - 1) * si2;
+    sumLnVar += (ni - 1) * Math.log(si2);
+    sumInv += 1 / (ni - 1);
+  }
+  const sp2 = pooledNum / (N - k);
+  const numerator = (N - k) * Math.log(sp2) - sumLnVar;
+  const C = 1 + (sumInv - 1 / (N - k)) / (3 * (k - 1));
+  const T = numerator / C;
+  return { statistic: T, pValue: _chiSquaredPValue(T, k - 1), degreesOfFreedom: k - 1 };
+}
+function studentTTestPaired(sample1, sample2) {
+  const n = sample1.length;
+  if (n < 2 || sample2.length !== n) {
+    throw new Error("studentTTestPaired: samples must be the same length \u2265 2");
+  }
+  const d = sample1.map((x, i) => x - sample2[i]);
+  const dBar = _mean(d);
+  const sd = Math.sqrt(_variance(d, 1));
+  const df = n - 1;
+  const t = dBar / (sd / Math.sqrt(n));
+  return { statistic: t, pValue: _tPValue(t, df), degreesOfFreedom: df };
+}
+function proportionZTest(count2, nobs, value) {
+  let z;
+  if (Array.isArray(count2) && Array.isArray(nobs)) {
+    const [c1, c2] = count2;
+    const [n16, n26] = nobs;
+    const p1 = c1 / n16;
+    const p2 = c2 / n26;
+    const pPool = (c1 + c2) / (n16 + n26);
+    z = (p1 - p2) / Math.sqrt(pPool * (1 - pPool) * (1 / n16 + 1 / n26));
+  } else if (typeof count2 === "number" && typeof nobs === "number") {
+    const p0 = value ?? 0.5;
+    const pHat = count2 / nobs;
+    z = (pHat - p0) / Math.sqrt(p0 * (1 - p0) / nobs);
+  } else {
+    throw new Error("proportionZTest: count and nobs must both be numbers or both be [a, b] pairs");
+  }
+  const pValue = erfcScalar(Math.abs(z) / Math.SQRT2);
+  return { statistic: z, pValue };
+}
+function _binomPmf(k, n, p) {
+  if (k < 0 || k > n) return 0;
+  const logC = _lgamma3(n + 1) - _lgamma3(k + 1) - _lgamma3(n - k + 1);
+  return Math.exp(logC + k * Math.log(p) + (n - k) * Math.log(1 - p));
+}
+function binomialTest(successes, n, p = 0.5) {
+  if (!Number.isInteger(successes) || !Number.isInteger(n) || successes < 0 || successes > n) {
+    throw new Error("binomialTest: successes must be an integer in [0, n]");
+  }
+  const dObs = _binomPmf(successes, n, p);
+  const rel = 1 + 1e-7;
+  let pValue = 0;
+  for (let k = 0; k <= n; k++) {
+    const pk = _binomPmf(k, n, p);
+    if (pk <= dObs * rel) pValue += pk;
+  }
+  return { statistic: successes / n, pValue: Math.min(1, pValue) };
+}
 
 // src/typed/matrix-ops.ts
 import {
@@ -17242,9 +17482,9 @@ var createExpm1 = /* @__PURE__ */ factory(
 );
 
 // src/utils/bigint.ts
-function promoteLogarithm(log162, numberLog, config, cplx) {
+function promoteLogarithm(log162, numberLog, config2, cplx) {
   return function(b) {
-    if (b > 0 || config.predictable) {
+    if (b > 0 || config2.predictable) {
       if (b <= 0) return NaN;
       const s = b.toString(16);
       const s15 = s.substring(0, 15);
@@ -17261,7 +17501,7 @@ var log16 = log10Number(16);
 var createLog10 = /* @__PURE__ */ factory(
   name6,
   dependencies6,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     function complexLog(c) {
       return c.log().div(Math.LN10);
     }
@@ -17270,16 +17510,16 @@ var createLog10 = /* @__PURE__ */ factory(
     }
     return typed3(name6, {
       number: function(x) {
-        if (x >= 0 || config.predictable) {
+        if (x >= 0 || config2.predictable) {
           return log10Number(x);
         } else {
           return complexLogNumber(x);
         }
       },
-      bigint: promoteLogarithm(log16, log10Number, config, complexLogNumber),
+      bigint: promoteLogarithm(log16, log10Number, config2, complexLogNumber),
       Complex: complexLog,
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.log();
         } else {
           return complexLogNumber(x.toNumber());
@@ -17298,22 +17538,22 @@ var dependencies7 = ["typed", "config", "Complex"];
 var createLog2 = /* @__PURE__ */ factory(
   name7,
   dependencies7,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     function complexLog2Number(x) {
       return _log2Complex(new Complex12(x, 0));
     }
     return typed3(name7, {
       number: function(x) {
-        if (x >= 0 || config.predictable) {
+        if (x >= 0 || config2.predictable) {
           return log2Number(x);
         } else {
           return complexLog2Number(x);
         }
       },
-      bigint: promoteLogarithm(4, log2Number, config, complexLog2Number),
+      bigint: promoteLogarithm(4, log2Number, config2, complexLog2Number),
       Complex: _log2Complex,
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.log(2);
         } else {
           return complexLog2Number(x.toNumber());
@@ -17401,14 +17641,14 @@ var dependencies10 = ["config", "typed", "Complex"];
 var createSqrt = /* @__PURE__ */ factory(
   name10,
   dependencies10,
-  ({ config, typed: typed3, Complex: Complex12 }) => {
+  ({ config: config2, typed: typed3, Complex: Complex12 }) => {
     return typed3("sqrt", {
       number: _sqrtNumber,
       Complex: function(x) {
         return x.sqrt();
       },
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.sqrt();
         } else {
           return _sqrtNumber(x.toNumber());
@@ -17421,7 +17661,7 @@ var createSqrt = /* @__PURE__ */ factory(
     function _sqrtNumber(x) {
       if (isNaN(x)) {
         return NaN;
-      } else if (x >= 0 || config.predictable) {
+      } else if (x >= 0 || config2.predictable) {
         return Math.sqrt(x);
       } else {
         return new Complex12(x, 0).sqrt();
@@ -17504,7 +17744,7 @@ var dependencies13 = ["typed", "config", "?bignumber"];
 var createUnaryMinus = /* @__PURE__ */ factory(
   name13,
   dependencies13,
-  ({ typed: typed3, config, bignumber: bignumber2 }) => {
+  ({ typed: typed3, config: config2, bignumber: bignumber2 }) => {
     return typed3(name13, {
       number: unaryMinusNumber,
       "Complex | BigNumber | Fraction": (x) => x.neg(),
@@ -17517,7 +17757,7 @@ var createUnaryMinus = /* @__PURE__ */ factory(
       boolean: function(x) {
         const numValue = x ? 1 : 0;
         const negValue = -numValue;
-        const numberType = config?.number || "number";
+        const numberType = config2?.number || "number";
         switch (numberType) {
           case "BigNumber":
             if (!bignumber2) {
@@ -18552,8 +18792,8 @@ var dependencies30 = ["typed", "config", "?on"];
 var createPickRandom = /* @__PURE__ */ factory(
   name30,
   dependencies30,
-  ({ typed: typed3, config, on }) => {
-    let rng = createRng(config.randomSeed);
+  ({ typed: typed3, config: config2, on }) => {
+    let rng = createRng(config2.randomSeed);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.randomSeed !== prev.randomSeed) {
@@ -18653,8 +18893,8 @@ var dependencies31 = ["typed", "config", "?on"];
 var createRandom = /* @__PURE__ */ factory(
   name31,
   dependencies31,
-  ({ typed: typed3, config, on }) => {
-    let rng = createRng(config.randomSeed);
+  ({ typed: typed3, config: config2, on }) => {
+    let rng = createRng(config2.randomSeed);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.randomSeed !== prev.randomSeed) {
@@ -18733,7 +18973,7 @@ var dependencies32 = ["typed", "config"];
 var createEqualScalar = /* @__PURE__ */ factory(
   name32,
   dependencies32,
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name32,
@@ -18742,10 +18982,10 @@ var createEqualScalar = /* @__PURE__ */ factory(
           return x === y;
         },
         "number, number": function(x, y) {
-          return nearlyEqual(x, y, config.relTol, config.absTol);
+          return nearlyEqual(x, y, config2.relTol, config2.absTol);
         },
         "BigNumber, BigNumber": function(x, y) {
-          return x.eq(y) || nearlyEqual2(x, y, config.relTol, config.absTol);
+          return x.eq(y) || nearlyEqual2(x, y, config2.relTol, config2.absTol);
         },
         "bigint, bigint": function(x, y) {
           return x === y;
@@ -18754,7 +18994,7 @@ var createEqualScalar = /* @__PURE__ */ factory(
           return x.equals(y);
         },
         "Complex, Complex": function(x, y) {
-          return complexEquals(x, y, config.relTol, config.absTol);
+          return complexEquals(x, y, config2.relTol, config2.absTol);
         }
       },
       compareUnits2
@@ -18959,10 +19199,10 @@ var dependencies36 = ["typed", "config", "Complex"];
 var createAcos = /* @__PURE__ */ factory(
   name36,
   dependencies36,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name36, {
       number: function(x) {
-        if (x >= -1 && x <= 1 || config.predictable) {
+        if (x >= -1 && x <= 1 || config2.predictable) {
           return Math.acos(x);
         } else {
           return new Complex12(x, 0).acos();
@@ -18984,10 +19224,10 @@ var dependencies37 = ["typed", "config", "Complex"];
 var createAcosh = /* @__PURE__ */ factory(
   name37,
   dependencies37,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name37, {
       number: function(x) {
-        if (x >= 1 || config.predictable) {
+        if (x >= 1 || config2.predictable) {
           return acoshNumber(x);
         }
         if (x <= -1) {
@@ -19030,10 +19270,10 @@ var dependencies39 = ["typed", "config", "Complex", "BigNumber"];
 var createAcoth = /* @__PURE__ */ factory(
   name39,
   dependencies39,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name39, {
       number: function(x) {
-        if (x >= 1 || x <= -1 || config.predictable) {
+        if (x >= 1 || x <= -1 || config2.predictable) {
           return acothNumber(x);
         }
         return new Complex12(x, 0).acoth();
@@ -19054,10 +19294,10 @@ var dependencies40 = ["typed", "config", "Complex", "BigNumber"];
 var createAcsc = /* @__PURE__ */ factory(
   name40,
   dependencies40,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name40, {
       number: function(x) {
-        if (x <= -1 || x >= 1 || config.predictable) {
+        if (x <= -1 || x >= 1 || config2.predictable) {
           return acscNumber(x);
         }
         return new Complex12(x, 0).acsc();
@@ -19097,10 +19337,10 @@ var dependencies42 = ["typed", "config", "Complex", "BigNumber"];
 var createAsec = /* @__PURE__ */ factory(
   name42,
   dependencies42,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name42, {
       number: function(x) {
-        if (x <= -1 || x >= 1 || config.predictable) {
+        if (x <= -1 || x >= 1 || config2.predictable) {
           return asecNumber(x);
         }
         return new Complex12(x, 0).asec();
@@ -19121,12 +19361,12 @@ var dependencies43 = ["typed", "config", "Complex", "BigNumber"];
 var createAsech = /* @__PURE__ */ factory(
   name43,
   dependencies43,
-  ({ typed: typed3, config, Complex: Complex12, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12, BigNumber: BigNumber9 }) => {
     return typed3(name43, {
       number: function(x) {
-        if (x <= 1 && x >= -1 || config.predictable) {
+        if (x <= 1 && x >= -1 || config2.predictable) {
           const xInv = 1 / x;
-          if (xInv > 0 || config.predictable) {
+          if (xInv > 0 || config2.predictable) {
             return asechNumber(x);
           }
           const ret = Math.sqrt(xInv * xInv - 1);
@@ -19150,10 +19390,10 @@ var dependencies44 = ["typed", "config", "Complex"];
 var createAsin = /* @__PURE__ */ factory(
   name44,
   dependencies44,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name44, {
       number: function(x) {
-        if (x >= -1 && x <= 1 || config.predictable) {
+        if (x >= -1 && x <= 1 || config2.predictable) {
           return Math.asin(x);
         } else {
           return new Complex12(x, 0).asin();
@@ -19215,10 +19455,10 @@ var dependencies47 = ["typed", "config", "Complex"];
 var createAtanh = /* @__PURE__ */ factory(
   name47,
   dependencies47,
-  ({ typed: typed3, config, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, Complex: Complex12 }) => {
     return typed3(name47, {
       number: function(x) {
-        if (x <= 1 && x >= -1 || config.predictable) {
+        if (x <= 1 && x >= -1 || config2.predictable) {
           return atanhNumber(x);
         }
         return new Complex12(x, 0).atanh();
@@ -19544,10 +19784,10 @@ var dependencies64 = ["typed", "config"];
 var createIsNegative = /* @__PURE__ */ factory(
   name64,
   dependencies64,
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name64, {
-      number: (x) => nearlyEqual(x, 0, config.relTol, config.absTol) ? false : isNegativeNumber(x),
-      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config.relTol, config.absTol) ? false : x.isNeg() && !x.isZero() && !x.isNaN(),
+      number: (x) => nearlyEqual(x, 0, config2.relTol, config2.absTol) ? false : isNegativeNumber(x),
+      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config2.relTol, config2.absTol) ? false : x.isNeg() && !x.isZero() && !x.isNaN(),
       bigint: (x) => x < 0n,
       Fraction: (x) => x.s < 0n,
       // It's enough to decide on the sign
@@ -19584,10 +19824,10 @@ var dependencies66 = ["typed", "config"];
 var createIsPositive = /* @__PURE__ */ factory(
   name66,
   dependencies66,
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name66, {
-      number: (x) => nearlyEqual(x, 0, config.relTol, config.absTol) ? false : isPositiveNumber(x),
-      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config.relTol, config.absTol) ? false : !x.isNeg() && !x.isZero() && !x.isNaN(),
+      number: (x) => nearlyEqual(x, 0, config2.relTol, config2.absTol) ? false : isPositiveNumber(x),
+      BigNumber: (x) => nearlyEqual2(x, new x.constructor(0), config2.relTol, config2.absTol) ? false : !x.isNeg() && !x.isZero() && !x.isNaN(),
       bigint: (x) => x > 0n,
       Fraction: (x) => x.s > 0n && x.n > 0n,
       Unit: typed3.referToSelf(
@@ -19806,7 +20046,7 @@ var dependencies71 = ["typed", "config", "numeric"];
 var createUnaryPlus = /* @__PURE__ */ factory(
   name71,
   dependencies71,
-  ({ typed: typed3, config, numeric: numeric2 }) => {
+  ({ typed: typed3, config: config2, numeric: numeric2 }) => {
     return typed3(name71, {
       number: unaryPlusNumber,
       Complex: function(x) {
@@ -19829,10 +20069,10 @@ var createUnaryPlus = /* @__PURE__ */ factory(
         (self) => (x) => deepMap2(x, self, true)
       ),
       boolean: function(x) {
-        return numeric2(x ? 1 : 0, config.number);
+        return numeric2(x ? 1 : 0, config2.number);
       },
       string: function(x) {
-        return numeric2(x, safeNumberType(x, config));
+        return numeric2(x, safeNumberType(x, config2));
       }
     });
   }
@@ -19962,8 +20202,8 @@ var dependencies73 = ["typed", "config", "log2", "?on"];
 var createRandomInt = /* @__PURE__ */ factory(
   name73,
   dependencies73,
-  ({ typed: typed3, config, log2: log23, on }) => {
-    let rng = createRng(config.randomSeed);
+  ({ typed: typed3, config: config2, log2: log23, on }) => {
+    let rng = createRng(config2.randomSeed);
     if (on) {
       on("config", function(curr, prev) {
         if (curr.randomSeed !== prev.randomSeed) {
@@ -20255,12 +20495,12 @@ var dependencies82 = ["config", "?bignumber"];
 var createParseNumberWithConfig = /* @__PURE__ */ factory(
   name82,
   dependencies82,
-  ({ config, bignumber: bignumber2 }) => {
+  ({ config: config2, bignumber: bignumber2 }) => {
     function parseNumberWithConfig2(str) {
       if (typeof str !== "string") {
         throw new TypeError(`parseNumberWithConfig expects string, got ${typeof str}`);
       }
-      const numberType = config.number || "number";
+      const numberType = config2.number || "number";
       switch (numberType) {
         case "BigNumber":
           if (!bignumber2) {
@@ -20475,22 +20715,22 @@ var dependencies85 = ["typed", "config", "matrix", "BigNumber", "DenseMatrix", "
 var createIdentity = /* @__PURE__ */ factory(
   name85,
   dependencies85,
-  ({ typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6, SparseMatrix }) => {
     return typed3(name85, {
       "": function() {
-        return config.matrix === "Matrix" ? matrix2([]) : [];
+        return config2.matrix === "Matrix" ? matrix2([]) : [];
       },
       string: function(format6) {
         return matrix2(format6);
       },
       "number | BigNumber": function(rows) {
-        return _identity(rows, rows, config.matrix === "Matrix" ? "dense" : void 0);
+        return _identity(rows, rows, config2.matrix === "Matrix" ? "dense" : void 0);
       },
       "number | BigNumber, string": function(rows, format6) {
         return _identity(rows, rows, format6);
       },
       "number | BigNumber, number | BigNumber": function(rows, cols) {
-        return _identity(rows, cols, config.matrix === "Matrix" ? "dense" : void 0);
+        return _identity(rows, cols, config2.matrix === "Matrix" ? "dense" : void 0);
       },
       "number | BigNumber, number | BigNumber, string": function(rows, cols, format6) {
         return _identity(rows, cols, format6);
@@ -20553,10 +20793,10 @@ var createIdentity = /* @__PURE__ */ factory(
 );
 
 // src/matrix/utils/zerosAndOnes.ts
-function createZerosAndOnes(name254, defaultValue, { typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) {
+function createZerosAndOnes(name254, defaultValue, { typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9 }) {
   return typed3(name254, {
     "": function() {
-      return config.matrix === "Array" ? _zerosAndOnes([]) : _zerosAndOnes([], "default");
+      return config2.matrix === "Array" ? _zerosAndOnes([]) : _zerosAndOnes([], "default");
     },
     // math.zeros/ones(m, n, p, ..., format)
     // TODO: more accurate signature '...number | BigNumber, string' as soon as typed-function supports this
@@ -20565,7 +20805,7 @@ function createZerosAndOnes(name254, defaultValue, { typed: typed3, config, matr
       if (typeof last === "string") {
         const format6 = size2.pop();
         return _zerosAndOnes(size2, format6);
-      } else if (config.matrix === "Array") {
+      } else if (config2.matrix === "Array") {
         return _zerosAndOnes(size2);
       } else {
         return _zerosAndOnes(size2, "default");
@@ -23045,7 +23285,7 @@ var createCbrt = /* @__PURE__ */ factory(
   name105,
   dependencies105,
   ({
-    config,
+    config: config2,
     typed: typed3,
     isNegative: isNegative2,
     unaryMinus: unaryMinus2,
@@ -23081,7 +23321,7 @@ var createCbrt = /* @__PURE__ */ factory(
           new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3 + Math.PI * 2 / 3).exp()),
           new Complex12(cbrtNumber(abs2), 0).mul(new Complex12(0, arg3 - Math.PI * 2 / 3).exp())
         ];
-        return config.matrix === "Array" ? all : matrix2(all);
+        return config2.matrix === "Array" ? all : matrix2(all);
       } else {
         return principal;
       }
@@ -23357,7 +23597,7 @@ var dependencies110 = [
 var createRound = /* @__PURE__ */ factory(
   name110,
   dependencies110,
-  ({ typed: typed3, config, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, BigNumber: BigNumber9, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
@@ -23366,17 +23606,17 @@ var createRound = /* @__PURE__ */ factory(
     }
     return typed3(name110, {
       number: function(x) {
-        const xEpsilon = roundNumber(x, toExponent(config.relTol));
-        const xSelected = nearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xEpsilon = roundNumber(x, toExponent(config2.relTol));
+        const xSelected = nearlyEqual(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return roundNumber(xSelected);
       },
       "number, number": function(x, n) {
-        const epsilonExponent = toExponent(config.relTol);
+        const epsilonExponent = toExponent(config2.relTol);
         if (n >= epsilonExponent) {
           return roundNumber(x, n);
         }
         const xEpsilon = roundNumber(x, epsilonExponent);
-        const xSelected = nearlyEqual(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xSelected = nearlyEqual(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return roundNumber(xSelected, n);
       },
       "number, BigNumber": function(x, n) {
@@ -23402,20 +23642,20 @@ var createRound = /* @__PURE__ */ factory(
         return x.round(_n);
       },
       BigNumber: function(x) {
-        const xEpsilon = new BigNumber9(x).toDecimalPlaces(toExponent(config.relTol));
-        const xSelected = nearlyEqual2(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xEpsilon = new BigNumber9(x).toDecimalPlaces(toExponent(config2.relTol));
+        const xSelected = nearlyEqual2(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return xSelected.toDecimalPlaces(0);
       },
       "BigNumber, BigNumber": function(x, n) {
         if (!n.isInteger()) {
           throw new TypeError(NO_INT);
         }
-        const epsilonExponent = toExponent(config.relTol);
+        const epsilonExponent = toExponent(config2.relTol);
         if (n >= epsilonExponent) {
           return x.toDecimalPlaces(n.toNumber());
         }
         const xEpsilon = x.toDecimalPlaces(epsilonExponent);
-        const xSelected = nearlyEqual2(x, xEpsilon, config.relTol, config.absTol) ? xEpsilon : x;
+        const xSelected = nearlyEqual2(x, xEpsilon, config2.relTol, config2.absTol) ? xEpsilon : x;
         return xSelected.toDecimalPlaces(n.toNumber());
       },
       // bigints can't be rounded
@@ -23505,11 +23745,11 @@ var dependencies111 = ["typed", "config", "matrix", "BigNumber"];
 var createXgcd = /* @__PURE__ */ factory(
   name111,
   dependencies111,
-  ({ typed: typed3, config, matrix: matrix2, BigNumber: BigNumber9 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, BigNumber: BigNumber9 }) => {
     return typed3(name111, {
       "number, number": function(a, b) {
         const res = xgcdNumber(a, b);
-        return config.matrix === "Array" ? res : matrix2(res);
+        return config2.matrix === "Array" ? res : matrix2(res);
       },
       "BigNumber, BigNumber": _xgcdBigNumber
       // TODO: implement support for Fraction
@@ -23545,7 +23785,7 @@ var createXgcd = /* @__PURE__ */ factory(
       } else {
         res = [a, !a.isZero() ? lastx : 0, lasty];
       }
-      return config.matrix === "Array" ? res : matrix2(res);
+      return config2.matrix === "Array" ? res : matrix2(res);
     }
   }
 );
@@ -23557,7 +23797,7 @@ var nlg16 = Math.log(16);
 var createLog = /* @__PURE__ */ factory(
   name112,
   dependencies112,
-  ({ typed: typed3, typeOf: typeOf3, config, divideScalar: divideScalar2, Complex: Complex12 }) => {
+  ({ typed: typed3, typeOf: typeOf3, config: config2, divideScalar: divideScalar2, Complex: Complex12 }) => {
     function complexLog(c) {
       return c.log();
     }
@@ -23566,16 +23806,16 @@ var createLog = /* @__PURE__ */ factory(
     }
     return typed3(name112, {
       number: function(x) {
-        if (x >= 0 || config.predictable) {
+        if (x >= 0 || config2.predictable) {
           return logNumber(x);
         } else {
           return complexLogNumber(x);
         }
       },
-      bigint: promoteLogarithm(nlg16, logNumber, config, complexLogNumber),
+      bigint: promoteLogarithm(nlg16, logNumber, config2, complexLogNumber),
       Complex: complexLog,
       BigNumber: function(x) {
-        if (!x.isNegative() || config.predictable) {
+        if (!x.isNegative() || config2.predictable) {
           return x.ln();
         } else {
           return complexLogNumber(x.toNumber());
@@ -23963,7 +24203,7 @@ var dependencies117 = ["typed", "config", "matrix"];
 var createResize = /* @__PURE__ */ factory(
   name117,
   dependencies117,
-  ({ typed: typed3, config, matrix: matrix2 }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2 }) => {
     return typed3(name117, {
       "any, Array | Matrix": function(x, size2) {
         return _resize2(x, size2);
@@ -23985,7 +24225,7 @@ var createResize = /* @__PURE__ */ factory(
       if (typeof x === "string") {
         return _resizeString(x, sz, defaultValue);
       }
-      const asMatrix = Array.isArray(x) ? false : config.matrix !== "Array";
+      const asMatrix = Array.isArray(x) ? false : config2.matrix !== "Array";
       if (sz.length === 0) {
         let scalar = x;
         while (Array.isArray(scalar)) {
@@ -24284,7 +24524,7 @@ var createBernoulli = /* @__PURE__ */ factory(
   dependencies119,
   ({
     typed: typed3,
-    config,
+    config: config2,
     isInteger: _isInteger,
     number: number2,
     BigNumber: BigNumber9,
@@ -24312,9 +24552,9 @@ var createBernoulli = /* @__PURE__ */ factory(
         (a, b) => a.div(b)
       ),
       BigNumber: (index) => {
-        if (config.precision !== cachedPrecision) {
+        if (config2.precision !== cachedPrecision) {
           bigCache = [void 0];
-          cachedPrecision = config.precision;
+          cachedPrecision = config2.precision;
         }
         return _bernoulli(
           number2(index),
@@ -25019,7 +25259,7 @@ var dependencies128 = ["typed", "config", "add", "numeric", "parseNumberWithConf
 var createSum = /* @__PURE__ */ factory(
   name128,
   dependencies128,
-  ({ typed: typed3, config, add: add2, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
+  ({ typed: typed3, config: config2, add: add2, numeric: numeric2, parseNumberWithConfig: parseNumberWithConfig2 }) => {
     return typed3(name128, {
       // sum(string) - single string input
       string: function(x) {
@@ -25064,7 +25304,7 @@ var createSum = /* @__PURE__ */ factory(
         }
       });
       if (sum3 === void 0) {
-        sum3 = numeric2(0, config.number);
+        sum3 = numeric2(0, config2.number);
       }
       return sum3;
     }
@@ -25313,12 +25553,12 @@ var bigTen = new Decimal(10);
 var createFloorNumber = /* @__PURE__ */ factory(
   name133,
   ["typed", "config", "round"],
-  ({ typed: typed3, config, round: round2 }) => {
+  ({ typed: typed3, config: config2, round: round2 }) => {
     function _floorNumber(x) {
       const f = Math.floor(x);
       const r = round2(x);
       if (f === r) return f;
-      if (nearlyEqual(x, r, config.relTol, config.absTol) && !nearlyEqual(x, f, config.relTol, config.absTol)) {
+      if (nearlyEqual(x, r, config2.relTol, config2.absTol) && !nearlyEqual(x, f, config2.relTol, config2.absTol)) {
         return r;
       }
       return f;
@@ -25341,13 +25581,13 @@ var createFloorNumber = /* @__PURE__ */ factory(
 var createFloor = /* @__PURE__ */ factory(
   name133,
   dependencies133,
-  ({ typed: typed3, config, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
-    const floorNumber = createFloorNumber({ typed: typed3, config, round: round2 });
+    const floorNumber = createFloorNumber({ typed: typed3, config: config2, round: round2 });
     function _bigFloor(x) {
-      const bne = (a, b) => nearlyEqual2(a, b, config.relTol, config.absTol);
+      const bne = (a, b) => nearlyEqual2(a, b, config2.relTol, config2.absTol);
       const f = x.floor();
       const r = round2(x);
       if (f.eq(r)) return f;
@@ -25554,10 +25794,10 @@ var dependencies135 = [
 var createMod = /* @__PURE__ */ factory(
   name135,
   dependencies135,
-  ({ typed: typed3, config, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6, concat: concat3 }) => {
     const floor2 = createFloor({
       typed: typed3,
-      config,
+      config: config2,
       round: round2,
       matrix: matrix2,
       equalScalar: equalScalar3,
@@ -25855,7 +26095,7 @@ var createGcd = /* @__PURE__ */ factory(
   ({
     typed: typed3,
     matrix: matrix2,
-    config,
+    config: config2,
     round: round2,
     equalScalar: equalScalar3,
     zeros: zeros2,
@@ -25865,7 +26105,7 @@ var createGcd = /* @__PURE__ */ factory(
   }) => {
     const mod2 = createMod({
       typed: typed3,
-      config,
+      config: config2,
       round: round2,
       matrix: matrix2,
       equalScalar: equalScalar3,
@@ -26122,10 +26362,10 @@ var dependencies142 = ["typed", "config", "divideScalar", "log", "Complex"];
 var createLog1p = /* @__PURE__ */ factory(
   name142,
   dependencies142,
-  ({ typed: typed3, config, divideScalar: divideScalar2, log: log3, Complex: Complex12 }) => {
+  ({ typed: typed3, config: config2, divideScalar: divideScalar2, log: log3, Complex: Complex12 }) => {
     return typed3(name142, {
       number: function(x) {
-        if (x >= -1 || config.predictable) {
+        if (x >= -1 || config2.predictable) {
           return log1p2(x);
         } else {
           return _log1pComplex(new Complex12(x, 0));
@@ -26134,7 +26374,7 @@ var createLog1p = /* @__PURE__ */ factory(
       Complex: _log1pComplex,
       BigNumber: function(x) {
         const y = x.plus(1);
-        if (!y.isNegative() || config.predictable) {
+        if (!y.isNegative() || config2.predictable) {
           return y.ln();
         } else {
           return _log1pComplex(new Complex12(x.toNumber(), 0));
@@ -26296,7 +26536,7 @@ var createPow = /* @__PURE__ */ factory(
   dependencies144,
   ({
     typed: typed3,
-    config,
+    config: config2,
     identity: identity2,
     multiply: multiply2,
     matrix: matrix2,
@@ -26311,7 +26551,7 @@ var createPow = /* @__PURE__ */ factory(
         return x.pow(y);
       },
       "BigNumber, BigNumber": function(x, y) {
-        if (y.isInteger() || x.gte(0) || config.predictable) {
+        if (y.isInteger() || x.gte(0) || config2.predictable) {
           return x.pow(y);
         } else {
           return new Complex12(x.toNumber(), 0).pow(y.toNumber(), 0);
@@ -26323,7 +26563,7 @@ var createPow = /* @__PURE__ */ factory(
         if (result != null) {
           return result;
         }
-        if (config.predictable) {
+        if (config2.predictable) {
           throw new Error("Result of pow is non-rational and cannot be expressed as a fraction");
         } else {
           return _pow(x.valueOf(), y.valueOf());
@@ -26342,7 +26582,7 @@ var createPow = /* @__PURE__ */ factory(
       }
     });
     function _pow(x, y) {
-      if (config.predictable && !isInteger(y) && x < 0) {
+      if (config2.predictable && !isInteger(y) && x < 0) {
         try {
           const yFrac = fraction2(y);
           const yNum = number2(yFrac);
@@ -26354,10 +26594,10 @@ var createPow = /* @__PURE__ */ factory(
         } catch {
         }
       }
-      if (config.predictable && (x < -1 && y === Infinity || x > -1 && x < 0 && y === -Infinity)) {
+      if (config2.predictable && (x < -1 && y === Infinity || x > -1 && x < 0 && y === -Infinity)) {
         return NaN;
       }
-      if (isInteger(y) || x >= 0 || config.predictable) {
+      if (isInteger(y) || x >= 0 || config2.predictable) {
         return powNumber(x, y);
       } else {
         if (isPowZeroAtInfinity(x, y)) {
@@ -26414,12 +26654,12 @@ var bigTen2 = new Decimal2(10);
 var createCeilNumber = /* @__PURE__ */ factory(
   name145,
   ["typed", "config", "round"],
-  ({ typed: typed3, config, round: round2 }) => {
+  ({ typed: typed3, config: config2, round: round2 }) => {
     function _ceilNumber(x) {
       const c = Math.ceil(x);
       const r = round2(x);
       if (c === r) return c;
-      if (nearlyEqual(x, r, config.relTol, config.absTol) && !nearlyEqual(x, c, config.relTol, config.absTol)) {
+      if (nearlyEqual(x, r, config2.relTol, config2.absTol) && !nearlyEqual(x, c, config2.relTol, config2.absTol)) {
         return r;
       }
       return c;
@@ -26442,13 +26682,13 @@ var createCeilNumber = /* @__PURE__ */ factory(
 var createCeil = /* @__PURE__ */ factory(
   name145,
   dependencies145,
-  ({ typed: typed3, config, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
+  ({ typed: typed3, config: config2, round: round2, matrix: matrix2, equalScalar: equalScalar3, zeros: zeros2, DenseMatrix: DenseMatrix6 }) => {
     const matAlgo11xS0s = createMatAlgo11xS0s({ typed: typed3, equalScalar: equalScalar3 });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
     const matAlgo14xDs = createMatAlgo14xDs({ typed: typed3 });
-    const ceilNumber = createCeilNumber({ typed: typed3, config, round: round2 });
+    const ceilNumber = createCeilNumber({ typed: typed3, config: config2, round: round2 });
     function _bigCeil(x) {
-      const bne = (a, b) => nearlyEqual2(a, b, config.relTol, config.absTol);
+      const bne = (a, b) => nearlyEqual2(a, b, config2.relTol, config2.absTol);
       const c = x.ceil();
       const r = round2(x);
       if (c.eq(r)) return c;
@@ -27054,7 +27294,7 @@ var createCompare = /* @__PURE__ */ factory(
   dependencies155,
   ({
     typed: typed3,
-    config,
+    config: config2,
     equalScalar: equalScalar3,
     matrix: matrix2,
     BigNumber: BigNumber9,
@@ -27073,13 +27313,13 @@ var createCompare = /* @__PURE__ */ factory(
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name155,
-      createCompareNumber({ typed: typed3, config }),
+      createCompareNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": function(x, y) {
           return x === y ? 0 : x > y ? 1 : -1;
         },
         "BigNumber, BigNumber": function(x, y) {
-          return nearlyEqual2(x, y, config.relTol, config.absTol) ? new BigNumber9(0) : new BigNumber9(x.cmp(y));
+          return nearlyEqual2(x, y, config2.relTol, config2.absTol) ? new BigNumber9(0) : new BigNumber9(x.cmp(y));
         },
         "bigint, bigint": function(x, y) {
           return x === y ? 0n : x > y ? 1n : -1n;
@@ -27103,10 +27343,10 @@ var createCompare = /* @__PURE__ */ factory(
 var createCompareNumber = /* @__PURE__ */ factory(
   name155,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name155, {
       "number, number": function(x, y) {
-        return nearlyEqual(x, y, config.relTol, config.absTol) ? 0 : x > y ? 1 : -1;
+        return nearlyEqual(x, y, config2.relTol, config2.absTol) ? 0 : x > y ? 1 : -1;
       }
     });
   }
@@ -27189,7 +27429,7 @@ var dependencies158 = [
 var createLarger = /* @__PURE__ */ factory(
   name158,
   dependencies158,
-  ({ typed: typed3, config, bignumber: bignumber2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, bignumber: bignumber2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
@@ -27200,11 +27440,11 @@ var createLarger = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     function bignumLarger(x, y) {
-      return x.gt(y) && !nearlyEqual2(x, y, config.relTol, config.absTol);
+      return x.gt(y) && !nearlyEqual2(x, y, config2.relTol, config2.absTol);
     }
     return typed3(
       name158,
-      createLargerNumber({ typed: typed3, config }),
+      createLargerNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x > y,
         "BigNumber, BigNumber": bignumLarger,
@@ -27232,10 +27472,10 @@ var createLarger = /* @__PURE__ */ factory(
 var createLargerNumber = /* @__PURE__ */ factory(
   name158,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name158, {
       "number, number": function(x, y) {
-        return x > y && !nearlyEqual(x, y, config.relTol, config.absTol);
+        return x > y && !nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -27247,7 +27487,7 @@ var dependencies159 = ["typed", "config", "matrix", "DenseMatrix", "concat", "Sp
 var createLargerEq = /* @__PURE__ */ factory(
   name159,
   dependencies159,
-  ({ typed: typed3, config, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
@@ -27259,11 +27499,11 @@ var createLargerEq = /* @__PURE__ */ factory(
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name159,
-      createLargerEqNumber({ typed: typed3, config }),
+      createLargerEqNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x >= y,
         "BigNumber, BigNumber": function(x, y) {
-          return x.gte(y) || nearlyEqual2(x, y, config.relTol, config.absTol);
+          return x.gte(y) || nearlyEqual2(x, y, config2.relTol, config2.absTol);
         },
         "bigint, bigint": function(x, y) {
           return x >= y;
@@ -27285,10 +27525,10 @@ var createLargerEq = /* @__PURE__ */ factory(
 var createLargerEqNumber = /* @__PURE__ */ factory(
   name159,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name159, {
       "number, number": function(x, y) {
-        return x >= y || nearlyEqual(x, y, config.relTol, config.absTol);
+        return x >= y || nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -27310,7 +27550,7 @@ var createSmaller = /* @__PURE__ */ factory(
   dependencies160,
   ({
     typed: typed3,
-    config,
+    config: config2,
     bignumber: bignumber2,
     matrix: matrix2,
     DenseMatrix: DenseMatrix6,
@@ -27327,11 +27567,11 @@ var createSmaller = /* @__PURE__ */ factory(
     });
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     function bignumSmaller(x, y) {
-      return x.lt(y) && !nearlyEqual2(x, y, config.relTol, config.absTol);
+      return x.lt(y) && !nearlyEqual2(x, y, config2.relTol, config2.absTol);
     }
     return typed3(
       name160,
-      createSmallerNumber({ typed: typed3, config }),
+      createSmallerNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x < y,
         "BigNumber, BigNumber": bignumSmaller,
@@ -27359,10 +27599,10 @@ var createSmaller = /* @__PURE__ */ factory(
 var createSmallerNumber = /* @__PURE__ */ factory(
   name160,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name160, {
       "number, number": function(x, y) {
-        return x < y && !nearlyEqual(x, y, config.relTol, config.absTol);
+        return x < y && !nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -27374,7 +27614,7 @@ var dependencies161 = ["typed", "config", "matrix", "DenseMatrix", "concat", "Sp
 var createSmallerEq = /* @__PURE__ */ factory(
   name161,
   dependencies161,
-  ({ typed: typed3, config, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
+  ({ typed: typed3, config: config2, matrix: matrix2, DenseMatrix: DenseMatrix6, concat: concat3, SparseMatrix }) => {
     const matAlgo03xDSf = createMatAlgo03xDSf({ typed: typed3 });
     const matAlgo07xSSf = createMatAlgo07xSSf({ typed: typed3, SparseMatrix });
     const matAlgo12xSfs = createMatAlgo12xSfs({ typed: typed3, DenseMatrix: DenseMatrix6 });
@@ -27386,11 +27626,11 @@ var createSmallerEq = /* @__PURE__ */ factory(
     const compareUnits2 = createCompareUnits({ typed: typed3 });
     return typed3(
       name161,
-      createSmallerEqNumber({ typed: typed3, config }),
+      createSmallerEqNumber({ typed: typed3, config: config2 }),
       {
         "boolean, boolean": (x, y) => x <= y,
         "BigNumber, BigNumber": function(x, y) {
-          return x.lte(y) || nearlyEqual2(x, y, config.relTol, config.absTol);
+          return x.lte(y) || nearlyEqual2(x, y, config2.relTol, config2.absTol);
         },
         "bigint, bigint": (x, y) => x <= y,
         "Fraction, Fraction": (x, y) => x.compare(y) !== 1,
@@ -27410,10 +27650,10 @@ var createSmallerEq = /* @__PURE__ */ factory(
 var createSmallerEqNumber = /* @__PURE__ */ factory(
   name161,
   ["typed", "config"],
-  ({ typed: typed3, config }) => {
+  ({ typed: typed3, config: config2 }) => {
     return typed3(name161, {
       "number, number": function(x, y) {
-        return x <= y || nearlyEqual(x, y, config.relTol, config.absTol);
+        return x <= y || nearlyEqual(x, y, config2.relTol, config2.absTol);
       }
     });
   }
@@ -28346,7 +28586,7 @@ var createRange = /* @__PURE__ */ factory(
   dependencies173,
   ({
     typed: typed3,
-    config,
+    config: config2,
     matrix: matrix2,
     bignumber: bignumber2,
     smaller: smaller2,
@@ -28440,7 +28680,7 @@ var createRange = /* @__PURE__ */ factory(
       }
     });
     function _out(arr7) {
-      if (config.matrix === "Matrix") {
+      if (config2.matrix === "Matrix") {
         return matrix2 ? matrix2(arr7) : noMatrix();
       }
       return arr7;
@@ -28450,7 +28690,7 @@ var createRange = /* @__PURE__ */ factory(
       if (!r) {
         throw new SyntaxError('String "' + str + '" is no valid range');
       }
-      if (config.number === "BigNumber") {
+      if (config2.number === "BigNumber") {
         if (bignumber2 === void 0) {
           noBignumber();
         }
@@ -28509,7 +28749,7 @@ var createGamma = /* @__PURE__ */ factory(
   dependencies174,
   ({
     typed: typed3,
-    config,
+    config: config2,
     multiplyScalar: _multiplyScalar,
     pow: _pow,
     BigNumber: BigNumber9,
@@ -28555,7 +28795,7 @@ var createGamma = /* @__PURE__ */ factory(
       if (nNum < 8) {
         return new BigNumber9([1, 1, 2, 6, 24, 120, 720, 5040][nNum]);
       }
-      const precision = config.precision + (Math.log(nNum) | 0);
+      const precision = config2.precision + (Math.log(nNum) | 0);
       const Big = BigNumber9.clone({ precision });
       if (nNum % 2 === 1) {
         return n.times(bigFactorial(n.minus(1)));
@@ -28763,7 +29003,7 @@ var dependencies177 = ["typed", "config", "numeric", "larger", "isNaN"];
 var createMax = /* @__PURE__ */ factory(
   name177,
   dependencies177,
-  ({ typed: typed3, config, numeric: numeric2, larger: larger2, isNaN: mathIsNaN }) => {
+  ({ typed: typed3, config: config2, numeric: numeric2, larger: larger2, isNaN: mathIsNaN }) => {
     return typed3(name177, {
       // max([a, b, c, d, ...])
       "Array | Matrix": _max,
@@ -28820,7 +29060,7 @@ var createMax = /* @__PURE__ */ factory(
         throw new Error("Cannot calculate max of an empty array");
       }
       if (typeof res === "string") {
-        res = numeric2(res, safeNumberType(res, config));
+        res = numeric2(res, safeNumberType(res, config2));
       }
       return res;
     }
@@ -28842,7 +29082,7 @@ var dependencies178 = ["typed", "config", "numeric", "smaller", "isNaN"];
 var createMin = /* @__PURE__ */ factory(
   name178,
   dependencies178,
-  ({ typed: typed3, config, numeric: numeric2, smaller: smaller2, isNaN: mathIsNaN }) => {
+  ({ typed: typed3, config: config2, numeric: numeric2, smaller: smaller2, isNaN: mathIsNaN }) => {
     return typed3(name178, {
       // min([a, b, c, d, ...])
       "Array | Matrix": _min,
@@ -28899,7 +29139,7 @@ var createMin = /* @__PURE__ */ factory(
         throw new Error("Cannot calculate min of an empty array");
       }
       if (typeof min2 === "string") {
-        min2 = numeric2(min2, safeNumberType(min2, config));
+        min2 = numeric2(min2, safeNumberType(min2, config2));
       }
       return min2;
     }
@@ -30180,7 +30420,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
   dependencies193,
   ({
     typed: typed3,
-    config,
+    config: config2,
     mathWithTransform,
     matrix: matrix2,
     parse: parse3,
@@ -30280,7 +30520,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
     }
     const _toNumber = typed3({
       "string, Object": function(s, options) {
-        const numericType = safeNumberType(s, config);
+        const numericType = safeNumberType(s, config2);
         if (numericType === "BigNumber") {
           if (bignumber2 === void 0) {
             noBignumber();
@@ -30329,7 +30569,7 @@ var createSimplifyConstant = /* @__PURE__ */ factory(
       return new OperatorNode("-", "unaryMinus", [n]);
     }
     function _fractionToNode(f) {
-      const fromBigInt = (value) => config.number === "BigNumber" && bignumber2 ? bignumber2(value) : Number(value);
+      const fromBigInt = (value) => config2.number === "BigNumber" && bignumber2 ? bignumber2(value) : Number(value);
       const signBigInt = BigInt(f.s);
       const numeratorValue = signBigInt * f.n;
       const numeratorNode = numeratorValue < 0n ? new OperatorNode("-", "unaryMinus", [new ConstantNode(fromBigInt(-numeratorValue))]) : new ConstantNode(fromBigInt(numeratorValue));
@@ -33164,7 +33404,7 @@ var createIntersect = /* @__PURE__ */ factory(
   dependencies217,
   ({
     typed: typed3,
-    config,
+    config: config2,
     abs: abs2,
     add: add2,
     addScalar: addScalar2,
@@ -33292,7 +33532,7 @@ var createIntersect = /* @__PURE__ */ factory(
         multiplyScalar2(d2[0], d1[1])
       );
       if (isZero2(det2)) return null;
-      if (smaller2(abs2(det2), config.relTol)) {
+      if (smaller2(abs2(det2), config2.relTol)) {
         return null;
       }
       const d20o11 = multiplyScalar2(d2[0], o1[1]);
@@ -33488,7 +33728,7 @@ var createMedian = /* @__PURE__ */ factory(
   name219,
   dependencies219,
   ({ typed: typed3, add: add2, divide: divide2, compare: compare2, partitionSelect: partitionSelect2 }) => {
-    function _median(array) {
+    function _median2(array) {
       try {
         const flat = flatten2(array.valueOf());
         const num2 = flat.length;
@@ -33525,7 +33765,7 @@ var createMedian = /* @__PURE__ */ factory(
     });
     return typed3(name219, {
       // median([a, b, c, d, ...])
-      "Array | Matrix": _median,
+      "Array | Matrix": _median2,
       // median([a, b, c, d, ...], dim)
       "Array | Matrix, number | BigNumber": function(_array, _dim) {
         throw new Error("median(A, dim) is not yet supported");
@@ -33535,7 +33775,7 @@ var createMedian = /* @__PURE__ */ factory(
         if (containsCollections(args)) {
           throw new TypeError("Scalar values expected in function median");
         }
-        return _median(args);
+        return _median2(args);
       }
     });
   }
@@ -35276,7 +35516,7 @@ var createZeta = /* @__PURE__ */ factory(
   dependencies235,
   ({
     typed: typed3,
-    config,
+    config: config2,
     multiply: multiply2,
     pow: pow2,
     divide: divide2,
@@ -35306,7 +35546,7 @@ var createZeta = /* @__PURE__ */ factory(
         s,
         (value) => new BigNumber9(value),
         () => {
-          return Math.abs(Math.log10(config.relTol));
+          return Math.abs(Math.log10(config2.relTol));
         }
       ),
       Complex: zetaComplex
@@ -35327,7 +35567,7 @@ var createZeta = /* @__PURE__ */ factory(
       if (s.re === 0 && s.im === 0) {
         return new Complex12(-0.5);
       }
-      if (s.re === 1) {
+      if (s.re === 1 && s.im === 0) {
         return new Complex12(NaN, NaN);
       }
       if (s.re === Infinity && s.im === 0) {
@@ -35907,7 +36147,7 @@ function flattenToFloat649(matrix2, rows, cols) {
   return result;
 }
 function createRealSymmetric({
-  config,
+  config: config2,
   addScalar: addScalar2,
   subtract: subtract2,
   abs: abs2,
@@ -35932,7 +36172,7 @@ function createRealSymmetric({
     if (typeof a === "number" && typeof b === "number") return a <= b;
     return a.lte(b);
   }
-  function main(arr7, _N, prec = config.relTol, type, computeVectors) {
+  function main(arr7, _N, prec = config2.relTol, type, computeVectors) {
     if (type === "number") {
       return diag2(arr7, prec, computeVectors);
     }
@@ -36053,7 +36293,7 @@ function createRealSymmetric({
   }
   function getTheta(aii, ajj, aij) {
     const denom = ajj - aii;
-    if (Math.abs(denom) <= config.relTol) {
+    if (Math.abs(denom) <= config2.relTol) {
       return Math.PI / 4;
     } else {
       return 0.5 * Math.atan(2 * aij / (ajj - aii));
@@ -36061,7 +36301,7 @@ function createRealSymmetric({
   }
   function getThetaBig(aii, ajj, aij) {
     const denom = subtract2(ajj, aii);
-    if (bigLte(abs2(denom), bignumber2(config.relTol))) {
+    if (bigLte(abs2(denom), bignumber2(config2.relTol))) {
       return bignumber2(-1).acos().div(4);
     } else {
       return multiplyScalar2(
@@ -36272,7 +36512,7 @@ var createEigs = /* @__PURE__ */ factory(
   name237,
   dependencies237,
   ({
-    config,
+    config: config2,
     typed: typed3,
     matrix: matrix2,
     addScalar: addScalar2,
@@ -36307,7 +36547,7 @@ var createEigs = /* @__PURE__ */ factory(
     dot: dot3
   }) => {
     const doRealSymmetric = createRealSymmetric({
-      config,
+      config: config2,
       addScalar: addScalar2,
       subtract: subtract2,
       abs: abs2,
@@ -36375,7 +36615,7 @@ var createEigs = /* @__PURE__ */ factory(
     });
     function doEigs(mat, opts = {}) {
       const computeVectors = "eigenvectors" in opts ? opts.eigenvectors : true;
-      const prec = opts.precision ?? config.relTol;
+      const prec = opts.precision ?? config2.relTol;
       const result = computeValuesAndVectors(mat, prec, computeVectors);
       if (opts.matricize) {
         result.values = matrix2(result.values);
@@ -37834,7 +38074,7 @@ var createDerivative = /* @__PURE__ */ factory(
   dependencies244,
   ({
     typed: typed3,
-    config,
+    config: config2,
     parse: parse3,
     simplify: simplify2,
     equal: equal2,
@@ -38363,7 +38603,7 @@ var createDerivative = /* @__PURE__ */ factory(
       }
     });
     function createConstantNode2(value, valueType) {
-      return new ConstantNode(numeric2(value, valueType || safeNumberType(String(value), config)));
+      return new ConstantNode(numeric2(value, valueType || safeNumberType(String(value), config2)));
     }
     return derivative2;
   }
@@ -39128,7 +39368,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
   dependencies249,
   ({
     typed: typed3,
-    config,
+    config: config2,
     multiplyScalar: multiplyScalar2,
     addScalar: addScalar2,
     unaryMinus: unaryMinus2,
@@ -39142,13 +39382,13 @@ var createRotationMatrix = /* @__PURE__ */ factory(
   }) => {
     return typed3(name249, {
       "": function() {
-        return config.matrix === "Matrix" ? matrix2([]) : [];
+        return config2.matrix === "Matrix" ? matrix2([]) : [];
       },
       string: function(format6) {
         return matrix2(format6);
       },
       "number | BigNumber | Complex | Unit": function(theta) {
-        return _rotationMatrix2x2(theta, config.matrix === "Matrix" ? "dense" : void 0);
+        return _rotationMatrix2x2(theta, config2.matrix === "Matrix" ? "dense" : void 0);
       },
       "number | BigNumber | Complex | Unit, string": function(theta, format6) {
         return _rotationMatrix2x2(theta, format6);
@@ -39160,7 +39400,7 @@ var createRotationMatrix = /* @__PURE__ */ factory(
       },
       "number | BigNumber | Complex | Unit, Matrix": function(theta, v) {
         _validateVector(v);
-        const storageType = v.storage() || (config.matrix === "Matrix" ? "dense" : void 0);
+        const storageType = v.storage() || (config2.matrix === "Matrix" ? "dense" : void 0);
         return _rotationMatrix3x3(theta, v, storageType);
       },
       "number | BigNumber | Complex | Unit, Array, string": function(theta, v, format6) {
@@ -39691,8 +39931,8 @@ function unitFactory(name254, valueStr, unitStr) {
   return factory(
     name254,
     dependencies254,
-    ({ config, Unit: Unit2, BigNumber: BigNumber9 }) => {
-      const value = config.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
+    ({ config: config2, Unit: Unit2, BigNumber: BigNumber9 }) => {
+      const value = config2.number === "BigNumber" ? new BigNumber9(valueStr) : parseFloat(valueStr);
       const unit2 = new Unit2(value, unitStr);
       unit2.fixPrefix = true;
       return unit2;
@@ -39704,8 +39944,8 @@ function numberFactory(name254, value) {
   return factory(
     name254,
     dependencies254,
-    ({ config, BigNumber: BigNumber9 }) => {
-      return config.number === "BigNumber" ? new BigNumber9(value) : value;
+    ({ config: config2, BigNumber: BigNumber9 }) => {
+      return config2.number === "BigNumber" ? new BigNumber9(value) : value;
     }
   );
 }
@@ -42331,6 +42571,13 @@ function casFactor(input) {
   }).then((r) => r.result);
 }
 
+// src/config-api.ts
+function config(options) {
+  const shared = factoryScope.config;
+  if (options) Object.assign(shared, options);
+  return { ...shared };
+}
+
 // src/help.ts
 import { createHelpClass, embeddedDocs } from "@danielsimonjr/mathts-expression";
 var savedConfig = {};
@@ -42529,6 +42776,33 @@ function corrcoef(matrix2) {
     (_, i) => Array.from({ length: n }, (_2, j) => c[i][j] / (d[i] * d[j]))
   );
 }
+function kendallTau(x, y) {
+  const n = x.length;
+  if (n !== y.length) throw new Error("kendallTau: inputs must have equal length");
+  if (n < 2) return NaN;
+  let P2 = 0;
+  let Q2 = 0;
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const s = Math.sign(x[j] - x[i]) * Math.sign(y[j] - y[i]);
+      if (s > 0) P2++;
+      else if (s < 0) Q2++;
+    }
+  }
+  const n0 = n * (n - 1) / 2;
+  const tiePairs = (arr7) => {
+    const counts = /* @__PURE__ */ new Map();
+    for (const v of arr7) counts.set(v, (counts.get(v) ?? 0) + 1);
+    let s = 0;
+    for (const c of counts.values()) s += c * (c - 1) / 2;
+    return s;
+  };
+  const n16 = tiePairs(x);
+  const n26 = tiePairs(y);
+  const denom = Math.sqrt((n0 - n16) * (n0 - n26));
+  if (denom === 0) return NaN;
+  return (P2 - Q2) / denom;
+}
 
 // src/numeric-extra.ts
 var toArr = (x) => Array.isArray(x) ? x : Array.from(x);
@@ -43709,6 +43983,7 @@ export {
   avogadro,
   bandpassFilter,
   bartlettPSD,
+  bartlettTest,
   bellNumbers,
   bernoulli,
   bernoulliPMF,
@@ -43733,6 +44008,7 @@ export {
   bin,
   binomialDist,
   binomialPMF,
+  binomialTest,
   bitAnd,
   bitNot,
   bitOr,
@@ -43796,6 +44072,7 @@ export {
   concat2 as concat,
   cond,
   conductanceQuantum,
+  config,
   conj,
   connectedComponents,
   convexHull,
@@ -44049,6 +44326,7 @@ export {
   highpassFilter,
   hilbertTransform,
   hmean,
+  hypergeometricDist,
   hypot,
   idct,
   identity,
@@ -44092,9 +44370,11 @@ export {
   jsDivergence,
   kdTree,
   kdTreeNearest,
+  kendallTau,
   kldivergence,
   klitzing,
   kmeans,
+  kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
   kruskalWallis,
@@ -44117,6 +44397,7 @@ export {
   legendreFit,
   legendreP,
   levenbergMarquardt,
+  leveneTest,
   lfilter,
   lfilterZi,
   lgamma,
@@ -44195,6 +44476,7 @@ export {
   multiplyScalar,
   multivariateTaylor,
   nearestNeighbor,
+  negativeBinomialDist,
   nelderMead,
   neutronMass,
   newtonInterp,
@@ -44296,6 +44578,7 @@ export {
   print,
   prod,
   projectVector,
+  proportionZTest,
   protonMass,
   qr,
   quadprog,
@@ -44408,6 +44691,7 @@ export {
   studentTPDF,
   studentTQuantile,
   studentTTest,
+  studentTTestPaired,
   studentizedRangeCDF,
   studentizedRangeQuantile,
   subfactorial,