deepbox 0.1.0

package/dist/chunk-XMWVME2W.js

@@ -0,0 +1,2377 @@
+import { tensor, Tensor } from './chunk-BCR7G3A6.js';
+import { __export, InvalidParameterError, ShapeError, DTypeError, getElementAsNumber, normalizeAxis, validateShape } from './chunk-4S73VUBD.js';
+
+// src/stats/index.ts
+var stats_exports = {};
+__export(stats_exports, {
+  anderson: () => anderson,
+  bartlett: () => bartlett,
+  chisquare: () => chisquare,
+  corrcoef: () => corrcoef,
+  cov: () => cov,
+  f_oneway: () => f_oneway,
+  friedmanchisquare: () => friedmanchisquare,
+  geometricMean: () => geometricMean,
+  harmonicMean: () => harmonicMean,
+  kendalltau: () => kendalltau,
+  kruskal: () => kruskal,
+  kstest: () => kstest,
+  kurtosis: () => kurtosis,
+  levene: () => levene,
+  mannwhitneyu: () => mannwhitneyu,
+  mean: () => mean,
+  median: () => median,
+  mode: () => mode,
+  moment: () => moment,
+  normaltest: () => normaltest,
+  pearsonr: () => pearsonr,
+  percentile: () => percentile,
+  quantile: () => quantile,
+  shapiro: () => shapiro,
+  skewness: () => skewness,
+  spearmanr: () => spearmanr,
+  std: () => std,
+  trimMean: () => trimMean,
+  ttest_1samp: () => ttest_1samp,
+  ttest_ind: () => ttest_ind,
+  ttest_rel: () => ttest_rel,
+  variance: () => variance,
+  wilcoxon: () => wilcoxon
+});
+
+// src/stats/_internal.ts
+function normalizeAxes(axis, ndim) {
+  if (axis === void 0) return [];
+  const axesInput = Array.isArray(axis) ? [...axis] : [axis];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const ax of axesInput) {
+    const norm = normalizeAxis(ax, ndim);
+    if (!seen.has(norm)) {
+      seen.add(norm);
+      result.push(norm);
+    }
+  }
+  return result.sort((a, b) => a - b);
+}
+function reducedShape(shape, axes, keepdims) {
+  if (axes.length === 0) {
+    return keepdims ? new Array(shape.length).fill(1) : [];
+  }
+  const reduce = new Set(axes);
+  const out = [];
+  for (let i = 0; i < shape.length; i++) {
+    const d = shape[i];
+    if (d === void 0) throw new ShapeError("Internal error: missing shape dimension");
+    if (reduce.has(i)) {
+      if (keepdims) out.push(1);
+    } else {
+      out.push(d);
+    }
+  }
+  validateShape(out);
+  return out;
+}
+function computeStrides(shape) {
+  const strides = new Array(shape.length);
+  let stride = 1;
+  for (let i = shape.length - 1; i >= 0; i--) {
+    strides[i] = stride;
+    stride *= shape[i] ?? 0;
+  }
+  return strides;
+}
+function assertSameSize(a, b, name) {
+  if (a.size !== b.size) {
+    throw new InvalidParameterError(
+      `${name}: tensors must have the same number of elements; got ${a.size} and ${b.size}`,
+      "size",
+      { a: a.size, b: b.size }
+    );
+  }
+}
+function getNumberAt(t, offset) {
+  if (t.dtype === "string" || Array.isArray(t.data)) {
+    throw new DTypeError("operation not supported for string dtype");
+  }
+  return getElementAsNumber(t.data, offset);
+}
+function rankData(values) {
+  const n = values.length;
+  const ranks = new Float64Array(n);
+  if (n === 0) return { ranks, tieSum: 0 };
+  const sorted = Array.from(values, (v, i) => ({ v, i })).sort((a, b) => a.v - b.v);
+  let tieSum = 0;
+  for (let i = 0; i < sorted.length; ) {
+    let j = i + 1;
+    while (j < sorted.length && sorted[j]?.v === sorted[i]?.v) {
+      j++;
+    }
+    const t = j - i;
+    const avgRank = (i + 1 + j) / 2;
+    for (let k = i; k < j; k++) {
+      const idx = sorted[k]?.i;
+      if (idx !== void 0) {
+        ranks[idx] = avgRank;
+      }
+    }
+    if (t > 1) tieSum += t * t * t - t;
+    i = j;
+  }
+  return { ranks, tieSum };
+}
+function forEachIndexOffset(t, fn) {
+  if (t.size === 0) return;
+  if (t.ndim === 0) {
+    fn(t.offset, []);
+    return;
+  }
+  const shape = t.shape;
+  const strides = t.strides;
+  const idx = new Array(t.ndim).fill(0);
+  let offset = t.offset;
+  while (true) {
+    fn(offset, idx);
+    let axis = t.ndim - 1;
+    for (; ; ) {
+      idx[axis] = (idx[axis] ?? 0) + 1;
+      offset += strides[axis] ?? 0;
+      const dim = shape[axis] ?? 0;
+      if ((idx[axis] ?? 0) < dim) break;
+      offset -= (idx[axis] ?? 0) * (strides[axis] ?? 0);
+      idx[axis] = 0;
+      axis--;
+      if (axis < 0) return;
+    }
+  }
+}
+function reduceMean(t, axis, keepdims) {
+  const axes = normalizeAxes(axis, t.ndim);
+  if (axes.length === 0) {
+    if (t.size === 0) {
+      throw new InvalidParameterError("mean() requires at least one element", "size", t.size);
+    }
+    let sum = 0;
+    forEachIndexOffset(t, (off) => {
+      sum += getNumberAt(t, off);
+    });
+    const out = new Float64Array(1);
+    out[0] = sum / t.size;
+    const outShape2 = keepdims ? new Array(t.ndim).fill(1) : [];
+    return Tensor.fromTypedArray({
+      data: out,
+      shape: outShape2,
+      dtype: "float64",
+      device: t.device
+    });
+  }
+  const outShape = reducedShape(t.shape, axes, keepdims);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const sums = new Float64Array(outSize);
+  const reduce = new Set(axes);
+  const reduceCount = axes.reduce((acc, ax) => acc * (t.shape[ax] ?? 0), 1);
+  if (reduceCount === 0) {
+    throw new InvalidParameterError(
+      "mean() reduction over empty axis is undefined",
+      "reduceCount",
+      reduceCount
+    );
+  }
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    if (keepdims) {
+      for (let i = 0; i < t.ndim; i++) {
+        const s = outStrides[i] ?? 0;
+        const v = reduce.has(i) ? 0 : idx[i] ?? 0;
+        outFlat += v * s;
+      }
+    } else {
+      let oi = 0;
+      for (let i = 0; i < t.ndim; i++) {
+        if (reduce.has(i)) continue;
+        outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+        oi++;
+      }
+    }
+    sums[outFlat] = (sums[outFlat] ?? 0) + getNumberAt(t, off);
+  });
+  for (let i = 0; i < sums.length; i++) {
+    sums[i] = (sums[i] ?? 0) / reduceCount;
+  }
+  return Tensor.fromTypedArray({
+    data: sums,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function reduceVariance(t, axis, keepdims, ddof) {
+  const axes = normalizeAxes(axis, t.ndim);
+  if (t.dtype === "string") {
+    throw new DTypeError("variance() not supported for string dtype");
+  }
+  if (axes.length === 0) {
+    if (t.size === 0) {
+      throw new InvalidParameterError("variance() requires at least one element", "size", t.size);
+    }
+    if (ddof < 0) {
+      throw new InvalidParameterError("ddof must be non-negative", "ddof", ddof);
+    }
+    if (t.size <= ddof) {
+      throw new InvalidParameterError(
+        `ddof=${ddof} >= size=${t.size}, variance undefined`,
+        "ddof",
+        ddof
+      );
+    }
+    let mean2 = 0;
+    let m2 = 0;
+    let n = 0;
+    forEachIndexOffset(t, (off) => {
+      const x = getNumberAt(t, off);
+      n++;
+      const delta = x - mean2;
+      mean2 += delta / n;
+      const delta2 = x - mean2;
+      m2 += delta * delta2;
+    });
+    const out2 = new Float64Array(1);
+    out2[0] = m2 / (n - ddof);
+    const outShape2 = keepdims ? new Array(t.ndim).fill(1) : [];
+    return Tensor.fromTypedArray({
+      data: out2,
+      shape: outShape2,
+      dtype: "float64",
+      device: t.device
+    });
+  }
+  const outShape = reducedShape(t.shape, axes, keepdims);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const reduce = new Set(axes);
+  const reduceCount = axes.reduce((acc, ax) => acc * (t.shape[ax] ?? 0), 1);
+  if (reduceCount === 0) {
+    throw new InvalidParameterError(
+      "variance() reduction over empty axis is undefined",
+      "reduceCount",
+      reduceCount
+    );
+  }
+  if (ddof < 0) {
+    throw new InvalidParameterError("ddof must be non-negative", "ddof", ddof);
+  }
+  if (reduceCount <= ddof) {
+    throw new InvalidParameterError(
+      `ddof=${ddof} >= reduced size=${reduceCount}, variance undefined`,
+      "ddof",
+      ddof
+    );
+  }
+  const means = new Float64Array(outSize);
+  const m2s = new Float64Array(outSize);
+  const counts = new Int32Array(outSize);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    if (keepdims) {
+      for (let i = 0; i < t.ndim; i++) {
+        const s = outStrides[i] ?? 0;
+        const v = reduce.has(i) ? 0 : idx[i] ?? 0;
+        outFlat += v * s;
+      }
+    } else {
+      let oi = 0;
+      for (let i = 0; i < t.ndim; i++) {
+        if (reduce.has(i)) continue;
+        outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+        oi++;
+      }
+    }
+    const x = getNumberAt(t, off);
+    const n = (counts[outFlat] ?? 0) + 1;
+    counts[outFlat] = n;
+    const mean2 = means[outFlat] ?? 0;
+    const delta = x - mean2;
+    const nextMean = mean2 + delta / n;
+    means[outFlat] = nextMean;
+    const delta2 = x - nextMean;
+    m2s[outFlat] = (m2s[outFlat] ?? 0) + delta * delta2;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    const n = counts[i] ?? 0;
+    out[i] = (m2s[i] ?? 0) / (n - ddof);
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+var LANCZOS_COEFFS = [
+  0.9999999999998099,
+  676.5203681218851,
+  -1259.1392167224028,
+  771.3234287776531,
+  -176.6150291621406,
+  12.507343278686905,
+  -0.13857109526572012,
+  9984369578019572e-21,
+  15056327351493116e-23
+];
+function logGamma(z) {
+  if (z < 0.5) {
+    return Math.log(Math.PI) - Math.log(Math.sin(Math.PI * z)) - logGamma(1 - z);
+  }
+  z -= 1;
+  let x = LANCZOS_COEFFS[0];
+  for (let i = 1; i < LANCZOS_COEFFS.length; i++) {
+    x += (LANCZOS_COEFFS[i] ?? 0) / (z + i);
+  }
+  const t = z + 7.5;
+  return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
+}
+function betacf(a, b, x) {
+  const MAX_ITER = 200;
+  const EPS = 3e-14;
+  const FPMIN = 1e-300;
+  const qab = a + b;
+  const qap = a + 1;
+  const qam = a - 1;
+  let c = 1;
+  let d = 1 - qab * x / qap;
+  if (Math.abs(d) < FPMIN) d = FPMIN;
+  d = 1 / d;
+  let h = d;
+  for (let m = 1; m <= MAX_ITER; m++) {
+    const m2 = 2 * m;
+    let aa = m * (b - m) * x / ((qam + m2) * (a + m2));
+    d = 1 + aa * d;
+    if (Math.abs(d) < FPMIN) d = FPMIN;
+    c = 1 + aa / c;
+    if (Math.abs(c) < FPMIN) c = FPMIN;
+    d = 1 / d;
+    h *= d * c;
+    aa = -(a + m) * (qab + m) * x / ((a + m2) * (qap + m2));
+    d = 1 + aa * d;
+    if (Math.abs(d) < FPMIN) d = FPMIN;
+    c = 1 + aa / c;
+    if (Math.abs(c) < FPMIN) c = FPMIN;
+    d = 1 / d;
+    const del = d * c;
+    h *= del;
+    if (Math.abs(del - 1) < EPS) break;
+  }
+  return h;
+}
+function regularizedIncompleteBeta(a, b, x) {
+  if (!Number.isFinite(a) || a <= 0) {
+    throw new InvalidParameterError("a must be > 0", "a", a);
+  }
+  if (!Number.isFinite(b) || b <= 0) {
+    throw new InvalidParameterError("b must be > 0", "b", b);
+  }
+  if (x < 0 || x > 1) {
+    throw new InvalidParameterError("x must be in [0,1]", "x", x);
+  }
+  if (x === 0) return 0;
+  if (x === 1) return 1;
+  const lnBt = logGamma(a + b) - logGamma(a) - logGamma(b) + a * Math.log(x) + b * Math.log(1 - x);
+  const bt = Math.exp(lnBt);
+  if (x < (a + 1) / (a + b + 2)) {
+    return bt * betacf(a, b, x) / a;
+  }
+  return 1 - bt * betacf(b, a, 1 - x) / b;
+}
+function regularizedLowerIncompleteGamma(s, x) {
+  if (!Number.isFinite(s) || s <= 0) {
+    throw new InvalidParameterError("s must be > 0", "s", s);
+  }
+  if (x < 0) throw new InvalidParameterError("x must be >= 0", "x", x);
+  if (x === 0) return 0;
+  const ITMAX = 200;
+  const EPS = 3e-14;
+  const FPMIN = 1e-300;
+  if (x < s + 1) {
+    let sum = 1 / s;
+    let del = sum;
+    let ap = s;
+    for (let n = 1; n <= ITMAX; n++) {
+      ap += 1;
+      del *= x / ap;
+      sum += del;
+      if (Math.abs(del) < Math.abs(sum) * EPS) break;
+    }
+    return sum * Math.exp(-x + s * Math.log(x) - logGamma(s));
+  }
+  let b = x + 1 - s;
+  let c = 1 / FPMIN;
+  let d = 1 / b;
+  let h = d;
+  for (let i = 1; i <= ITMAX; i++) {
+    const an = -i * (i - s);
+    b += 2;
+    d = an * d + b;
+    if (Math.abs(d) < FPMIN) d = FPMIN;
+    c = b + an / c;
+    if (Math.abs(c) < FPMIN) c = FPMIN;
+    d = 1 / d;
+    const del = d * c;
+    h *= del;
+    if (Math.abs(del - 1) < EPS) break;
+  }
+  const q = Math.exp(-x + s * Math.log(x) - logGamma(s)) * h;
+  return 1 - q;
+}
+function normalCdf(x) {
+  const a = 0.147;
+  const sign = x < 0 ? -1 : 1;
+  const ax = Math.abs(x) / Math.SQRT2;
+  const t = 1 + a * ax * ax;
+  const erf = sign * Math.sqrt(1 - Math.exp(-ax * ax * ((4 / Math.PI + a * ax * ax) / t)));
+  return 0.5 * (1 + erf);
+}
+function studentTCdf(t, df) {
+  if (!Number.isFinite(df) || df <= 0) {
+    throw new InvalidParameterError("df must be > 0", "df", df);
+  }
+  if (Number.isNaN(t)) return NaN;
+  if (!Number.isFinite(t)) return t < 0 ? 0 : 1;
+  const x = df / (df + t * t);
+  const a = df / 2;
+  const b = 0.5;
+  const ib = regularizedIncompleteBeta(a, b, x);
+  const p = 0.5 * ib;
+  return t >= 0 ? 1 - p : p;
+}
+function chiSquareCdf(x, k) {
+  if (!Number.isFinite(k) || k <= 0) {
+    throw new InvalidParameterError("degrees of freedom must be > 0", "k", k);
+  }
+  if (Number.isNaN(x)) return NaN;
+  if (x === Infinity) return 1;
+  if (x <= 0) return 0;
+  return regularizedLowerIncompleteGamma(k / 2, x / 2);
+}
+function fCdf(x, dfn, dfd) {
+  if (!Number.isFinite(dfn) || dfn <= 0) {
+    throw new InvalidParameterError("degrees of freedom (dfn) must be > 0", "dfn", dfn);
+  }
+  if (!Number.isFinite(dfd) || dfd <= 0) {
+    throw new InvalidParameterError("degrees of freedom (dfd) must be > 0", "dfd", dfd);
+  }
+  if (Number.isNaN(x)) return NaN;
+  if (x === Infinity) return 1;
+  if (x <= 0) return 0;
+  const xx = dfn * x / (dfn * x + dfd);
+  return regularizedIncompleteBeta(dfn / 2, dfd / 2, xx);
+}
+
+// src/stats/correlation.ts
+function toDenseFlatArray(t) {
+  const out = new Float64Array(t.size);
+  let i = 0;
+  forEachIndexOffset(t, (off) => {
+    out[i] = getNumberAt(t, off);
+    i++;
+  });
+  return out;
+}
+function pearsonFromDense(x, y) {
+  const n = x.length;
+  let sumX = 0;
+  let sumY = 0;
+  for (let i = 0; i < n; i++) {
+    sumX += x[i] ?? 0;
+    sumY += y[i] ?? 0;
+  }
+  const meanX = sumX / n;
+  const meanY = sumY / n;
+  let num = 0;
+  let denX = 0;
+  let denY = 0;
+  for (let i = 0; i < n; i++) {
+    const dx = (x[i] ?? 0) - meanX;
+    const dy = (y[i] ?? 0) - meanY;
+    num += dx * dy;
+    denX += dx * dx;
+    denY += dy * dy;
+  }
+  const den = Math.sqrt(denX * denY);
+  if (den === 0) {
+    throw new InvalidParameterError(
+      "pearsonr() is undefined for constant input",
+      "input",
+      "constant"
+    );
+  }
+  return num / den;
+}
+function pearsonr(x, y) {
+  assertSameSize(x, y, "pearsonr");
+  const n = x.size;
+  if (n < 2) {
+    throw new InvalidParameterError("pearsonr() requires at least 2 paired samples", "n", n);
+  }
+  const xd = toDenseFlatArray(x);
+  const yd = toDenseFlatArray(y);
+  const r = pearsonFromDense(xd, yd);
+  const df = n - 2;
+  if (df <= 0) {
+    return [r, NaN];
+  }
+  const tStat = r * Math.sqrt(df / (1 - r * r));
+  const pValue = 2 * (1 - studentTCdf(Math.abs(tStat), df));
+  return [r, pValue];
+}
+function spearmanr(x, y) {
+  assertSameSize(x, y, "spearmanr");
+  const n = x.size;
+  if (n < 2) {
+    throw new InvalidParameterError("spearmanr() requires at least 2 paired samples", "n", n);
+  }
+  const xd = toDenseFlatArray(x);
+  const yd = toDenseFlatArray(y);
+  const rankX = rankData(xd).ranks;
+  const rankY = rankData(yd).ranks;
+  const rho = pearsonFromDense(rankX, rankY);
+  const df = n - 2;
+  const tStat = rho * Math.sqrt(df / (1 - rho * rho));
+  const pValue = df > 0 ? 2 * (1 - studentTCdf(Math.abs(tStat), df)) : NaN;
+  return [rho, pValue];
+}
+function kendalltau(x, y) {
+  assertSameSize(x, y, "kendalltau");
+  const n = x.size;
+  if (n < 2) {
+    throw new InvalidParameterError("kendalltau() requires at least 2 paired samples", "n", n);
+  }
+  const xd = toDenseFlatArray(x);
+  const yd = toDenseFlatArray(y);
+  let concordant = 0;
+  let discordant = 0;
+  for (let i = 0; i < n - 1; i++) {
+    const xi = xd[i] ?? 0;
+    const yi = yd[i] ?? 0;
+    for (let j = i + 1; j < n; j++) {
+      const signX = Math.sign((xd[j] ?? 0) - xi);
+      const signY = Math.sign((yd[j] ?? 0) - yi);
+      if (signX === 0 || signY === 0) continue;
+      if (signX === signY) concordant++;
+      else discordant++;
+    }
+  }
+  const n0 = n * (n - 1) / 2;
+  const tieSums = (vals) => {
+    const sorted = Array.from(vals).sort((a, b) => a - b);
+    let sumT = 0;
+    let sumT2 = 0;
+    let sumT3 = 0;
+    for (let i = 0; i < sorted.length; ) {
+      let j = i + 1;
+      while (j < sorted.length && sorted[j] === sorted[i]) j++;
+      const t = j - i;
+      if (t > 1) {
+        sumT += t * (t - 1);
+        sumT2 += t * (t - 1) * (2 * t + 5);
+        sumT3 += t * (t - 1) * (t - 2);
+      }
+      i = j;
+    }
+    return { nTies: sumT / 2, sumT, sumT2, sumT3 };
+  };
+  const tieX = tieSums(xd);
+  const tieY = tieSums(yd);
+  const denom = Math.sqrt((n0 - tieX.nTies) * (n0 - tieY.nTies));
+  const s = concordant - discordant;
+  const tau = denom === 0 ? NaN : s / denom;
+  let varS = (n * (n - 1) * (2 * n + 5) - tieX.sumT2 - tieY.sumT2) / 18 + tieX.sumT * tieY.sumT / (2 * n * (n - 1));
+  if (n > 2) {
+    varS += tieX.sumT3 * tieY.sumT3 / (9 * n * (n - 1) * (n - 2));
+  }
+  const pValue = varS <= 0 ? NaN : 2 * (1 - normalCdf(Math.abs(s / Math.sqrt(varS))));
+  return [tau, pValue];
+}
+function corrcoef(x, y) {
+  if (y) {
+    const [r] = pearsonr(x, y);
+    return tensor([
+      [1, r],
+      [r, 1]
+    ]);
+  }
+  if (x.ndim === 1) {
+    if (x.size < 2) {
+      throw new InvalidParameterError(
+        "corrcoef() requires at least 2 observations",
+        "nObs",
+        x.size
+      );
+    }
+    return tensor([[1]]);
+  }
+  if (x.ndim !== 2) {
+    throw new ShapeError("corrcoef() expects a 1D or 2D tensor");
+  }
+  const nObs = x.shape[0] ?? 0;
+  const nVar = x.shape[1] ?? 0;
+  if (nObs < 2) {
+    throw new InvalidParameterError("corrcoef() requires at least 2 observations", "nObs", nObs);
+  }
+  const s0 = x.strides[0] ?? 0;
+  const s1 = x.strides[1] ?? 0;
+  const xOff = x.offset;
+  const xData = x.data;
+  const directAccess = !Array.isArray(xData) && !(xData instanceof BigInt64Array);
+  const means = new Float64Array(nVar);
+  if (directAccess) {
+    for (let j = 0; j < nVar; j++) {
+      let s = 0;
+      for (let i = 0; i < nObs; i++) {
+        s += xData[xOff + i * s0 + j * s1];
+      }
+      means[j] = s / nObs;
+    }
+  } else {
+    for (let j = 0; j < nVar; j++) {
+      let s = 0;
+      for (let i = 0; i < nObs; i++) {
+        s += getNumberAt(x, xOff + i * s0 + j * s1);
+      }
+      means[j] = s / nObs;
+    }
+  }
+  const cov2 = new Float64Array(nVar * nVar);
+  const ddof = 1;
+  if (directAccess) {
+    for (let a = 0; a < nVar; a++) {
+      const ma = means[a];
+      for (let b = a; b < nVar; b++) {
+        const mb = means[b];
+        let s = 0;
+        for (let i = 0; i < nObs; i++) {
+          const base = xOff + i * s0;
+          s += (xData[base + a * s1] - ma) * (xData[base + b * s1] - mb);
+        }
+        const v = s / (nObs - ddof);
+        cov2[a * nVar + b] = v;
+        cov2[b * nVar + a] = v;
+      }
+    }
+  } else {
+    for (let a = 0; a < nVar; a++) {
+      for (let b = a; b < nVar; b++) {
+        let s = 0;
+        for (let i = 0; i < nObs; i++) {
+          const offA = xOff + i * s0 + a * s1;
+          const offB = xOff + i * s0 + b * s1;
+          s += (getNumberAt(x, offA) - (means[a] ?? 0)) * (getNumberAt(x, offB) - (means[b] ?? 0));
+        }
+        const v = s / (nObs - ddof);
+        cov2[a * nVar + b] = v;
+        cov2[b * nVar + a] = v;
+      }
+    }
+  }
+  const corr = new Float64Array(nVar * nVar);
+  for (let i = 0; i < nVar; i++) {
+    for (let j = 0; j < nVar; j++) {
+      const v = cov2[i * nVar + j] ?? 0;
+      const vi = cov2[i * nVar + i] ?? 0;
+      const vj = cov2[j * nVar + j] ?? 0;
+      const den = Math.sqrt(vi * vj);
+      corr[i * nVar + j] = den === 0 ? NaN : v / den;
+    }
+  }
+  return Tensor.fromTypedArray({
+    data: corr,
+    shape: [nVar, nVar],
+    dtype: "float64",
+    device: x.device
+  });
+}
+function cov(x, y, ddof = 1) {
+  if (!Number.isFinite(ddof) || ddof < 0) {
+    throw new InvalidParameterError("ddof must be a non-negative finite number", "ddof", ddof);
+  }
+  if (y) {
+    assertSameSize(x, y, "cov");
+    const n = x.size;
+    if (n === 0) throw new InvalidParameterError("cov() requires at least one element", "n", n);
+    if (n <= ddof)
+      throw new InvalidParameterError(
+        `ddof=${ddof} >= size=${n}, covariance undefined`,
+        "ddof",
+        ddof
+      );
+    const xd = toDenseFlatArray(x);
+    const yd = toDenseFlatArray(y);
+    let meanX = 0;
+    let meanY = 0;
+    for (let i = 0; i < n; i++) {
+      meanX += xd[i] ?? 0;
+      meanY += yd[i] ?? 0;
+    }
+    meanX /= n;
+    meanY /= n;
+    let varX = 0;
+    let varY = 0;
+    let covXY = 0;
+    for (let i = 0; i < n; i++) {
+      const dx = (xd[i] ?? 0) - meanX;
+      const dy = (yd[i] ?? 0) - meanY;
+      varX += dx * dx;
+      varY += dy * dy;
+      covXY += dx * dy;
+    }
+    varX /= n - ddof;
+    varY /= n - ddof;
+    covXY /= n - ddof;
+    return tensor([
+      [varX, covXY],
+      [covXY, varY]
+    ]);
+  }
+  if (x.ndim === 1) {
+    const n = x.size;
+    if (n === 0) throw new InvalidParameterError("cov() requires at least one element", "n", n);
+    if (ddof < 0) {
+      throw new InvalidParameterError("ddof must be non-negative", "ddof", ddof);
+    }
+    if (n <= ddof)
+      throw new InvalidParameterError(
+        `ddof=${ddof} >= size=${n}, covariance undefined`,
+        "ddof",
+        ddof
+      );
+    const xd = toDenseFlatArray(x);
+    let meanX = 0;
+    for (let i = 0; i < n; i++) meanX += xd[i] ?? 0;
+    meanX /= n;
+    let varX = 0;
+    for (let i = 0; i < n; i++) {
+      const dx = (xd[i] ?? 0) - meanX;
+      varX += dx * dx;
+    }
+    varX /= n - ddof;
+    return tensor([[varX]]);
+  }
+  if (x.ndim !== 2) {
+    throw new ShapeError("cov() expects a 1D or 2D tensor");
+  }
+  const nObs = x.shape[0] ?? 0;
+  const nVar = x.shape[1] ?? 0;
+  if (nObs === 0)
+    throw new InvalidParameterError("cov() requires at least one observation", "nObs", nObs);
+  if (ddof < 0) {
+    throw new InvalidParameterError("ddof must be non-negative", "ddof", ddof);
+  }
+  if (nObs <= ddof)
+    throw new InvalidParameterError(
+      `ddof=${ddof} >= nObs=${nObs}, covariance undefined`,
+      "ddof",
+      ddof
+    );
+  const means = new Float64Array(nVar);
+  for (let j = 0; j < nVar; j++) {
+    let s = 0;
+    for (let i = 0; i < nObs; i++) {
+      const off = x.offset + i * (x.strides[0] ?? 0) + j * (x.strides[1] ?? 0);
+      s += getNumberAt(x, off);
+    }
+    means[j] = s / nObs;
+  }
+  const out = new Float64Array(nVar * nVar);
+  for (let a = 0; a < nVar; a++) {
+    for (let b = a; b < nVar; b++) {
+      let s = 0;
+      for (let i = 0; i < nObs; i++) {
+        const offA = x.offset + i * (x.strides[0] ?? 0) + a * (x.strides[1] ?? 0);
+        const offB = x.offset + i * (x.strides[0] ?? 0) + b * (x.strides[1] ?? 0);
+        s += (getNumberAt(x, offA) - (means[a] ?? 0)) * (getNumberAt(x, offB) - (means[b] ?? 0));
+      }
+      const v = s / (nObs - ddof);
+      out[a * nVar + b] = v;
+      out[b * nVar + a] = v;
+    }
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: [nVar, nVar],
+    dtype: "float64",
+    device: x.device
+  });
+}
+
+// src/stats/descriptive.ts
+function mean(t, axis, _keepdims = false) {
+  return reduceMean(t, axis, _keepdims);
+}
+function median(t, axis, _keepdims = false) {
+  const axes = normalizeAxes(axis, t.ndim);
+  if (axes.length === 0) {
+    if (t.size === 0) {
+      throw new InvalidParameterError("median() requires at least one element", "size", t.size);
+    }
+    const values = [];
+    let hasNaN = false;
+    forEachIndexOffset(t, (off) => {
+      const v = getNumberAt(t, off);
+      if (Number.isNaN(v)) hasNaN = true;
+      values.push(v);
+    });
+    const outShape2 = _keepdims ? new Array(t.ndim).fill(1) : [];
+    if (hasNaN) {
+      const out3 = new Float64Array(1);
+      out3[0] = Number.NaN;
+      return Tensor.fromTypedArray({
+        data: out3,
+        shape: outShape2,
+        dtype: "float64",
+        device: t.device
+      });
+    }
+    values.sort((a, b) => a - b);
+    const mid = Math.floor(values.length / 2);
+    const result = values.length % 2 === 0 ? ((values[mid - 1] ?? 0) + (values[mid] ?? 0)) / 2 : values[mid] ?? 0;
+    const out2 = new Float64Array(1);
+    out2[0] = result;
+    return Tensor.fromTypedArray({
+      data: out2,
+      shape: outShape2,
+      dtype: "float64",
+      device: t.device
+    });
+  }
+  const outShape = reducedShape(t.shape, axes, _keepdims);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const buckets = new Array(outSize);
+  const nanFlags = new Array(outSize).fill(false);
+  const reduce = new Set(axes);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    if (_keepdims) {
+      for (let i = 0; i < t.ndim; i++) {
+        const s = outStrides[i] ?? 0;
+        const v = reduce.has(i) ? 0 : idx[i] ?? 0;
+        outFlat += v * s;
+      }
+    } else {
+      let oi = 0;
+      for (let i = 0; i < t.ndim; i++) {
+        if (reduce.has(i)) continue;
+        outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+        oi++;
+      }
+    }
+    const val = getNumberAt(t, off);
+    if (Number.isNaN(val)) {
+      nanFlags[outFlat] = true;
+      return;
+    }
+    const arr = buckets[outFlat] ?? [];
+    arr.push(val);
+    buckets[outFlat] = arr;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    if (nanFlags[i]) {
+      out[i] = Number.NaN;
+      continue;
+    }
+    const arr = buckets[i] ?? [];
+    if (arr.length === 0) {
+      throw new InvalidParameterError(
+        "median() reduction over empty axis is undefined",
+        "axis",
+        arr.length
+      );
+    }
+    arr.sort((a, b) => a - b);
+    const mid = Math.floor(arr.length / 2);
+    out[i] = arr.length % 2 === 0 ? ((arr[mid - 1] ?? 0) + (arr[mid] ?? 0)) / 2 : arr[mid] ?? 0;
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function mode(t, axis) {
+  const axes = normalizeAxes(axis, t.ndim);
+  if (axes.length === 0) {
+    if (t.size === 0) {
+      throw new InvalidParameterError("mode() requires at least one element", "size", t.size);
+    }
+    const freq = /* @__PURE__ */ new Map();
+    let maxFreq = 0;
+    let modeVal = Number.POSITIVE_INFINITY;
+    let hasNaN = false;
+    forEachIndexOffset(t, (off) => {
+      const val = getNumberAt(t, off);
+      if (Number.isNaN(val)) {
+        hasNaN = true;
+        return;
+      }
+      const count = (freq.get(val) ?? 0) + 1;
+      freq.set(val, count);
+      if (count > maxFreq || count === maxFreq && val < modeVal) {
+        maxFreq = count;
+        modeVal = val;
+      }
+    });
+    if (hasNaN) {
+      return tensor([Number.NaN]);
+    }
+    return tensor([modeVal]);
+  }
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const maps = new Array(outSize);
+  const bestCounts = new Int32Array(outSize);
+  const bestValues = new Float64Array(outSize);
+  const nanFlags = new Array(outSize).fill(false);
+  const reduce = new Set(axes);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const val = getNumberAt(t, off);
+    if (Number.isNaN(val)) {
+      nanFlags[outFlat] = true;
+      return;
+    }
+    const m = maps[outFlat] ?? /* @__PURE__ */ new Map();
+    const next = (m.get(val) ?? 0) + 1;
+    m.set(val, next);
+    maps[outFlat] = m;
+    const currentBestCount = bestCounts[outFlat] ?? 0;
+    const currentBestValue = bestValues[outFlat] ?? Number.POSITIVE_INFINITY;
+    if (next > currentBestCount || next === currentBestCount && val < currentBestValue) {
+      bestCounts[outFlat] = next;
+      bestValues[outFlat] = val;
+    }
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    if (nanFlags[i]) {
+      out[i] = Number.NaN;
+      continue;
+    }
+    if ((bestCounts[i] ?? 0) === 0) {
+      throw new InvalidParameterError(
+        "mode() reduction over empty axis is undefined",
+        "axis",
+        bestCounts[i] ?? 0
+      );
+    }
+    out[i] = bestValues[i] ?? Number.NaN;
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function std(t, axis, _keepdims = false, ddof = 0) {
+  const v = reduceVariance(t, axis, _keepdims, ddof);
+  const out = new Float64Array(v.size);
+  for (let i = 0; i < v.size; i++) {
+    out[i] = Math.sqrt(getNumberAt(v, v.offset + i));
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: v.shape,
+    dtype: "float64",
+    device: v.device
+  });
+}
+function variance(t, axis, _keepdims = false, ddof = 0) {
+  return reduceVariance(t, axis, _keepdims, ddof);
+}
+function skewness(t, axis, bias = true) {
+  const mu = reduceMean(t, axis, false);
+  const sigma2 = reduceVariance(t, axis, false, 0);
+  const axes = normalizeAxes(axis, t.ndim);
+  const reduce = new Set(axes);
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const sumCube = new Float64Array(outSize);
+  const counts = new Int32Array(outSize);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const m = getNumberAt(mu, mu.offset + outFlat);
+    const v = Math.sqrt(getNumberAt(sigma2, sigma2.offset + outFlat));
+    const x = getNumberAt(t, off);
+    if (!Number.isFinite(v) || v === 0) {
+      sumCube[outFlat] = NaN;
+    } else {
+      const z = (x - m) / v;
+      sumCube[outFlat] = (sumCube[outFlat] ?? 0) + z * z * z;
+    }
+    counts[outFlat] = (counts[outFlat] ?? 0) + 1;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    const n = counts[i] ?? 0;
+    if (n === 0) {
+      out[i] = NaN;
+      continue;
+    }
+    let g1 = (sumCube[i] ?? NaN) / n;
+    if (!bias) {
+      if (n < 3) {
+        g1 = NaN;
+      } else {
+        g1 *= Math.sqrt(n * (n - 1)) / (n - 2);
+      }
+    }
+    out[i] = g1;
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function kurtosis(t, axis, fisher = true, bias = true) {
+  const mu = reduceMean(t, axis, false);
+  const sigma2 = reduceVariance(t, axis, false, 0);
+  const axes = normalizeAxes(axis, t.ndim);
+  const reduce = new Set(axes);
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const sumQuad = new Float64Array(outSize);
+  const counts = new Int32Array(outSize);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const m = getNumberAt(mu, mu.offset + outFlat);
+    const v = Math.sqrt(getNumberAt(sigma2, sigma2.offset + outFlat));
+    const x = getNumberAt(t, off);
+    if (!Number.isFinite(v) || v === 0) {
+      sumQuad[outFlat] = NaN;
+    } else {
+      const z = (x - m) / v;
+      sumQuad[outFlat] = (sumQuad[outFlat] ?? 0) + z ** 4;
+    }
+    counts[outFlat] = (counts[outFlat] ?? 0) + 1;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    const n = counts[i] ?? 0;
+    if (n === 0) {
+      out[i] = NaN;
+      continue;
+    }
+    let g2 = (sumQuad[i] ?? NaN) / n;
+    if (!bias) {
+      if (n < 4) {
+        g2 = NaN;
+      } else {
+        const excess = g2 - 3;
+        const adj = ((n + 1) * excess + 6) * ((n - 1) / ((n - 2) * (n - 3)));
+        g2 = adj + 3;
+      }
+    }
+    out[i] = fisher ? g2 - 3 : g2;
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function quantile(t, q, axis) {
+  const qVals = Array.isArray(q) ? q : [q];
+  for (const v of qVals) {
+    if (!Number.isFinite(v) || v < 0 || v > 1) {
+      throw new InvalidParameterError("q must be in [0, 1]", "q", v);
+    }
+  }
+  const axes = normalizeAxes(axis, t.ndim);
+  const reduce = new Set(axes);
+  if (axes.length === 0) {
+    if (t.size === 0) {
+      throw new InvalidParameterError("quantile() requires at least one element", "size", t.size);
+    }
+    const arr = [];
+    let hasNaN = false;
+    forEachIndexOffset(t, (off) => {
+      const v = getNumberAt(t, off);
+      if (Number.isNaN(v)) hasNaN = true;
+      arr.push(v);
+    });
+    if (hasNaN) {
+      return tensor(qVals.map(() => Number.NaN));
+    }
+    arr.sort((a, b) => a - b);
+    const results = [];
+    for (const qVal of qVals) {
+      const idx = qVal * (arr.length - 1);
+      const lower = Math.floor(idx);
+      const upper = Math.ceil(idx);
+      const weight = idx - lower;
+      results.push((arr[lower] ?? 0) * (1 - weight) + (arr[upper] ?? 0) * weight);
+    }
+    return tensor(results);
+  }
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const buckets = new Array(outSize);
+  const nanFlags = new Array(outSize).fill(false);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const val = getNumberAt(t, off);
+    if (Number.isNaN(val)) {
+      nanFlags[outFlat] = true;
+      return;
+    }
+    const arr = buckets[outFlat] ?? [];
+    arr.push(val);
+    buckets[outFlat] = arr;
+  });
+  const finalShape = [qVals.length, ...outShape];
+  const finalSize = qVals.length * outSize;
+  const out = new Float64Array(finalSize);
+  for (let g = 0; g < outSize; g++) {
+    if (nanFlags[g]) {
+      for (let qi = 0; qi < qVals.length; qi++) {
+        out[qi * outSize + g] = Number.NaN;
+      }
+      continue;
+    }
+    const arr = buckets[g] ?? [];
+    if (arr.length === 0) {
+      throw new InvalidParameterError(
+        "quantile() reduction over empty axis is undefined",
+        "axis",
+        arr.length
+      );
+    }
+    arr.sort((a, b) => a - b);
+    for (let qi = 0; qi < qVals.length; qi++) {
+      const qVal = qVals[qi] ?? 0;
+      const idx = qVal * (arr.length - 1);
+      const lower = Math.floor(idx);
+      const upper = Math.ceil(idx);
+      const weight = idx - lower;
+      out[qi * outSize + g] = (arr[lower] ?? 0) * (1 - weight) + (arr[upper] ?? 0) * weight;
+    }
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: finalShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function percentile(t, q, axis) {
+  const qArr = Array.isArray(q) ? q : [q];
+  for (const v of qArr) {
+    if (!Number.isFinite(v) || v < 0 || v > 100) {
+      throw new InvalidParameterError("q must be in [0, 100]", "q", v);
+    }
+  }
+  const qVals = Array.isArray(q) ? q.map((v) => v / 100) : q / 100;
+  return quantile(t, qVals, axis);
+}
+function moment(t, n, axis) {
+  if (!Number.isFinite(n) || !Number.isInteger(n) || n < 0) {
+    throw new InvalidParameterError("n must be a non-negative integer", "n", n);
+  }
+  const mu = reduceMean(t, axis, false);
+  const axes = normalizeAxes(axis, t.ndim);
+  const reduce = new Set(axes);
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const sums = new Float64Array(outSize);
+  const counts = new Int32Array(outSize);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const m = getNumberAt(mu, mu.offset + outFlat);
+    const x = getNumberAt(t, off);
+    sums[outFlat] = (sums[outFlat] ?? 0) + (x - m) ** n;
+    counts[outFlat] = (counts[outFlat] ?? 0) + 1;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    const c = counts[i] ?? 0;
+    out[i] = c === 0 ? NaN : (sums[i] ?? 0) / c;
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function geometricMean(t, axis) {
+  const axes = normalizeAxes(axis, t.ndim);
+  if (axes.length === 0 && t.size === 0) {
+    throw new InvalidParameterError(
+      "geometricMean() requires at least one element",
+      "size",
+      t.size
+    );
+  }
+  const reduce = new Set(axes);
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const sums = new Float64Array(outSize);
+  const counts = new Int32Array(outSize);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const x = getNumberAt(t, off);
+    if (x <= 0)
+      throw new InvalidParameterError("geometricMean() requires all values to be > 0", "value", x);
+    sums[outFlat] = (sums[outFlat] ?? 0) + Math.log(x);
+    counts[outFlat] = (counts[outFlat] ?? 0) + 1;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    const c = counts[i] ?? 0;
+    if (c === 0) {
+      throw new InvalidParameterError(
+        "geometricMean() reduction over empty axis is undefined",
+        "axis",
+        c
+      );
+    }
+    out[i] = Math.exp((sums[i] ?? 0) / c);
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function harmonicMean(t, axis) {
+  const axes = normalizeAxes(axis, t.ndim);
+  if (axes.length === 0 && t.size === 0) {
+    throw new InvalidParameterError("harmonicMean() requires at least one element", "size", t.size);
+  }
+  const reduce = new Set(axes);
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const sums = new Float64Array(outSize);
+  const counts = new Int32Array(outSize);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const x = getNumberAt(t, off);
+    if (x <= 0) {
+      throw new InvalidParameterError("harmonicMean() requires all values to be > 0", "value", x);
+    }
+    sums[outFlat] = (sums[outFlat] ?? 0) + 1 / x;
+    counts[outFlat] = (counts[outFlat] ?? 0) + 1;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    const c = counts[i] ?? 0;
+    if (c === 0) {
+      throw new InvalidParameterError(
+        "harmonicMean() reduction over empty axis is undefined",
+        "axis",
+        c
+      );
+    }
+    out[i] = c / (sums[i] ?? NaN);
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+function trimMean(t, proportiontocut, axis) {
+  if (!Number.isFinite(proportiontocut) || proportiontocut < 0 || proportiontocut >= 0.5) {
+    throw new InvalidParameterError(
+      "proportiontocut must be a finite number in range [0, 0.5)",
+      "proportiontocut",
+      proportiontocut
+    );
+  }
+  const axes = normalizeAxes(axis, t.ndim);
+  const reduce = new Set(axes);
+  if (axes.length === 0) {
+    const arr = [];
+    let hasNaN = false;
+    forEachIndexOffset(t, (off) => {
+      const v = getNumberAt(t, off);
+      if (Number.isNaN(v)) hasNaN = true;
+      arr.push(v);
+    });
+    if (arr.length === 0)
+      throw new InvalidParameterError(
+        "trimMean() requires at least one element",
+        "size",
+        arr.length
+      );
+    if (hasNaN) {
+      return tensor([Number.NaN]);
+    }
+    arr.sort((a, b) => a - b);
+    const nTrim = Math.floor(arr.length * proportiontocut);
+    const trimmed = arr.slice(nTrim, arr.length - nTrim);
+    const sum = trimmed.reduce((a, b) => a + b, 0);
+    return tensor([sum / trimmed.length]);
+  }
+  const outShape = reducedShape(t.shape, axes, false);
+  const outStrides = computeStrides(outShape);
+  const outSize = outShape.reduce((a, b) => a * b, 1);
+  const buckets = new Array(outSize);
+  const nanFlags = new Array(outSize).fill(false);
+  forEachIndexOffset(t, (off, idx) => {
+    let outFlat = 0;
+    let oi = 0;
+    for (let i = 0; i < t.ndim; i++) {
+      if (reduce.has(i)) continue;
+      outFlat += (idx[i] ?? 0) * (outStrides[oi] ?? 0);
+      oi++;
+    }
+    const val = getNumberAt(t, off);
+    if (Number.isNaN(val)) {
+      nanFlags[outFlat] = true;
+      return;
+    }
+    const arr = buckets[outFlat] ?? [];
+    arr.push(val);
+    buckets[outFlat] = arr;
+  });
+  const out = new Float64Array(outSize);
+  for (let i = 0; i < outSize; i++) {
+    if (nanFlags[i]) {
+      out[i] = Number.NaN;
+      continue;
+    }
+    const arr = buckets[i] ?? [];
+    if (arr.length === 0) {
+      throw new InvalidParameterError(
+        "trimMean() reduction over empty axis is undefined",
+        "axis",
+        arr.length
+      );
+    }
+    arr.sort((a, b) => a - b);
+    const nTrim = Math.floor(arr.length * proportiontocut);
+    const trimmed = arr.slice(nTrim, arr.length - nTrim);
+    const sum = trimmed.reduce((a, b) => a + b, 0);
+    out[i] = sum / trimmed.length;
+  }
+  return Tensor.fromTypedArray({
+    data: out,
+    shape: outShape,
+    dtype: "float64",
+    device: t.device
+  });
+}
+
+// src/stats/tests.ts
+function toDenseSortedArray1D(x) {
+  if (x.size < 1) {
+    return new Float64Array(0);
+  }
+  const out = new Float64Array(x.size);
+  let i = 0;
+  forEachIndexOffset(x, (off) => {
+    out[i] = getNumberAt(x, off);
+    i++;
+  });
+  out.sort((a, b) => a - b);
+  return out;
+}
+function toDenseArray1D(x) {
+  const out = new Float64Array(x.size);
+  let i = 0;
+  forEachIndexOffset(x, (off) => {
+    out[i] = getNumberAt(x, off);
+    i++;
+  });
+  return out;
+}
+function meanAndM2(x) {
+  if (x.length === 0) {
+    throw new InvalidParameterError("expected at least one element", "length", x.length);
+  }
+  let mean2 = 0;
+  let m2 = 0;
+  for (let i = 0; i < x.length; i++) {
+    const v = x[i] ?? 0;
+    const n = i + 1;
+    const delta = v - mean2;
+    mean2 += delta / n;
+    const delta2 = v - mean2;
+    m2 += delta * delta2;
+  }
+  return { mean: mean2, m2 };
+}
+function shapiroWilk(x) {
+  const n = x.length;
+  if (n < 3 || n > 5e3) {
+    throw new InvalidParameterError("shapiro() sample size must be between 3 and 5000", "n", n);
+  }
+  const range = (x[n - 1] ?? 0) - (x[0] ?? 0);
+  if (range === 0) {
+    throw new InvalidParameterError("shapiro() all x values are identical", "range", range);
+  }
+  const small = 1e-19;
+  if (range < small) {
+    throw new InvalidParameterError("shapiro() range is too small", "range", range);
+  }
+  const nn2 = Math.floor(n / 2);
+  const a = new Float64Array(nn2 + 1);
+  const g = [-2.273, 0.459];
+  const c1 = [0, 0.221157, -0.147981, -2.07119, 4.434685, -2.706056];
+  const c2 = [0, 0.042981, -0.293762, -1.752461, 5.682633, -3.582633];
+  const c3 = [0.544, -0.39978, 0.025054, -6714e-7];
+  const c4 = [1.3822, -0.77857, 0.062767, -20322e-7];
+  const c5 = [-1.5861, -0.31082, -0.083751, 38915e-7];
+  const c6 = [-0.4803, -0.082676, 30302e-7];
+  const poly = (cc, x0) => {
+    let p = cc[cc.length - 1] ?? 0;
+    for (let j = cc.length - 2; j >= 0; j--) {
+      p = p * x0 + (cc[j] ?? 0);
+    }
+    return p;
+  };
+  const sign = (v) => v === 0 ? 0 : v > 0 ? 1 : -1;
+  const an = n;
+  if (n === 3) {
+    a[1] = Math.SQRT1_2;
+  } else {
+    const an25 = an + 0.25;
+    let summ2 = 0;
+    for (let i = 1; i <= nn2; i++) {
+      const p = (i - 0.375) / an25;
+      let lo = -10;
+      let hi = 10;
+      for (let it = 0; it < 80; it++) {
+        const mid = (lo + hi) / 2;
+        const cdf = normalCdf(mid);
+        if (cdf < p) lo = mid;
+        else hi = mid;
+      }
+      const z2 = (lo + hi) / 2;
+      a[i] = z2;
+      summ2 += z2 * z2;
+    }
+    summ2 *= 2;
+    const ssumm2 = Math.sqrt(summ2);
+    const rsn = 1 / Math.sqrt(an);
+    const a1 = poly(c1, rsn) - (a[1] ?? 0) / ssumm2;
+    let i1;
+    let fac;
+    if (n > 5) {
+      i1 = 3;
+      const a2 = -((a[2] ?? 0) / ssumm2) + poly(c2, rsn);
+      fac = Math.sqrt(
+        (summ2 - 2 * (a[1] ?? 0) * (a[1] ?? 0) - 2 * (a[2] ?? 0) * (a[2] ?? 0)) / (1 - 2 * a1 * a1 - 2 * a2 * a2)
+      );
+      a[2] = a2;
+    } else {
+      i1 = 2;
+      fac = Math.sqrt((summ2 - 2 * (a[1] ?? 0) * (a[1] ?? 0)) / (1 - 2 * a1 * a1));
+    }
+    a[1] = a1;
+    for (let i = i1; i <= nn2; i++) {
+      a[i] = -((a[i] ?? 0) / fac);
+    }
+  }
+  let xx = (x[0] ?? 0) / range;
+  let sx = xx;
+  let sa = -(a[1] ?? 0);
+  for (let i = 1, j = n - 1; i < n; j--) {
+    const xi = (x[i] ?? 0) / range;
+    if (xx - xi > small) {
+      throw new InvalidParameterError("shapiro() data is not sorted", "data", "unsorted");
+    }
+    sx += xi;
+    i++;
+    if (i !== j) {
+      sa += sign(i - j) * (a[Math.min(i, j)] ?? 0);
+    }
+    xx = xi;
+  }
+  sa /= n;
+  sx /= n;
+  let ssa = 0;
+  let ssx = 0;
+  let sax = 0;
+  for (let i = 0, j = n - 1; i < n; i++, j--) {
+    const asa = i !== j ? sign(i - j) * (a[1 + Math.min(i, j)] ?? 0) - sa : -sa;
+    const xsx = (x[i] ?? 0) / range - sx;
+    ssa += asa * asa;
+    ssx += xsx * xsx;
+    sax += asa * xsx;
+  }
+  const ssassx = Math.sqrt(ssa * ssx);
+  const w1 = (ssassx - sax) * (ssassx + sax) / (ssa * ssx);
+  const w = 1 - w1;
+  if (n === 3) {
+    const pi6 = 1.90985931710274;
+    const stqr = 1.0471975511966;
+    let pw = pi6 * (Math.asin(Math.sqrt(w)) - stqr);
+    if (pw < 0) pw = 0;
+    if (pw > 1) pw = 1;
+    return { statistic: w, pvalue: pw };
+  }
+  const y = Math.log(w1);
+  const lnN = Math.log(an);
+  let m;
+  let s;
+  if (n <= 11) {
+    const gamma = poly(g, an);
+    if (y >= gamma) {
+      return { statistic: w, pvalue: 0 };
+    }
+    const yy = -Math.log(gamma - y);
+    m = poly(c3, an);
+    s = Math.exp(poly(c4, an));
+    const z2 = (yy - m) / s;
+    return { statistic: w, pvalue: normalCdf(z2) };
+  }
+  m = poly(c5, lnN);
+  s = Math.exp(poly(c6, lnN));
+  const z = (y - m) / s;
+  return { statistic: w, pvalue: normalCdf(z) };
+}
+function ttest_1samp(a, popmean) {
+  const x = toDenseSortedArray1D(a);
+  const n = x.length;
+  if (n < 2) {
+    throw new InvalidParameterError("ttest_1samp() requires at least 2 samples", "n", n);
+  }
+  let mean2 = 0;
+  for (let i = 0; i < n; i++) mean2 += x[i] ?? 0;
+  mean2 /= n;
+  let m2 = 0;
+  for (let i = 0; i < n; i++) {
+    const d = (x[i] ?? 0) - mean2;
+    m2 += d * d;
+  }
+  const variance2 = m2 / (n - 1);
+  const std2 = Math.sqrt(variance2);
+  if (std2 === 0) {
+    throw new InvalidParameterError("ttest_1samp() is undefined for constant input", "std", std2);
+  }
+  const tstat = (mean2 - popmean) / (std2 / Math.sqrt(n));
+  const df = n - 1;
+  const pvalue = 2 * (1 - studentTCdf(Math.abs(tstat), df));
+  return { statistic: tstat, pvalue };
+}
+function ttest_ind(a, b, equalVar = true) {
+  const xa = toDenseSortedArray1D(a);
+  const xb = toDenseSortedArray1D(b);
+  const na = xa.length;
+  const nb = xb.length;
+  if (na < 2 || nb < 2) {
+    throw new InvalidParameterError("ttest_ind() requires at least 2 samples in each group", "n", {
+      na,
+      nb
+    });
+  }
+  let meanA = 0;
+  let meanB = 0;
+  for (let i = 0; i < na; i++) meanA += xa[i] ?? 0;
+  for (let i = 0; i < nb; i++) meanB += xb[i] ?? 0;
+  meanA /= na;
+  meanB /= nb;
+  let ssa = 0;
+  let ssb = 0;
+  for (let i = 0; i < na; i++) {
+    const d = (xa[i] ?? 0) - meanA;
+    ssa += d * d;
+  }
+  for (let i = 0; i < nb; i++) {
+    const d = (xb[i] ?? 0) - meanB;
+    ssb += d * d;
+  }
+  const varA = ssa / (na - 1);
+  const varB = ssb / (nb - 1);
+  let tstat;
+  let df;
+  if (equalVar) {
+    const pooledVar = ((na - 1) * varA + (nb - 1) * varB) / (na + nb - 2);
+    const denom = Math.sqrt(pooledVar * (1 / na + 1 / nb));
+    if (denom === 0)
+      throw new InvalidParameterError(
+        "ttest_ind() is undefined for constant input",
+        "denom",
+        denom
+      );
+    tstat = (meanA - meanB) / denom;
+    df = na + nb - 2;
+  } else {
+    const denom = Math.sqrt(varA / na + varB / nb);
+    if (denom === 0)
+      throw new InvalidParameterError(
+        "ttest_ind() is undefined for constant input",
+        "denom",
+        denom
+      );
+    tstat = (meanA - meanB) / denom;
+    df = (varA / na + varB / nb) ** 2 / ((varA / na) ** 2 / (na - 1) + (varB / nb) ** 2 / (nb - 1));
+  }
+  const pvalue = 2 * (1 - studentTCdf(Math.abs(tstat), df));
+  return { statistic: tstat, pvalue };
+}
+function ttest_rel(a, b) {
+  if (a.size !== b.size) {
+    throw new InvalidParameterError("ttest_rel() requires paired samples of equal length", "size", {
+      a: a.size,
+      b: b.size
+    });
+  }
+  const n = a.size;
+  if (n < 2) {
+    throw new InvalidParameterError("ttest_rel() requires at least 2 paired samples", "n", n);
+  }
+  const diffs = new Float64Array(n);
+  let i = 0;
+  forEachIndexOffset(a, (offA) => {
+    diffs[i] = getNumberAt(a, offA);
+    i++;
+  });
+  const bd = new Float64Array(n);
+  i = 0;
+  forEachIndexOffset(b, (offB) => {
+    bd[i] = getNumberAt(b, offB);
+    i++;
+  });
+  for (let k = 0; k < n; k++) {
+    diffs[k] = (diffs[k] ?? 0) - (bd[k] ?? 0);
+  }
+  let mean2 = 0;
+  for (let k = 0; k < n; k++) mean2 += diffs[k] ?? 0;
+  mean2 /= n;
+  let ss = 0;
+  for (let k = 0; k < n; k++) {
+    const d = (diffs[k] ?? 0) - mean2;
+    ss += d * d;
+  }
+  const varDiff = ss / (n - 1);
+  const stdDiff = Math.sqrt(varDiff);
+  if (stdDiff === 0) {
+    throw new InvalidParameterError(
+      "ttest_rel() is undefined for constant differences",
+      "stdDiff",
+      stdDiff
+    );
+  }
+  const tstat = mean2 / (stdDiff / Math.sqrt(n));
+  const df = n - 1;
+  const pvalue = 2 * (1 - studentTCdf(Math.abs(tstat), df));
+  return { statistic: tstat, pvalue };
+}
+function chisquare(f_obs, f_exp) {
+  const obs = toDenseArray1D(f_obs);
+  const n = obs.length;
+  if (n < 1) {
+    throw new InvalidParameterError("chisquare() requires at least one observed value", "n", n);
+  }
+  let chiSq = 0;
+  let sumObs = 0;
+  for (let i = 0; i < n; i++) {
+    const v = obs[i] ?? 0;
+    if (!Number.isFinite(v) || v < 0) {
+      throw new InvalidParameterError(
+        "chisquare() observed frequencies must be finite and >= 0",
+        "f_obs",
+        v
+      );
+    }
+    sumObs += v;
+  }
+  if (f_exp && f_obs.size !== f_exp.size) {
+    throw new InvalidParameterError(
+      "Observed and expected frequency arrays must have the same length",
+      "size",
+      { f_obs: f_obs.size, f_exp: f_exp.size }
+    );
+  }
+  if (!f_exp) {
+    const expected = sumObs / n;
+    if (!Number.isFinite(expected) || expected <= 0) {
+      throw new InvalidParameterError(
+        "chisquare() expected frequencies must be finite and > 0",
+        "expected",
+        expected
+      );
+    }
+    for (let i = 0; i < n; i++) {
+      const v = obs[i] ?? 0;
+      chiSq += (v - expected) ** 2 / expected;
+    }
+  } else {
+    const exp = toDenseArray1D(f_exp);
+    let sumExp = 0;
+    for (let i = 0; i < n; i++) {
+      const v = exp[i] ?? 0;
+      if (!Number.isFinite(v) || v <= 0) {
+        throw new InvalidParameterError(
+          "chisquare() expected frequencies must be finite and > 0",
+          "f_exp",
+          v
+        );
+      }
+      sumExp += v;
+    }
+    const rtol = Math.sqrt(Number.EPSILON);
+    const denom = Math.max(Math.abs(sumObs), Math.abs(sumExp));
+    if (Math.abs(sumObs - sumExp) > rtol * denom) {
+      throw new InvalidParameterError(
+        "chisquare() expected and observed frequencies must sum to the same value",
+        "sum",
+        { f_obs: sumObs, f_exp: sumExp }
+      );
+    }
+    for (let i = 0; i < n; i++) {
+      const vObs = obs[i] ?? 0;
+      const vExp = exp[i] ?? 0;
+      chiSq += (vObs - vExp) ** 2 / vExp;
+    }
+  }
+  const df = n - 1;
+  if (df < 1) {
+    throw new InvalidParameterError(
+      "chisquare() requires at least 2 categories (df must be >= 1)",
+      "df",
+      df
+    );
+  }
+  const pvalue = 1 - chiSquareCdf(chiSq, df);
+  return { statistic: chiSq, pvalue };
+}
+function kstest(data, cdf) {
+  const x = toDenseSortedArray1D(data);
+  const n = x.length;
+  if (n === 0) {
+    throw new InvalidParameterError("kstest() requires at least one element", "n", n);
+  }
+  if (typeof cdf === "string" && cdf !== "norm") {
+    throw new InvalidParameterError(
+      `Unsupported distribution: '${cdf}'. Supported distributions: 'norm'`,
+      "cdf",
+      cdf
+    );
+  }
+  const F = typeof cdf === "string" ? (v) => normalCdf(v) : cdf;
+  let d = 0;
+  for (let i = 0; i < n; i++) {
+    const xi = x[i] ?? 0;
+    const fi = F(xi);
+    const dPlus = (i + 1) / n - fi;
+    const dMinus = fi - i / n;
+    d = Math.max(d, dPlus, dMinus);
+  }
+  let p = 0;
+  for (let k = 1; k < 200; k++) {
+    const term = Math.exp(-2 * k * k * d * d * n);
+    p += (k % 2 === 1 ? 1 : -1) * term;
+    if (term < 1e-12) break;
+  }
+  p = Math.max(0, Math.min(1, 2 * p));
+  return { statistic: d, pvalue: p };
+}
+function normaltest(a) {
+  const x = toDenseSortedArray1D(a);
+  const n = x.length;
+  if (n < 8) {
+    throw new InvalidParameterError("normaltest() requires at least 8 samples", "n", n);
+  }
+  const { mean: mean2, m2 } = meanAndM2(x);
+  const m2n = m2 / n;
+  const std2 = Math.sqrt(m2n);
+  if (!Number.isFinite(std2) || std2 === 0) {
+    throw new InvalidParameterError("normaltest() is undefined for constant input", "std", std2);
+  }
+  let m3 = 0;
+  let m4 = 0;
+  for (let i = 0; i < n; i++) {
+    const d = (x[i] ?? 0) - mean2;
+    m3 += d * d * d;
+    m4 += d * d * d * d;
+  }
+  const skew = m3 / n / m2n ** 1.5;
+  const kurt = m4 / n / (m2n * m2n);
+  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 yScaled = y / alpha;
+  const z1 = delta * Math.log(yScaled + Math.sqrt(yScaled * yScaled + 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 xval = (kurt - 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 aTerm = 6 + 8 / sqrtbeta1 * (2 / sqrtbeta1 + Math.sqrt(1 + 4 / (sqrtbeta1 * sqrtbeta1)));
+  const term1 = 1 - 2 / (9 * aTerm);
+  const denom = 1 + xval * Math.sqrt(2 / (aTerm - 4));
+  const term2 = denom === 0 ? Number.NaN : Math.sign(denom) * ((1 - 2 / aTerm) / Math.abs(denom)) ** (1 / 3);
+  const z2 = (term1 - term2) / Math.sqrt(2 / (9 * aTerm));
+  const k2 = z1 * z1 + z2 * z2;
+  const pvalue = 1 - chiSquareCdf(k2, 2);
+  return { statistic: k2, pvalue };
+}
+function shapiro(x) {
+  const sorted = toDenseSortedArray1D(x);
+  return shapiroWilk(sorted);
+}
+function anderson(x) {
+  const sorted = toDenseSortedArray1D(x);
+  const n = sorted.length;
+  if (n < 1) {
+    throw new InvalidParameterError("anderson() requires at least one element", "n", n);
+  }
+  const { mean: mean2, m2 } = meanAndM2(sorted);
+  const variance2 = n > 1 ? m2 / (n - 1) : NaN;
+  let std2 = Math.sqrt(variance2);
+  if (!Number.isFinite(std2) || std2 === 0) {
+    throw new InvalidParameterError("anderson() is undefined for constant input", "std", std2);
+  }
+  if (n < 10) {
+    const quantile2 = (q) => {
+      if (n === 1) return sorted[0] ?? 0;
+      const pos = (n - 1) * q;
+      const lo = Math.floor(pos);
+      const hi = Math.ceil(pos);
+      const v0 = sorted[lo] ?? 0;
+      const v1 = sorted[hi] ?? v0;
+      return v0 + (pos - lo) * (v1 - v0);
+    };
+    const q1 = quantile2(0.25);
+    const q3 = quantile2(0.75);
+    const iqr = q3 - q1;
+    const robust = iqr / 1.349;
+    if (Number.isFinite(robust) && robust > 0) {
+      std2 = robust;
+    }
+  }
+  let A2 = 0;
+  for (let i = 0; i < n; i++) {
+    const zi = ((sorted[i] ?? 0) - mean2) / std2;
+    const zj = ((sorted[n - 1 - i] ?? 0) - mean2) / std2;
+    const PhiI = Math.max(1e-300, Math.min(1 - 1e-16, normalCdf(zi)));
+    const PhiJ = Math.max(1e-300, Math.min(1 - 1e-16, normalCdf(zj)));
+    A2 += (2 * (i + 1) - 1) * (Math.log(PhiI) + Math.log(1 - PhiJ));
+  }
+  A2 = -n - A2 / n;
+  const baseCritical = [0.576, 0.656, 0.787, 0.918, 1.092];
+  const factor = 1 + 4 / n - 25 / (n * n);
+  const critical_values = baseCritical.map((v) => Math.round(v / factor * 1e3) / 1e3);
+  return {
+    statistic: A2,
+    critical_values,
+    significance_level: [0.15, 0.1, 0.05, 0.025, 0.01]
+  };
+}
+function mannwhitneyu(x, y) {
+  const nx = x.size;
+  const ny = y.size;
+  if (nx < 1 || ny < 1) {
+    throw new InvalidParameterError("Both samples must be non-empty", "size", {
+      x: nx,
+      y: ny
+    });
+  }
+  const xVals = toDenseArray1D(x);
+  const yVals = toDenseArray1D(y);
+  const n = nx + ny;
+  const combined = new Float64Array(n);
+  combined.set(xVals, 0);
+  combined.set(yVals, nx);
+  const { ranks, tieSum } = rankData(combined);
+  let R1 = 0;
+  for (let i = 0; i < nx; i++) {
+    R1 += ranks[i] ?? 0;
+  }
+  const U1 = R1 - nx * (nx + 1) / 2;
+  const U2 = nx * ny - U1;
+  const U = Math.min(U1, U2);
+  const meanU = nx * ny / 2;
+  const tieAdj = n > 1 ? tieSum / (n * (n - 1)) : 0;
+  const varU = nx * ny * (n + 1 - tieAdj) / 12;
+  if (varU <= 0) {
+    return { statistic: U, pvalue: NaN };
+  }
+  const stdU = Math.sqrt(varU);
+  const useContinuity = nx + ny > 20;
+  const continuity = useContinuity ? U < meanU ? 0.5 : U > meanU ? -0.5 : 0 : 0;
+  const z = (U - meanU + continuity) / stdU;
+  const pvalue = 2 * (1 - normalCdf(Math.abs(z)));
+  return { statistic: U, pvalue };
+}
+function wilcoxon(x, y) {
+  const n = x.size;
+  const diffs = [];
+  if (y) {
+    if (x.size !== y.size) {
+      throw new InvalidParameterError("Paired samples must have equal length", "size", {
+        x: x.size,
+        y: y.size
+      });
+    }
+    const xd = toDenseArray1D(x);
+    const yd = toDenseArray1D(y);
+    for (let i = 0; i < n; i++) {
+      const diff = (xd[i] ?? 0) - (yd[i] ?? 0);
+      if (diff !== 0) diffs.push(diff);
+    }
+  } else {
+    const xd = toDenseArray1D(x);
+    for (let i = 0; i < n; i++) {
+      const val = xd[i] ?? 0;
+      if (val !== 0) diffs.push(val);
+    }
+  }
+  if (diffs.length === 0) {
+    throw new InvalidParameterError(
+      "wilcoxon() is undefined when all differences are zero",
+      "diffs",
+      diffs.length
+    );
+  }
+  const absDiffs = new Float64Array(diffs.length);
+  for (let i = 0; i < diffs.length; i++) {
+    absDiffs[i] = Math.abs(diffs[i] ?? 0);
+  }
+  const { ranks, tieSum } = rankData(absDiffs);
+  let Wplus = 0;
+  for (let i = 0; i < diffs.length; i++) {
+    if ((diffs[i] ?? 0) > 0) {
+      Wplus += ranks[i] ?? 0;
+    }
+  }
+  const nEff = diffs.length;
+  const meanW = nEff * (nEff + 1) / 4;
+  const varW = nEff * (nEff + 1) * (2 * nEff + 1) / 24 - tieSum / 48;
+  if (varW <= 0) {
+    return { statistic: Wplus, pvalue: NaN };
+  }
+  const stdW = Math.sqrt(varW);
+  const useContinuity = nEff > 20;
+  const continuity = useContinuity ? Wplus < meanW ? 0.5 : Wplus > meanW ? -0.5 : 0 : 0;
+  const z = (Wplus - meanW + continuity) / stdW;
+  const pvalue = 2 * (1 - normalCdf(Math.abs(z)));
+  return { statistic: Wplus, pvalue };
+}
+function kruskal(...samples) {
+  const k = samples.length;
+  if (k < 2) {
+    throw new InvalidParameterError("kruskal() requires at least 2 groups", "k", k);
+  }
+  let N = 0;
+  const sizes = new Array(k);
+  const validatedSamples = new Array(k);
+  for (let g = 0; g < k; g++) {
+    const sample = samples[g];
+    if (!sample || sample.size < 1) {
+      throw new InvalidParameterError("kruskal() requires non-empty samples", "size", {
+        group: g,
+        size: sample?.size ?? 0
+      });
+    }
+    validatedSamples[g] = sample;
+    sizes[g] = sample.size;
+    N += sample.size;
+  }
+  const combined = new Float64Array(N);
+  const groupIndex = new Int32Array(N);
+  let idx = 0;
+  for (let g = 0; g < k; g++) {
+    const sample = validatedSamples[g];
+    if (!sample) {
+      throw new InvalidParameterError("kruskal() requires non-empty samples", "sample", g);
+    }
+    const vals = toDenseArray1D(sample);
+    for (let i = 0; i < vals.length; i++) {
+      combined[idx] = vals[i] ?? 0;
+      groupIndex[idx] = g;
+      idx++;
+    }
+  }
+  const { ranks, tieSum } = rankData(combined);
+  const rankSums = new Float64Array(k);
+  for (let i = 0; i < N; i++) {
+    const group = groupIndex[i] ?? 0;
+    const rank = ranks[i] ?? 0;
+    rankSums[group] = (rankSums[group] ?? 0) + rank;
+  }
+  let H = 0;
+  for (let g = 0; g < k; g++) {
+    const rs = rankSums[g] ?? 0;
+    const sz = sizes[g] ?? 1;
+    H += rs * rs / sz;
+  }
+  H = 12 / (N * (N + 1)) * H - 3 * (N + 1);
+  const tieCorrection = N > 1 ? 1 - tieSum / (N * N * N - N) : 1;
+  if (tieCorrection <= 0) {
+    throw new InvalidParameterError(
+      "kruskal() is undefined when all numbers are identical",
+      "tieCorrection",
+      tieCorrection
+    );
+  }
+  H /= tieCorrection;
+  const df = k - 1;
+  const pvalue = 1 - chiSquareCdf(H, df);
+  return { statistic: H, pvalue };
+}
+function friedmanchisquare(...samples) {
+  const k = samples.length;
+  if (k < 3) {
+    throw new InvalidParameterError(
+      "friedmanchisquare() requires at least 3 related samples",
+      "k",
+      k
+    );
+  }
+  const n = samples[0]?.size ?? 0;
+  if (n < 1) {
+    throw new InvalidParameterError(
+      "friedmanchisquare() requires all samples to be non-empty",
+      "n",
+      n
+    );
+  }
+  for (let i = 1; i < k; i++) {
+    const sample = samples[i];
+    if (sample && sample.size !== n) {
+      throw new InvalidParameterError(
+        "All samples must have the same length for Friedman test",
+        "size",
+        { expected: n, got: sample.size, sampleIndex: i }
+      );
+    }
+  }
+  const denseSamples = samples.map(
+    (sample) => sample ? toDenseArray1D(sample) : new Float64Array(0)
+  );
+  const rankSums = new Float64Array(k);
+  let tieSum = 0;
+  for (let i = 0; i < n; i++) {
+    const block = new Float64Array(k);
+    for (let j = 0; j < k; j++) {
+      const arr = denseSamples[j];
+      block[j] = arr?.[i] ?? 0;
+    }
+    const ranked = rankData(block);
+    tieSum += ranked.tieSum;
+    for (let j = 0; j < k; j++) {
+      const rank = ranked.ranks[j] ?? 0;
+      rankSums[j] = (rankSums[j] ?? 0) + rank;
+    }
+  }
+  let chiSq = 0;
+  for (let j = 0; j < k; j++) {
+    const rs = rankSums[j] ?? 0;
+    chiSq += rs * rs;
+  }
+  chiSq = 12 / (n * k * (k + 1)) * chiSq - 3 * n * (k + 1);
+  const tieCorrection = n > 0 ? 1 - tieSum / (n * k * (k * k - 1)) : 1;
+  if (tieCorrection <= 0) {
+    throw new InvalidParameterError(
+      "friedmanchisquare() is undefined when all numbers are identical within blocks",
+      "tieCorrection",
+      tieCorrection
+    );
+  }
+  chiSq /= tieCorrection;
+  const df = k - 1;
+  const pvalue = 1 - chiSquareCdf(chiSq, df);
+  return { statistic: chiSq, pvalue };
+}
+function levene(center, ...samples) {
+  const k = samples.length;
+  if (k < 2) {
+    throw new InvalidParameterError("levene() requires at least 2 groups", "k", k);
+  }
+  const groups = [];
+  const centers = [];
+  for (let g = 0; g < k; g++) {
+    const sample = samples[g];
+    if (!sample || sample.size === 0) {
+      throw new InvalidParameterError("levene() requires all groups to be non-empty", "groupSize", {
+        group: g,
+        size: sample?.size ?? 0
+      });
+    }
+    const arr = toDenseSortedArray1D(sample);
+    if (arr.length < 2) {
+      throw new InvalidParameterError(
+        "levene() requires at least 2 samples per group",
+        "groupSize",
+        arr.length
+      );
+    }
+    groups.push(arr);
+    if (center === "mean") {
+      let sum = 0;
+      for (let i = 0; i < arr.length; i++) sum += arr[i] ?? 0;
+      centers.push(sum / arr.length);
+    } else if (center === "median") {
+      const mid = Math.floor(arr.length / 2);
+      if (arr.length % 2 === 0) {
+        centers.push(((arr[mid - 1] ?? 0) + (arr[mid] ?? 0)) / 2);
+      } else {
+        centers.push(arr[mid] ?? 0);
+      }
+    } else {
+      const trimCount = Math.floor(arr.length * 0.1);
+      let sum = 0;
+      const n = arr.length - 2 * trimCount;
+      for (let i = trimCount; i < arr.length - trimCount; i++) {
+        sum += arr[i] ?? 0;
+      }
+      centers.push(sum / n);
+    }
+  }
+  const Z = [];
+  const groupMeansZ = [];
+  let N = 0;
+  let grandSumZ = 0;
+  for (let g = 0; g < groups.length; g++) {
+    const arr = groups[g];
+    if (!arr) continue;
+    const c = centers[g] ?? 0;
+    const zArr = new Float64Array(arr.length);
+    let sumZ = 0;
+    for (let i = 0; i < arr.length; i++) {
+      const absVal = Math.abs((arr[i] ?? 0) - c);
+      zArr[i] = absVal;
+      sumZ += absVal;
+    }
+    Z.push(zArr);
+    groupMeansZ.push(sumZ / arr.length);
+    N += arr.length;
+    grandSumZ += sumZ;
+  }
+  const grandMeanZ = grandSumZ / N;
+  let SSB = 0;
+  let SSW = 0;
+  for (let g = 0; g < Z.length; g++) {
+    const zArr = Z[g];
+    if (!zArr) continue;
+    const n = zArr.length;
+    SSB += n * ((groupMeansZ[g] ?? 0) - grandMeanZ) ** 2;
+    for (let i = 0; i < n; i++) {
+      SSW += ((zArr[i] ?? 0) - (groupMeansZ[g] ?? 0)) ** 2;
+    }
+  }
+  const dfB = k - 1;
+  const dfW = N - k;
+  if (dfW <= 0) {
+    throw new InvalidParameterError(
+      "levene() requires more total observations than groups",
+      "dfW",
+      dfW
+    );
+  }
+  if (SSW === 0) {
+    return { statistic: Infinity, pvalue: 0 };
+  }
+  const W = SSB / dfB / (SSW / dfW);
+  const pvalue = 1 - fCdf(W, dfB, dfW);
+  return { statistic: W, pvalue };
+}
+function bartlett(...samples) {
+  const k = samples.length;
+  if (k < 2) {
+    throw new InvalidParameterError("bartlett() requires at least 2 groups", "k", k);
+  }
+  const variances = [];
+  const sizes = [];
+  let N = 0;
+  for (let g = 0; g < k; g++) {
+    const sample = samples[g];
+    if (!sample || sample.size === 0) {
+      throw new InvalidParameterError(
+        "bartlett() requires all groups to be non-empty",
+        "groupSize",
+        { group: g, size: sample?.size ?? 0 }
+      );
+    }
+    const arr = toDenseSortedArray1D(sample);
+    const n = arr.length;
+    if (n < 2) {
+      throw new InvalidParameterError(
+        "bartlett() requires at least 2 samples per group",
+        "groupSize",
+        n
+      );
+    }
+    let mean2 = 0;
+    for (let i = 0; i < n; i++) mean2 += arr[i] ?? 0;
+    mean2 /= n;
+    let ss = 0;
+    for (let i = 0; i < n; i++) {
+      const d = (arr[i] ?? 0) - mean2;
+      ss += d * d;
+    }
+    const variance2 = ss / (n - 1);
+    variances.push(variance2);
+    sizes.push(n);
+    N += n;
+  }
+  for (let g = 0; g < k; g++) {
+    if ((variances[g] ?? 0) === 0) {
+      throw new InvalidParameterError(
+        "bartlett() is undefined when a group has zero variance",
+        "variance",
+        variances[g]
+      );
+    }
+  }
+  let pooledNumerator = 0;
+  for (let g = 0; g < k; g++) {
+    pooledNumerator += ((sizes[g] ?? 1) - 1) * (variances[g] ?? 1);
+  }
+  const pooledVariance = pooledNumerator / (N - k);
+  let sumLogVar = 0;
+  for (let g = 0; g < k; g++) {
+    sumLogVar += ((sizes[g] ?? 1) - 1) * Math.log(variances[g] ?? 1);
+  }
+  const T = (N - k) * Math.log(pooledVariance) - sumLogVar;
+  let sumInvDf = 0;
+  for (let g = 0; g < k; g++) {
+    sumInvDf += 1 / ((sizes[g] ?? 1) - 1);
+  }
+  const C = 1 + 1 / (3 * (k - 1)) * (sumInvDf - 1 / (N - k));
+  const chiSq = T / C;
+  const df = k - 1;
+  const pvalue = 1 - chiSquareCdf(chiSq, df);
+  return { statistic: chiSq, pvalue };
+}
+function f_oneway(...samples) {
+  const k = samples.length;
+  if (k < 2) {
+    throw new InvalidParameterError("f_oneway() requires at least 2 groups", "groups", k);
+  }
+  for (let g = 0; g < k; g++) {
+    const sample = samples[g];
+    if (!sample || sample.size === 0) {
+      throw new InvalidParameterError(
+        "f_oneway() requires all groups to be non-empty",
+        "groupSize",
+        { group: g, size: sample?.size ?? 0 }
+      );
+    }
+  }
+  let N = 0;
+  const means = [];
+  const sizes = [];
+  const groups = [];
+  for (let g = 0; g < k; g++) {
+    const sample = samples[g];
+    if (!sample) {
+      throw new InvalidParameterError(
+        "f_oneway() requires all groups to be non-empty",
+        "groupSize",
+        { group: g, size: 0 }
+      );
+    }
+    const arr = toDenseArray1D(sample);
+    const n = arr.length;
+    groups.push(arr);
+    sizes.push(n);
+    N += n;
+    let sum = 0;
+    for (let i = 0; i < n; i++) {
+      sum += arr[i] ?? 0;
+    }
+    means.push(sum / n);
+  }
+  let grandSum = 0;
+  for (let g = 0; g < k; g++) {
+    grandSum += (means[g] ?? 0) * (sizes[g] ?? 0);
+  }
+  const grandMean = grandSum / N;
+  let SSB = 0;
+  let SSW = 0;
+  for (let g = 0; g < groups.length; g++) {
+    const arr = groups[g];
+    if (!arr) continue;
+    const n = arr.length;
+    SSB += n * ((means[g] ?? 0) - grandMean) ** 2;
+    for (let i = 0; i < n; i++) {
+      SSW += ((arr[i] ?? 0) - (means[g] ?? 0)) ** 2;
+    }
+  }
+  const dfB = k - 1;
+  const dfW = N - k;
+  if (dfW <= 0) {
+    throw new InvalidParameterError(
+      "f_oneway() requires at least one group with more than one sample",
+      "dfW",
+      dfW
+    );
+  }
+  const MSB = SSB / dfB;
+  const MSW = SSW / dfW;
+  if (MSW === 0) {
+    const F2 = MSB === 0 ? NaN : Infinity;
+    return { statistic: F2, pvalue: MSB === 0 ? NaN : 0 };
+  }
+  const F = MSB / MSW;
+  const pvalue = 1 - fCdf(F, dfB, dfW);
+  return { statistic: F, pvalue };
+}
+
+export { anderson, bartlett, chisquare, corrcoef, cov, f_oneway, friedmanchisquare, geometricMean, harmonicMean, kendalltau, kruskal, kstest, kurtosis, levene, mannwhitneyu, mean, median, mode, moment, normaltest, pearsonr, percentile, quantile, shapiro, skewness, spearmanr, stats_exports, std, trimMean, ttest_1samp, ttest_ind, ttest_rel, variance, wilcoxon };
+//# sourceMappingURL=chunk-XMWVME2W.js.map
+//# sourceMappingURL=chunk-XMWVME2W.js.map