@danielsimonjr/mathts-functions 0.14.0 → 0.16.0

package/dist/index.js

@@ -33,9 +33,11 @@ __export(typed_exports, {
   airyAi: () => airyAi,
   airyBi: () => airyBi,
   and: () => and,
+  andersonDarlingTest: () => andersonDarlingTest,
   angle2D: () => angle2D,
   angle3D: () => angle3D,
   anova: () => anova,
+  anova2: () => anova2,
   apart: () => apart,
   area: () => area,
   arg: () => arg,
@@ -48,6 +50,7 @@ __export(typed_exports, {
   autoCorrelation: () => autoCorrelation,
   bandpassFilter: () => bandpassFilter,
   bartlettPSD: () => bartlettPSD,
+  bartlettTest: () => bartlettTest,
   bernoulli: () => bernoulli,
   bernoulliPMF: () => bernoulliPMF,
   besselI: () => besselI,
@@ -67,10 +70,12 @@ __export(typed_exports, {
   bin: () => bin,
   binomialDist: () => binomialDist,
   binomialPMF: () => binomialPMF,
+  binomialTest: () => binomialTest,
   bitAnd: () => bitAnd,
   bitNot: () => bitNot,
   bitOr: () => bitOr,
   bitXor: () => bitXor,
+  bootstrapCI: () => bootstrapCI,
   bspline: () => bspline,
   cancel: () => cancel,
   carlsonRC: () => carlsonRC,
@@ -120,12 +125,14 @@ __export(typed_exports, {
   cube: () => cube,
   cubicSpline: () => cubicSpline,
   curvefit: () => curvefit,
+  dagostinoTest: () => dagostinoTest,
   dct: () => dct,
   deepEqual: () => deepEqual,
   degree: () => degree,
   delaunayTriangulation: () => delaunayTriangulation,
   differences: () => differences,
   digamma: () => digamma,
+  discreteUniformDist: () => discreteUniformDist,
   discriminant: () => discriminant,
   distance2D: () => distance2D,
   distance3D: () => distance3D,
@@ -178,6 +185,7 @@ __export(typed_exports, {
   fourier: () => fourier,
   fresnelC: () => fresnelC,
   fresnelS: () => fresnelS,
+  friedmanTest: () => friedmanTest,
   fullSimplify: () => fullSimplify,
   functionExpand: () => functionExpand,
   fuseUnaryChain: () => fuseUnaryChain,
@@ -198,6 +206,7 @@ __export(typed_exports, {
   graphDistance: () => graphDistance,
   griddata: () => griddata,
   groupDelay: () => groupDelay,
+  gumbelDist: () => gumbelDist,
   harmonicNumber: () => harmonicNumber,
   hermiteH: () => hermiteH,
   hermiteInterp: () => hermiteInterp,
@@ -205,6 +214,8 @@ __export(typed_exports, {
   hex: () => hex,
   highpassFilter: () => highpassFilter,
   hilbertTransform: () => hilbertTransform,
+  hotellingT2: () => hotellingT2,
+  hypergeometricDist: () => hypergeometricDist,
   hypot: () => hypot,
   idct: () => idct,
   idst: () => idst,
@@ -217,12 +228,14 @@ __export(typed_exports, {
   intersectLines2D: () => intersectLines2D,
   intersectSegments2D: () => intersectSegments2D,
   invFourier: () => invFourier,
+  invGaussDist: () => invGaussDist,
   isConnected: () => isConnected,
   jacobiSymbol: () => jacobiSymbol,
   jordanForm: () => jordanForm,
   jsDivergence: () => jsDivergence,
   kdTree: () => kdTree,
   kdTreeNearest: () => kdTreeNearest,
+  kolmogorovSmirnov2Test: () => kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest: () => kolmogorovSmirnovTest,
   lagrangeInterp: () => lagrangeInterp,
   laguerreL: () => laguerreL,
@@ -234,6 +247,7 @@ __export(typed_exports, {
   leftShift: () => leftShift,
   legendreFit: () => legendreFit,
   legendreP: () => legendreP,
+  leveneTest: () => leveneTest,
   lgamma: () => lgamma,
   linearInterp: () => linearInterp,
   linprog: () => linprog,
@@ -250,6 +264,7 @@ __export(typed_exports, {
   lowpassFilter: () => lowpassFilter,
   lucas: () => lucas,
   lucasL: () => lucasL,
+  mahalanobis: () => mahalanobis,
   manhattanDistance: () => manhattanDistance,
   mannWhitneyTest: () => mannWhitneyTest,
   matmul: () => matmul,
@@ -264,6 +279,7 @@ __export(typed_exports, {
   maxSelect: () => maxSelect,
   maximize: () => maximize,
   mean: () => mean,
+  meanCI: () => meanCI,
   medfilt: () => medfilt,
   medianSelect: () => medianSelect,
   min: () => min,
@@ -275,8 +291,11 @@ __export(typed_exports, {
   moebiusMu: () => moebiusMu,
   multiTaperPSD: () => multiTaperPSD,
   multinomial: () => multinomial,
+  multipleComparison: () => multipleComparison,
   multiply: () => multiply,
+  multivariateNormal: () => multivariateNormal,
   nearestNeighbor: () => nearestNeighbor,
+  negativeBinomialDist: () => negativeBinomialDist,
   newtonInterp: () => newtonInterp,
   nextPrime: () => nextPrime,
   nintegrate: () => nintegrate,
@@ -323,10 +342,12 @@ __export(typed_exports, {
   parallelStatSum: () => parallelStatSum,
   parallelStatVariance: () => parallelStatVariance,
   parallelXCorr: () => parallelXCorr,
+  paretoDist: () => paretoDist,
   partitions: () => partitions,
   pchip: () => pchip,
   pchipInterp: () => pchipInterp,
   periodogram: () => periodogram,
+  permutationTest: () => permutationTest,
   permutations: () => permutations,
   pickRandom: () => pickRandom,
   pinv: () => pinv,
@@ -354,11 +375,14 @@ __export(typed_exports, {
   principalComponentAnalysis: () => principalComponentAnalysis,
   print: () => print,
   projectVector: () => projectVector,
+  proportionCI: () => proportionCI,
+  proportionZTest: () => proportionZTest,
   quadprog: () => quadprog,
   quickSelect: () => quickSelect,
   random: () => random,
   randomInt: () => randomInt,
   rank: () => rank,
+  rayleighDist: () => rayleighDist,
   rbfInterpolate: () => rbfInterpolate,
   re: () => re,
   reduce: () => reduce,
@@ -410,6 +434,7 @@ __export(typed_exports, {
   stronglyConnectedComponents: () => stronglyConnectedComponents,
   studentTPDF: () => studentTPDF,
   studentTTest: () => studentTTest,
+  studentTTestPaired: () => studentTTestPaired,
   subfactorial: () => subfactorial,
   substitute: () => substitute,
   subtract: () => subtract,
@@ -432,6 +457,7 @@ __export(typed_exports, {
   trapz: () => trapz,
   trapzF64: () => trapzF64,
   triangleArea: () => triangleArea,
+  triangularDist: () => triangularDist,
   trigExpand: () => trigExpand,
   trigReduce: () => trigReduce,
   trigToExp: () => trigToExp,
@@ -12813,12 +12839,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,9 +13510,337 @@ 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;
+    })
+  };
+}
+var EULER_GAMMA = 0.5772156649015329;
+function _contSample(quantile, rng) {
+  return quantile(rng());
+}
+function paretoDist(b, xm) {
+  if (b <= 0 || xm <= 0) throw new Error("paretoDist: shape b and scale xm must be positive");
+  const quantile = (p) => p <= 0 ? xm : p >= 1 ? Infinity : xm / Math.pow(1 - p, 1 / b);
+  return {
+    pdf: (x) => x < xm ? 0 : b * Math.pow(xm, b) / Math.pow(x, b + 1),
+    cdf: (x) => x < xm ? 0 : 1 - Math.pow(xm / x, b),
+    quantile,
+    mean: b > 1 ? b * xm / (b - 1) : Infinity,
+    variance: b > 2 ? xm * xm * b / ((b - 1) * (b - 1) * (b - 2)) : Infinity,
+    sample: () => _contSample(quantile, Math.random),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = _contSample(quantile, rng);
+      return out;
+    })
+  };
+}
+function rayleighDist(sigma) {
+  if (sigma <= 0) throw new Error("rayleighDist: sigma must be positive");
+  const s2 = sigma * sigma;
+  const quantile = (p) => p <= 0 ? 0 : p >= 1 ? Infinity : sigma * Math.sqrt(-2 * Math.log(1 - p));
+  return {
+    pdf: (x) => x < 0 ? 0 : x / s2 * Math.exp(-(x * x) / (2 * s2)),
+    cdf: (x) => x < 0 ? 0 : 1 - Math.exp(-(x * x) / (2 * s2)),
+    quantile,
+    mean: sigma * Math.sqrt(Math.PI / 2),
+    variance: (4 - Math.PI) / 2 * s2,
+    sample: () => _contSample(quantile, Math.random),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = _contSample(quantile, rng);
+      return out;
+    })
+  };
+}
+function triangularDist(a, c, b) {
+  if (!(a <= c && c <= b && a < b))
+    throw new Error("triangularDist: require a <= mode <= b, a < b");
+  const quantile = (p) => {
+    if (p <= 0) return a;
+    if (p >= 1) return b;
+    const fc = (c - a) / (b - a);
+    return p < fc ? a + Math.sqrt(p * (b - a) * (c - a)) : b - Math.sqrt((1 - p) * (b - a) * (b - c));
+  };
+  return {
+    pdf: (x) => {
+      if (x < a || x > b) return 0;
+      if (x < c) return 2 * (x - a) / ((b - a) * (c - a));
+      if (x > c) return 2 * (b - x) / ((b - a) * (b - c));
+      return 2 / (b - a);
+    },
+    cdf: (x) => {
+      if (x <= a) return 0;
+      if (x >= b) return 1;
+      return x < c ? (x - a) * (x - a) / ((b - a) * (c - a)) : 1 - (b - x) * (b - x) / ((b - a) * (b - c));
+    },
+    quantile,
+    mean: (a + c + b) / 3,
+    variance: (a * a + c * c + b * b - a * c - a * b - c * b) / 18,
+    sample: () => _contSample(quantile, Math.random),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = _contSample(quantile, rng);
+      return out;
+    })
+  };
+}
+function discreteUniformDist(lo, hi) {
+  if (!Number.isInteger(lo) || !Number.isInteger(hi) || hi < lo) {
+    throw new Error("discreteUniformDist: require integer lo <= hi");
+  }
+  const k = hi - lo + 1;
+  const cdf = (x) => {
+    if (x < lo) return 0;
+    if (x >= hi) return 1;
+    return (Math.floor(x) - lo + 1) / k;
+  };
+  return {
+    pdf: (x) => Number.isInteger(x) && x >= lo && x <= hi ? 1 / k : 0,
+    cdf,
+    quantile: (p) => {
+      if (p <= 0) return lo;
+      if (p >= 1) return hi;
+      return Math.min(hi, lo + Math.ceil(p * k) - 1);
+    },
+    mean: (lo + hi) / 2,
+    variance: (k * k - 1) / 12,
+    sample: () => lo + Math.floor(Math.random() * k),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = lo + Math.floor(rng() * k);
+      return out;
+    })
+  };
+}
+function gumbelDist(mu, beta2) {
+  if (beta2 <= 0) throw new Error("gumbelDist: scale beta must be positive");
+  const quantile = (p) => p <= 0 ? -Infinity : p >= 1 ? Infinity : mu - beta2 * Math.log(-Math.log(p));
+  return {
+    pdf: (x) => {
+      const z = (x - mu) / beta2;
+      return 1 / beta2 * Math.exp(-(z + Math.exp(-z)));
+    },
+    cdf: (x) => Math.exp(-Math.exp(-(x - mu) / beta2)),
+    quantile,
+    mean: mu + beta2 * EULER_GAMMA,
+    variance: Math.PI * Math.PI / 6 * beta2 * beta2,
+    sample: () => _contSample(quantile, Math.random),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = _contSample(quantile, rng);
+      return out;
+    })
+  };
+}
+function invGaussDist(mu, lambda) {
+  if (mu <= 0 || lambda <= 0) throw new Error("invGaussDist: mu and lambda must be positive");
+  const quantile = (p) => {
+    if (p <= 0) return 0;
+    if (p >= 1) return Infinity;
+    let lo = 1e-9;
+    let hi = mu * 100;
+    for (let it = 0; it < 200; it++) {
+      const mid = (lo + hi) / 2;
+      if (cdf(mid) < p) lo = mid;
+      else hi = mid;
+    }
+    return (lo + hi) / 2;
+  };
+  const cdf = (x) => {
+    if (x <= 0) return 0;
+    const a = Math.sqrt(lambda / x) * (x / mu - 1);
+    const b = -Math.sqrt(lambda / x) * (x / mu + 1);
+    return _normalCdfStd(a) + Math.exp(2 * lambda / mu) * _normalCdfStd(b);
+  };
+  return {
+    pdf: (x) => {
+      if (x <= 0) return 0;
+      return Math.sqrt(lambda / (2 * Math.PI * x * x * x)) * Math.exp(-lambda * (x - mu) * (x - mu) / (2 * mu * mu * x));
+    },
+    cdf,
+    quantile,
+    mean: mu,
+    variance: mu * mu * mu / lambda,
+    sample: () => _contSample(quantile, Math.random),
+    sampleN: (n, opts) => _sampleNDispatch(null, [], n, opts, (count2, rng) => {
+      const out = new Float64Array(count2);
+      for (let j = 0; j < count2; j++) out[j] = _contSample(quantile, rng);
+      return out;
+    })
+  };
+}
+function _cholesky(m) {
+  const n = m.length;
+  const L = Array.from({ length: n }, () => new Array(n).fill(0));
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j <= i; j++) {
+      let s = m[i][j];
+      for (let k = 0; k < j; k++) s -= L[i][k] * L[j][k];
+      if (i === j) {
+        if (s <= 0) throw new Error("multivariateNormal: covariance is not positive-definite");
+        L[i][j] = Math.sqrt(s);
+      } else {
+        L[i][j] = s / L[j][j];
+      }
+    }
+  }
+  return L;
+}
+function multivariateNormal(mean6, cov2) {
+  const k = mean6.length;
+  if (cov2.length !== k || cov2.some((row2) => row2.length !== k)) {
+    throw new Error("multivariateNormal: cov must be a k\xD7k matrix matching mean");
+  }
+  const L = _cholesky(cov2);
+  let logDet = 0;
+  for (let i = 0; i < k; i++) logDet += 2 * Math.log(L[i][i]);
+  return {
+    mean: mean6,
+    cov: cov2,
+    pdf: (x) => {
+      if (x.length !== k) throw new Error("multivariateNormal.pdf: x must have length k");
+      const z = new Array(k).fill(0);
+      for (let i = 0; i < k; i++) {
+        let s = x[i] - mean6[i];
+        for (let j = 0; j < i; j++) s -= L[i][j] * z[j];
+        z[i] = s / L[i][i];
+      }
+      let quad = 0;
+      for (let i = 0; i < k; i++) quad += z[i] * z[i];
+      return Math.exp(-0.5 * (k * Math.log(2 * Math.PI) + logDet + quad));
+    }
+  };
+}
 
 // src/typed/hypothesis.ts
 import { computePool as computePool10 } from "@danielsimonjr/mathts-parallel";
+
+// src/distribution-functions.ts
+var normalQuantile = (p, mu = 0, sigma = 1) => normalDist(mu, sigma).quantile(p);
+var studentTCDF = (x, df) => tDist(df).cdf(x);
+var studentTQuantile = (p, df) => tDist(df).quantile(p);
+var chiSquaredCDF = (x, df) => chiSquaredDist(df).cdf(x);
+var chiSquaredQuantile = (p, df) => chiSquaredDist(df).quantile(p);
+var fCDF = (x, d1, d2) => fDist(d1, d2).cdf(x);
+var fQuantile = (p, d1, d2) => fDist(d1, d2).quantile(p);
+var gammaCDF = (x, shape, rate = 1) => gammaDist(shape, rate).cdf(x);
+var gammaQuantile = (p, shape, rate = 1) => gammaDist(shape, rate).quantile(p);
+var betaCDF = (x, a, b) => betaDist(a, b).cdf(x);
+var betaQuantile = (p, a, b) => betaDist(a, b).quantile(p);
+var cauchyPDF = (x, x0 = 0, gamma2 = 1) => 1 / (Math.PI * gamma2 * (1 + ((x - x0) / gamma2) ** 2));
+var cauchyCDF = (x, x0 = 0, gamma2 = 1) => 0.5 + Math.atan((x - x0) / gamma2) / Math.PI;
+var cauchyQuantile = (p, x0 = 0, gamma2 = 1) => x0 + gamma2 * Math.tan(Math.PI * (p - 0.5));
+var laplacePDF = (x, mu = 0, b = 1) => Math.exp(-Math.abs(x - mu) / b) / (2 * b);
+var laplaceCDF = (x, mu = 0, b = 1) => x < mu ? 0.5 * Math.exp((x - mu) / b) : 1 - 0.5 * Math.exp(-(x - mu) / b);
+var laplaceQuantile = (p, mu = 0, b = 1) => p < 0.5 ? mu + b * Math.log(2 * p) : mu - b * Math.log(2 - 2 * p);
+var logisticPDF = (x, mu = 0, s = 1) => {
+  const e = Math.exp(-(x - mu) / s);
+  return e / (s * (1 + e) ** 2);
+};
+var logisticCDF = (x, mu = 0, s = 1) => 1 / (1 + Math.exp(-(x - mu) / s));
+var logisticQuantile = (p, mu = 0, s = 1) => mu + s * Math.log(p / (1 - p));
+
+// src/typed/hypothesis.ts
 var HYPOTHESIS_THRESHOLD = 4096;
 function _makeMulberry322(seed) {
   let s = seed | 0;
@@ -14252,6 +14601,407 @@ 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) };
+}
+function _skewKurt(a) {
+  const n = a.length;
+  const m = _mean(a);
+  let m2 = 0;
+  let m3 = 0;
+  let m4 = 0;
+  for (const v of a) {
+    const d = v - m;
+    m2 += d * d;
+    m3 += d * d * d;
+    m4 += d * d * d * d;
+  }
+  const mu2 = m2 / n;
+  return { skew: m3 / n / Math.pow(mu2, 1.5), kurtPearson: m4 / n / (mu2 * mu2) };
+}
+function andersonDarlingTest(data) {
+  const n = data.length;
+  if (n < 8) throw new Error("andersonDarlingTest: need at least 8 observations");
+  const sorted = data.slice().sort((p2, q) => p2 - q);
+  const mean6 = _mean(sorted);
+  const s = Math.sqrt(_variance(sorted, 1));
+  const phi = (z) => 0.5 * erfcScalar(-z / Math.SQRT2);
+  let sumTerm = 0;
+  for (let i = 0; i < n; i++) {
+    const wi = (sorted[i] - mean6) / s;
+    const wj = (sorted[n - 1 - i] - mean6) / s;
+    sumTerm += (2 * (i + 1) - 1) / n * (Math.log(phi(wi)) + Math.log(1 - phi(wj)));
+  }
+  const a2 = -n - sumTerm;
+  const a2s = a2 * (1 + 0.75 / n + 2.25 / (n * n));
+  let p;
+  if (a2s < 0.2) p = 1 - Math.exp(-13.436 + 101.14 * a2s - 223.73 * a2s * a2s);
+  else if (a2s < 0.34) p = 1 - Math.exp(-8.318 + 42.796 * a2s - 59.938 * a2s * a2s);
+  else if (a2s < 0.6) p = Math.exp(0.9177 - 4.279 * a2s - 1.38 * a2s * a2s);
+  else if (a2s < 10) p = Math.exp(1.2937 - 5.709 * a2s + 0.0186 * a2s * a2s);
+  else p = 0;
+  return { statistic: a2, pValue: Math.max(0, Math.min(1, p)) };
+}
+function dagostinoTest(data) {
+  const n = data.length;
+  if (n < 8) throw new Error("dagostinoTest: need at least 8 observations");
+  const { skew, kurtPearson } = _skewKurt(data);
+  const y = skew * Math.sqrt((n + 1) * (n + 3) / (6 * (n - 2)));
+  const beta2 = 3 * (n * n + 27 * n - 70) * (n + 1) * (n + 3) / ((n - 2) * (n + 5) * (n + 7) * (n + 9));
+  const w2 = -1 + Math.sqrt(2 * (beta2 - 1));
+  const delta = 1 / Math.sqrt(0.5 * Math.log(w2));
+  const alpha = Math.sqrt(2 / (w2 - 1));
+  const yy = y === 0 ? 1 : y;
+  const z1 = delta * Math.log(yy / alpha + Math.sqrt(yy / alpha * (yy / alpha) + 1));
+  const E = 3 * (n - 1) / (n + 1);
+  const varb2 = 24 * n * (n - 2) * (n - 3) / ((n + 1) * (n + 1) * (n + 3) * (n + 5));
+  const xx = (kurtPearson - E) / Math.sqrt(varb2);
+  const sqrtbeta1 = 6 * (n * n - 5 * n + 2) / ((n + 7) * (n + 9)) * Math.sqrt(6 * (n + 3) * (n + 5) / (n * (n - 2) * (n - 3)));
+  const A = 6 + 8 / sqrtbeta1 * (2 / sqrtbeta1 + Math.sqrt(1 + 4 / (sqrtbeta1 * sqrtbeta1)));
+  const term1 = 1 - 2 / (9 * A);
+  const denom = 1 + xx * Math.sqrt(2 / (A - 4));
+  const term2 = Math.sign(denom) * Math.cbrt((1 - 2 / A) / Math.abs(denom));
+  const z2 = (term1 - term2) / Math.sqrt(2 / (9 * A));
+  const k2 = z1 * z1 + z2 * z2;
+  return { statistic: k2, pValue: Math.exp(-k2 / 2) };
+}
+function friedmanTest(groups) {
+  const k = groups.length;
+  if (k < 3) throw new Error("friedmanTest: need at least 3 related groups");
+  const n = groups[0].length;
+  for (const g of groups)
+    if (g.length !== n) throw new Error("friedmanTest: all groups must be the same length");
+  const rankSums = new Array(k).fill(0);
+  let tieCorrection = 0;
+  for (let block = 0; block < n; block++) {
+    const row2 = groups.map((g) => g[block]);
+    const order = row2.map((_, i) => i).sort((i, j) => row2[i] - row2[j]);
+    const ranks = new Array(k);
+    for (let i = 0; i < k; ) {
+      let j = i;
+      while (j < k && row2[order[j]] === row2[order[i]]) j++;
+      const avg = (i + 1 + j) / 2;
+      const t = j - i;
+      if (t > 1) tieCorrection += t * t * t - t;
+      for (let m = i; m < j; m++) ranks[order[m]] = avg;
+      i = j;
+    }
+    for (let g = 0; g < k; g++) rankSums[g] += ranks[g];
+  }
+  let stat = 12 / (n * k * (k + 1)) * rankSums.reduce((acc, rr) => acc + rr * rr, 0) - 3 * n * (k + 1);
+  const c = 1 - tieCorrection / (n * k * (k * k - 1));
+  if (c !== 0) stat /= c;
+  const df = k - 1;
+  return { statistic: stat, pValue: _chiSquaredPValue(stat, df), degreesOfFreedom: df };
+}
+function anova2(data) {
+  const nA = data.length;
+  const nB = data[0].length;
+  const r = data[0][0].length;
+  if (nA < 2 || nB < 2 || r < 2)
+    throw new Error("anova2: need at least 2 levels per factor and 2 replicates");
+  const all = [];
+  for (const row2 of data) for (const cell of row2) for (const v of cell) all.push(v);
+  const grand = _mean(all);
+  const aMeans = data.map((row2) => _mean(row2.flat()));
+  const bMeans = Array.from({ length: nB }, (_, j) => _mean(data.map((row2) => row2[j]).flat()));
+  const cellMeans = data.map((row2) => row2.map((cell) => _mean(cell)));
+  let ssA = 0;
+  for (const am of aMeans) ssA += (am - grand) * (am - grand);
+  ssA *= nB * r;
+  let ssB = 0;
+  for (const bm of bMeans) ssB += (bm - grand) * (bm - grand);
+  ssB *= nA * r;
+  let ssAB = 0;
+  let sse = 0;
+  for (let i = 0; i < nA; i++) {
+    for (let j = 0; j < nB; j++) {
+      const d = cellMeans[i][j] - aMeans[i] - bMeans[j] + grand;
+      ssAB += d * d;
+      for (const v of data[i][j]) sse += (v - cellMeans[i][j]) * (v - cellMeans[i][j]);
+    }
+  }
+  ssAB *= r;
+  const dfA = nA - 1;
+  const dfB = nB - 1;
+  const dfAB = dfA * dfB;
+  const dfE = nA * nB * (r - 1);
+  const mse = sse / dfE;
+  const fA = ssA / dfA / mse;
+  const fB = ssB / dfB / mse;
+  const fAB = ssAB / dfAB / mse;
+  return {
+    factorA: { F: fA, pValue: _fPValue(fA, dfA, dfE), degreesOfFreedom: [dfA, dfE] },
+    factorB: { F: fB, pValue: _fPValue(fB, dfB, dfE), degreesOfFreedom: [dfB, dfE] },
+    interaction: { F: fAB, pValue: _fPValue(fAB, dfAB, dfE), degreesOfFreedom: [dfAB, dfE] }
+  };
+}
+function multipleComparison(pValues, method = "bh") {
+  const m = pValues.length;
+  if (m === 0) return [];
+  if (method === "bonferroni") return pValues.map((p) => Math.min(p * m, 1));
+  const order = pValues.map((_, i) => i).sort((i, j) => pValues[i] - pValues[j]);
+  const out = new Array(m);
+  if (method === "holm") {
+    let running = 0;
+    for (let rank2 = 0; rank2 < m; rank2++) {
+      const idx = order[rank2];
+      running = Math.max(running, (m - rank2) * pValues[idx]);
+      out[idx] = Math.min(running, 1);
+    }
+  } else {
+    let prev = 1;
+    for (let rank2 = m - 1; rank2 >= 0; rank2--) {
+      const idx = order[rank2];
+      prev = Math.min(prev, pValues[idx] * m / (rank2 + 1));
+      out[idx] = Math.min(prev, 1);
+    }
+  }
+  return out;
+}
+function meanCI(data, confidence = 0.95) {
+  const n = data.length;
+  if (n < 2) throw new Error("meanCI: need at least 2 observations");
+  const m = _mean(data);
+  const se = Math.sqrt(_variance(data, 1) / n);
+  const tcrit = studentTQuantile((1 + confidence) / 2, n - 1);
+  return { estimate: m, lower: m - tcrit * se, upper: m + tcrit * se, confidence };
+}
+function proportionCI(successes, n, confidence = 0.95) {
+  if (n <= 0 || successes < 0 || successes > n) {
+    throw new Error("proportionCI: require 0 <= successes <= n, n > 0");
+  }
+  const p = successes / n;
+  const z = normalQuantile((1 + confidence) / 2);
+  const half = z * Math.sqrt(p * (1 - p) / n);
+  return { estimate: p, lower: p - half, upper: p + half, confidence };
+}
+function bootstrapCI(data, statistic, opts = {}) {
+  const n = data.length;
+  if (n < 2) throw new Error("bootstrapCI: need at least 2 observations");
+  const confidence = opts.confidence ?? 0.95;
+  const B = opts.resamples ?? 2e3;
+  const rng = opts.seed !== void 0 ? _makeMulberry322(opts.seed) : Math.random;
+  const stats = new Float64Array(B);
+  const resample2 = new Array(n);
+  for (let b = 0; b < B; b++) {
+    for (let i = 0; i < n; i++) resample2[i] = data[Math.floor(rng() * n)];
+    stats[b] = statistic(resample2);
+  }
+  stats.sort();
+  const loIdx = Math.floor((1 - confidence) / 2 * B);
+  const hiIdx = Math.min(B - 1, Math.ceil((1 - (1 - confidence) / 2) * B) - 1);
+  return { estimate: statistic(data), lower: stats[loIdx], upper: stats[hiIdx], confidence };
+}
+function permutationTest(a, b, statistic, opts = {}) {
+  const na = a.length;
+  const nb = b.length;
+  const B = opts.resamples ?? 2e3;
+  const rng = opts.seed !== void 0 ? _makeMulberry322(opts.seed) : Math.random;
+  const observed = statistic(a, b);
+  const pool = new Float64Array(na + nb);
+  for (let i = 0; i < na; i++) pool[i] = a[i];
+  for (let i = 0; i < nb; i++) pool[na + i] = b[i];
+  let extreme = 1;
+  for (let p = 0; p < B; p++) {
+    _shuffle(pool, rng);
+    const x = Array.from(pool.subarray(0, na));
+    const y = Array.from(pool.subarray(na));
+    if (Math.abs(statistic(x, y)) >= Math.abs(observed) - 1e-12) extreme++;
+  }
+  return { statistic: observed, pValue: extreme / (B + 1) };
+}
+function _matInverse(m) {
+  const n = m.length;
+  const a = m.map((row2, i) => [...row2, ...Array.from({ length: n }, (_, j) => i === j ? 1 : 0)]);
+  for (let col = 0; col < n; col++) {
+    let pivot = col;
+    for (let r = col + 1; r < n; r++) if (Math.abs(a[r][col]) > Math.abs(a[pivot][col])) pivot = r;
+    if (Math.abs(a[pivot][col]) < 1e-15) throw new Error("matrix inverse: singular matrix");
+    [a[col], a[pivot]] = [a[pivot], a[col]];
+    const d = a[col][col];
+    for (let j = 0; j < 2 * n; j++) a[col][j] /= d;
+    for (let r = 0; r < n; r++) {
+      if (r === col) continue;
+      const f = a[r][col];
+      for (let j = 0; j < 2 * n; j++) a[r][j] -= f * a[col][j];
+    }
+  }
+  return a.map((row2) => row2.slice(n));
+}
+function _quadForm(d, M) {
+  const n = d.length;
+  let s = 0;
+  for (let i = 0; i < n; i++) {
+    let mi = 0;
+    for (let j = 0; j < n; j++) mi += M[i][j] * d[j];
+    s += d[i] * mi;
+  }
+  return s;
+}
+function mahalanobis(u, v, cov2) {
+  if (u.length !== v.length || cov2.length !== u.length) {
+    throw new Error("mahalanobis: u, v, and cov dimensions must match");
+  }
+  const inv2 = _matInverse(cov2);
+  const d = u.map((ui, i) => ui - v[i]);
+  return Math.sqrt(_quadForm(d, inv2));
+}
+function hotellingT2(data, mu0) {
+  const n = data.length;
+  const p = mu0.length;
+  if (n <= p) throw new Error("hotellingT2: need more observations than variables");
+  if (data.some((row2) => row2.length !== p))
+    throw new Error("hotellingT2: every row must have length p");
+  const xbar = Array.from({ length: p }, (_, j) => _mean(data.map((row2) => row2[j])));
+  const S = Array.from({ length: p }, () => new Array(p).fill(0));
+  for (const row2 of data) {
+    for (let i = 0; i < p; i++) {
+      for (let j = 0; j < p; j++) S[i][j] += (row2[i] - xbar[i]) * (row2[j] - xbar[j]);
+    }
+  }
+  for (let i = 0; i < p; i++) for (let j = 0; j < p; j++) S[i][j] /= n - 1;
+  const diff2 = xbar.map((x, i) => x - mu0[i]);
+  const t2 = n * _quadForm(diff2, _matInverse(S));
+  const f = (n - p) / (p * (n - 1)) * t2;
+  return {
+    statistic: t2,
+    fStatistic: f,
+    pValue: _fPValue(f, p, n - p),
+    degreesOfFreedom: [p, n - p]
+  };
+}
 
 // src/typed/matrix-ops.ts
 import {
@@ -33488,7 +34238,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 +34275,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 +34285,7 @@ var createMedian = /* @__PURE__ */ factory(
         if (containsCollections(args)) {
           throw new TypeError("Scalar values expected in function median");
         }
-        return _median(args);
+        return _median2(args);
       }
     });
   }
@@ -42536,6 +43286,186 @@ 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;
+}
+function _tTwoTail(t, df) {
+  return 2 * (1 - studentTCDF(Math.abs(t), df));
+}
+function linregress(x, y) {
+  const n = x.length;
+  if (n !== y.length) throw new Error("linregress: x and y must have equal length");
+  if (n < 3) throw new Error("linregress: need at least 3 points for inference");
+  const xa = Array.from(x);
+  const ya = Array.from(y);
+  const xbar = mean2(xa);
+  const ybar = mean2(ya);
+  let sxx = 0;
+  let sxy = 0;
+  let syy = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xa[i] - xbar;
+    const dy = ya[i] - ybar;
+    sxx += dx * dx;
+    sxy += dx * dy;
+    syy += dy * dy;
+  }
+  const slope = sxy / sxx;
+  const intercept = ybar - slope * xbar;
+  const rValue = sxy / Math.sqrt(sxx * syy);
+  const df = n - 2;
+  const s2 = (syy - slope * sxy) / df;
+  const stdErr = Math.sqrt(s2 / sxx);
+  const interceptStdErr = Math.sqrt(s2 * (1 / n + xbar * xbar / sxx));
+  return {
+    slope,
+    intercept,
+    rValue,
+    pValue: _tTwoTail(slope / stdErr, df),
+    stdErr,
+    interceptStdErr
+  };
+}
+function _corrTPValue(r, n) {
+  const df = n - 2;
+  if (df <= 0 || Math.abs(r) >= 1) return Math.abs(r) >= 1 ? 0 : 1;
+  const t = r * Math.sqrt(df / (1 - r * r));
+  return _tTwoTail(t, df);
+}
+function _pearson(x, y) {
+  const xa = Array.from(x);
+  const ya = Array.from(y);
+  const n = xa.length;
+  if (n !== ya.length) throw new Error("pearsonr: inputs must have equal length");
+  const mx = mean2(xa);
+  const my = mean2(ya);
+  let sxy = 0;
+  let sxx = 0;
+  let syy = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = xa[i] - mx;
+    const dy = ya[i] - my;
+    sxy += dx * dy;
+    sxx += dx * dx;
+    syy += dy * dy;
+  }
+  return sxy / Math.sqrt(sxx * syy);
+}
+function pearsonr(x, y) {
+  const r = _pearson(x, y);
+  return { coefficient: r, pValue: _corrTPValue(r, x.length) };
+}
+function spearmanr(x, y) {
+  const rho = spearman(x, y);
+  return { coefficient: rho, pValue: _corrTPValue(rho, x.length) };
+}
+function kendalltau(x, y) {
+  const tau2 = kendallTau(x, y);
+  const n = x.length;
+  const z = 3 * tau2 * Math.sqrt(n * (n - 1)) / Math.sqrt(2 * (2 * n + 5));
+  return { coefficient: tau2, pValue: 2 * (1 - normalCDF(Math.abs(z))) };
+}
+function ptp(x) {
+  const a = Array.from(x);
+  if (a.length === 0) return NaN;
+  let lo = a[0];
+  let hi = a[0];
+  for (const v of a) {
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  return hi - lo;
+}
+function variation(x) {
+  const a = Array.from(x);
+  return stdPop(a) / mean2(a);
+}
+function trimmedMean(x, proportion) {
+  if (proportion < 0 || proportion >= 0.5) {
+    throw new Error("trimmedMean: proportion must be in [0, 0.5)");
+  }
+  const a = Array.from(x).sort((p, q) => p - q);
+  const k = Math.floor(a.length * proportion);
+  return mean2(a.slice(k, a.length - k));
+}
+function describe(x) {
+  const a = Array.from(x);
+  const n = a.length;
+  if (n < 1) throw new Error("describe: input must be non-empty");
+  const m = mean2(a);
+  let m2 = 0;
+  let m3 = 0;
+  let m4 = 0;
+  let lo = a[0];
+  let hi = a[0];
+  for (const v of a) {
+    const d = v - m;
+    m2 += d * d;
+    m3 += d * d * d;
+    m4 += d * d * d * d;
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  const mu2 = m2 / n;
+  return {
+    nobs: n,
+    min: lo,
+    max: hi,
+    mean: m,
+    variance: m2 / (n - 1),
+    skewness: m3 / n / Math.pow(mu2, 1.5),
+    kurtosis: m4 / n / (mu2 * mu2) - 3
+  };
+}
+function histogram(x, bins = 10) {
+  const a = Array.from(x);
+  if (a.length === 0) throw new Error("histogram: input must be non-empty");
+  if (!Number.isInteger(bins) || bins < 1)
+    throw new Error("histogram: bins must be a positive integer");
+  let lo = a[0];
+  let hi = a[0];
+  for (const v of a) {
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  if (lo === hi) {
+    lo -= 0.5;
+    hi += 0.5;
+  }
+  const width = (hi - lo) / bins;
+  const edges = Array.from({ length: bins + 1 }, (_, i) => lo + i * width);
+  const counts = new Array(bins).fill(0);
+  for (const v of a) {
+    let idx = Math.floor((v - lo) / width);
+    if (idx === bins) idx = bins - 1;
+    if (idx >= 0 && idx < bins) counts[idx]++;
+  }
+  return { counts, edges };
+}
 
 // src/numeric-extra.ts
 var toArr = (x) => Array.isArray(x) ? x : Array.from(x);
@@ -42621,31 +43551,6 @@ function cumtrapz(y, x) {
   return out;
 }
 
-// src/distribution-functions.ts
-var normalQuantile = (p, mu = 0, sigma = 1) => normalDist(mu, sigma).quantile(p);
-var studentTCDF = (x, df) => tDist(df).cdf(x);
-var studentTQuantile = (p, df) => tDist(df).quantile(p);
-var chiSquaredCDF = (x, df) => chiSquaredDist(df).cdf(x);
-var chiSquaredQuantile = (p, df) => chiSquaredDist(df).quantile(p);
-var fCDF = (x, d1, d2) => fDist(d1, d2).cdf(x);
-var fQuantile = (p, d1, d2) => fDist(d1, d2).quantile(p);
-var gammaCDF = (x, shape, rate = 1) => gammaDist(shape, rate).cdf(x);
-var gammaQuantile = (p, shape, rate = 1) => gammaDist(shape, rate).quantile(p);
-var betaCDF = (x, a, b) => betaDist(a, b).cdf(x);
-var betaQuantile = (p, a, b) => betaDist(a, b).quantile(p);
-var cauchyPDF = (x, x0 = 0, gamma2 = 1) => 1 / (Math.PI * gamma2 * (1 + ((x - x0) / gamma2) ** 2));
-var cauchyCDF = (x, x0 = 0, gamma2 = 1) => 0.5 + Math.atan((x - x0) / gamma2) / Math.PI;
-var cauchyQuantile = (p, x0 = 0, gamma2 = 1) => x0 + gamma2 * Math.tan(Math.PI * (p - 0.5));
-var laplacePDF = (x, mu = 0, b = 1) => Math.exp(-Math.abs(x - mu) / b) / (2 * b);
-var laplaceCDF = (x, mu = 0, b = 1) => x < mu ? 0.5 * Math.exp((x - mu) / b) : 1 - 0.5 * Math.exp(-(x - mu) / b);
-var laplaceQuantile = (p, mu = 0, b = 1) => p < 0.5 ? mu + b * Math.log(2 * p) : mu - b * Math.log(2 - 2 * p);
-var logisticPDF = (x, mu = 0, s = 1) => {
-  const e = Math.exp(-(x - mu) / s);
-  return e / (s * (1 + e) ** 2);
-};
-var logisticCDF = (x, mu = 0, s = 1) => 1 / (1 + Math.exp(-(x - mu) / s));
-var logisticQuantile = (p, mu = 0, s = 1) => mu + s * Math.log(p / (1 - p));
-
 // src/hypothesis-extra.ts
 var arr2 = (x) => Array.isArray(x) ? x : Array.from(x);
 var sampleVar = (x) => variance(x);
@@ -43695,9 +44600,11 @@ export {
   airyAi,
   airyBi,
   and,
+  andersonDarlingTest,
   angle2D,
   angle3D,
   anova,
+  anova2,
   apart,
   mapSlices as apply,
   area,
@@ -43716,6 +44623,7 @@ export {
   avogadro,
   bandpassFilter,
   bartlettPSD,
+  bartlettTest,
   bellNumbers,
   bernoulli,
   bernoulliPMF,
@@ -43740,6 +44648,7 @@ export {
   bin,
   binomialDist,
   binomialPMF,
+  binomialTest,
   bitAnd,
   bitNot,
   bitOr,
@@ -43748,6 +44657,7 @@ export {
   bohrRadius,
   boltzmann,
   boolean,
+  bootstrapCI,
   bspline,
   butter,
   cancel,
@@ -43846,12 +44756,14 @@ export {
   cumtrapz,
   curl,
   curvefit,
+  dagostinoTest,
   dct,
   deepEqual,
   degree,
   delaunayTriangulation,
   derivative,
   derivativeAt,
+  describe,
   det,
   detrend,
   deuteronMass,
@@ -43860,6 +44772,7 @@ export {
   differences,
   digamma,
   directionalDerivative,
+  discreteUniformDist,
   discriminant,
   distance,
   distance2D,
@@ -44009,6 +44922,7 @@ export {
   freqz,
   fresnelC,
   fresnelS,
+  friedmanTest,
   fullSimplify,
   functionExpand,
   fuseUnaryChain,
@@ -44044,6 +44958,7 @@ export {
   griddata,
   groebnerBasis,
   groupDelay,
+  gumbelDist,
   harmonicNumber,
   hartreeEnergy,
   hasNumericValue,
@@ -44056,7 +44971,10 @@ export {
   hex,
   highpassFilter,
   hilbertTransform,
+  histogram,
   hmean,
+  hotellingT2,
+  hypergeometricDist,
   hypot,
   idct,
   identity,
@@ -44077,6 +44995,7 @@ export {
   intersectSegments2D,
   inv,
   invFourier,
+  invGaussDist,
   inverseConductanceQuantum,
   inverseLaplace,
   inverseLaplaceTransform,
@@ -44100,9 +45019,12 @@ export {
   jsDivergence,
   kdTree,
   kdTreeNearest,
+  kendallTau,
+  kendalltau,
   kldivergence,
   klitzing,
   kmeans,
+  kolmogorovSmirnov2Test,
   kolmogorovSmirnovTest,
   kron,
   kruskalWallis,
@@ -44125,6 +45047,7 @@ export {
   legendreFit,
   legendreP,
   levenbergMarquardt,
+  leveneTest,
   lfilter,
   lfilterZi,
   lgamma,
@@ -44132,6 +45055,7 @@ export {
   linearInterp,
   linearRegression,
   linprog,
+  linregress,
   linsolve,
   loess,
   log,
@@ -44159,6 +45083,7 @@ export {
   mad,
   magneticConstant,
   magneticFluxQuantum,
+  mahalanobis,
   manhattanDistance,
   mannWhitneyTest,
   map,
@@ -44179,6 +45104,7 @@ export {
   maxSelect,
   maximize,
   mean,
+  meanCI,
   medfilt,
   median,
   medianSelect,
@@ -44199,10 +45125,13 @@ export {
   movingAverage,
   multiTaperPSD,
   multinomial,
+  multipleComparison,
   multiply,
   multiplyScalar,
+  multivariateNormal,
   multivariateTaylor,
   nearestNeighbor,
+  negativeBinomialDist,
   nelderMead,
   neutronMass,
   newtonInterp,
@@ -44259,6 +45188,7 @@ export {
   parallelStatSum,
   parallelStatVariance,
   parallelXCorr,
+  paretoDist,
   parse,
   parseNumberWithConfig,
   parser,
@@ -44267,7 +45197,9 @@ export {
   partitions,
   pchip,
   pchipInterp,
+  pearsonr,
   periodogram,
+  permutationTest,
   permutations,
   pickRandom,
   piecewise,
@@ -44304,7 +45236,10 @@ export {
   print,
   prod,
   projectVector,
+  proportionCI,
+  proportionZTest,
   protonMass,
+  ptp,
   qr,
   quadprog,
   quantileSeq,
@@ -44323,6 +45258,7 @@ export {
   rank,
   rankdata,
   rationalize,
+  rayleighDist,
   rbfInterpolate,
   re,
   reduce,
@@ -44398,6 +45334,7 @@ export {
   sort,
   sparse,
   spearman,
+  spearmanr,
   spectralClustering,
   spectrogram,
   speedOfLight,
@@ -44416,6 +45353,7 @@ export {
   studentTPDF,
   studentTQuantile,
   studentTTest,
+  studentTTestPaired,
   studentizedRangeCDF,
   studentizedRangeQuantile,
   subfactorial,
@@ -44452,10 +45390,12 @@ export {
   trapz,
   trapzF64,
   triangleArea,
+  triangularDist,
   trigExpand,
   trigReduce,
   trigToExp,
   tril,
+  trimmedMean,
   triu,
   tukeyHSD,
   typeOf2 as typeOf,
@@ -44489,6 +45429,7 @@ export {
   vander,
   variables,
   variance,
+  variation,
   voronoiDiagram,
   weakMixingAngle,
   weibullDist,