@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/descriptive/cov.js

@@ -0,0 +1,105 @@
+// Covariance and correlation of vectors and matrices: R's cov and cor with `method` and `use`.
+//
+// Written for rStats.js (no ported code). A matrix is an array of rows, its columns the variables. Pearson
+// covariances and correlations are computed in double-double (src/internal/summary.ts, src/htest/cor.ts); Spearman's
+// are Pearson's of the ranks (ranked after missing values are dropped as `use` says); Kendall's covariance is the
+// sum of sign(x_i - x_j) sign(y_i - y_j) over all ordered pairs, as R reports it, and the correlation is tau-b.
+// `use` follows R: "everything" (a missing value makes the entry NaN), "all.obs" (missing values are an error),
+// "complete.obs" and "na.or.complete" (rows with any missing value are dropped) and "pairwise.complete.obs" (each
+// pair of variables uses the rows where both are present).
+import { kendall, pearsonDD } from "../htest/cor.js";
+import { covariance } from "../internal/summary.js";
+import { rank } from "./rank.js";
+const METHODS = ["pearson", "kendall", "spearman"];
+const USES = ["all.obs", "complete.obs", "pairwise.complete.obs", "everything", "na.or.complete"];
+function match(v, all, dflt, what) {
+    if (v === undefined)
+        return dflt;
+    if (all.includes(v))
+        return v;
+    const hit = all.filter((a) => a.startsWith(v));
+    if (v.length === 0 || hit.length !== 1)
+        throw new RangeError(`invalid '${what}' argument`);
+    return hit[0];
+}
+function isMatrix(x) {
+    return x.length > 0 && Array.isArray(x[0]);
+}
+/** Columns of a matrix (array of rows), or the vector as one column */
+function columns(x) {
+    if (!isMatrix(x))
+        return [Array.from(x)];
+    const ncol = x[0].length;
+    return Array.from({ length: ncol }, (_, j) => x.map((r) => r[j]));
+}
+function compute(x, y, options, correlation) {
+    const method = match(options.method, METHODS, "pearson", "method");
+    const use = match(options.use, USES, "everything", "use");
+    if (y === undefined && !isMatrix(x))
+        throw new TypeError("supply both 'x' and 'y' or a matrix-like 'x'");
+    const cx = columns(x);
+    const cy = y === undefined ? cx : columns(y);
+    const n = cx[0]?.length ?? 0;
+    if (cy.some((c) => c.length !== n))
+        throw new RangeError("incompatible dimensions");
+    const all = [...cx, ...cy];
+    if (use === "all.obs" && all.some((c) => c.some(Number.isNaN)))
+        throw new RangeError("missing observations in cov/cor");
+    if (!correlation && use === "pairwise.complete.obs" && method !== "pearson") {
+        throw new RangeError("cannot handle 'pairwise.complete.obs'");
+    }
+    let keepRows;
+    if (use === "complete.obs" || use === "na.or.complete") {
+        keepRows = Array.from({ length: n }, (_, i) => all.every((c) => !Number.isNaN(c[i])));
+        if (!keepRows.some(Boolean)) {
+            if (use === "complete.obs")
+                throw new RangeError("no complete element pairs");
+            return y === undefined || isMatrix(x) || isMatrix(y) ? cx.map(() => cy.map(() => NaN)) : NaN;
+        }
+    }
+    const prep = (c) => {
+        const v = keepRows === undefined ? c : c.filter((_, i) => keepRows[i]);
+        // ranks for Spearman, missing values kept in place (pairwise ranks are taken per pair below)
+        return method === "spearman" && use !== "pairwise.complete.obs" ? rank(v, { naLast: "keep" }) : v;
+    };
+    const px = cx.map(prep);
+    const py = y === undefined ? px : cy.map(prep);
+    const entry = (a, b) => {
+        let u = a;
+        let v = b;
+        if (use === "pairwise.complete.obs") {
+            const ok = a.map((t, i) => !Number.isNaN(t) && !Number.isNaN(b[i]));
+            u = a.filter((_, i) => ok[i]);
+            v = b.filter((_, i) => ok[i]);
+            if (method === "spearman") {
+                u = rank(u);
+                v = rank(v);
+            }
+        }
+        else if (u.some(Number.isNaN) || v.some(Number.isNaN))
+            return NaN;
+        if (method === "kendall") {
+            if (correlation)
+                return kendall(u, v).tau;
+            return 2 * kendall(u, v).s;
+        }
+        if (correlation)
+            return pearsonDD(u, v)[0];
+        return covariance(u, v);
+    };
+    const out = px.map((a) => py.map((b) => entry(a, b)));
+    // as in R, the correlation matrix of x alone has 1 on the diagonal, whatever the column holds
+    if (correlation && y === undefined && use !== "pairwise.complete.obs")
+        out.forEach((r, i) => (r[i] = 1));
+    return (y === undefined ? false : !isMatrix(x) && !isMatrix(y)) ? out[0][0] : out;
+}
+export function cov(x, y, options = {}) {
+    if (y !== undefined && !Array.isArray(y) && !ArrayBuffer.isView(y))
+        return compute(x, undefined, y, false);
+    return compute(x, y, options, false);
+}
+export function cor(x, y, options = {}) {
+    if (y !== undefined && !Array.isArray(y) && !ArrayBuffer.isView(y))
+        return compute(x, undefined, y, true);
+    return compute(x, y, options, true);
+}

package/dist/descriptive/hist.d.ts

@@ -0,0 +1,64 @@
+import type { Sample } from "../htest/types.js";
+/** Options for {@link pretty}. */
+export interface PrettyOptions {
+    /** Desired number of intervals. Default `5`. */
+    n?: number;
+    /** Minimal number of intervals. Default `n / 3` rounded down. */
+    minN?: number;
+    /** Factor applied to the cell when the range is very small. Default `0.75`. */
+    shrinkSml?: number;
+    /** Bias towards larger units. Default `1.5`. */
+    highUBias?: number;
+    /** Bias towards 5 over 2 times a power of 10. Default `0.5 + 1.5 * highUBias`. */
+    u5Bias?: number;
+}
+/**
+ * About n + 1 equally spaced "round" values (1, 2 or 5 times a power of 10) covering the range of `x`. Equivalent to
+ * R's `pretty()`.
+ *
+ * @example
+ * ```ts
+ * pretty([0.3, 9.6]); // [0, 2, 4, 6, 8, 10]
+ * ```
+ */
+export declare function pretty(x: Sample, options?: PrettyOptions): number[];
+/** Options for {@link hist}. */
+export interface HistOptions {
+    /**
+     * Break points, a number of cells (a suggestion for pretty), or a rule: `"Sturges"` (default), `"Scott"` or
+     * `"FD"` (Freedman-Diaconis).
+     */
+    breaks?: readonly number[] | number | "Sturges" | "Scott" | "FD" | "Freedman-Diaconis";
+    /** Cells closed on the right, (a, b] (default `true`). */
+    right?: boolean;
+    /** Close the first cell on the left (the last on the right when `right` is false). Default `true`. */
+    includeLowest?: boolean;
+}
+/** Result of {@link hist}. */
+export interface HistResult {
+    breaks: number[];
+    counts: number[];
+    /** counts / (n * cell width) */
+    density: number[];
+    mids: number[];
+}
+/**
+ * Histogram counts. Equivalent to R's `hist(x, plot = FALSE)`: break points (by default pretty points over the range
+ * with about Sturges' number of cells), counts, densities and cell midpoints. Non-finite values are dropped.
+ *
+ * @example
+ * ```ts
+ * hist([1, 2, 2, 3, 3, 3, 4]).counts; // [3, 3, 1] for breaks [1, 2, 3, 4]
+ * ```
+ */
+export declare function hist(x: Sample, options?: HistOptions): HistResult;
+/**
+ * Empirical distribution function of `x`: a function returning the fraction of values at or below its argument.
+ * Equivalent to R's `ecdf()`. `NaN` values are dropped.
+ *
+ * @example
+ * ```ts
+ * ecdf([3, 1, 2])(2); // 2/3
+ * ```
+ */
+export declare function ecdf(x: Sample): (q: number) => number;

package/dist/descriptive/hist.js

@@ -0,0 +1,304 @@
+// Histogram counts and pretty break points: R's hist (with plot = FALSE), pretty and ecdf.
+//
+// Written for rStats.js to reproduce R's documented behaviour and output. pretty picks a unit of 1, 2, 5 or 10 times
+// a power of ten close to range / n, preferring the larger units by the biases high.u.bias and u5.bias described in
+// R's ?pretty, then extends to integer multiples of the unit that cover the data (with a 1e-10 relative rounding
+// allowance) and keeps at least min.n cells; a range that is tiny relative to its magnitude gets a scale derived
+// from the magnitude instead. hist chooses the number of cells by Sturges' (1926), Scott's (1979) or Freedman and
+// Diaconis' (1981) rule, or as given, takes pretty break points over the data range, and counts after moving the
+// breaks by 1e-7 times a typical cell width, so that values lying on a break up to rounding fall on the intended side.
+// The order of floating-point operations follows R where the results are compared bit for bit.
+import { median, range, sd } from "./basic.js";
+import { IQR, quantile } from "./quantile.js";
+import { seqLength } from "../internal/seq.js";
+/**
+ * About n + 1 equally spaced "round" values (1, 2 or 5 times a power of 10) covering the range of `x`. Equivalent to
+ * R's `pretty()`.
+ *
+ * @example
+ * ```ts
+ * pretty([0.3, 9.6]); // [0, 2, 4, 6, 8, 10]
+ * ```
+ */
+export function pretty(x, options = {}) {
+    const finite = Array.from(x).filter(Number.isFinite);
+    if (finite.length === 0)
+        return [];
+    const n = options.n ?? 5;
+    const minN = options.minN ?? Math.floor(n / 3);
+    const shrink = options.shrinkSml ?? 0.75;
+    const h = options.highUBias ?? 1.5;
+    const h5 = options.u5Bias ?? 0.5 + 1.5 * h;
+    let lo = Infinity;
+    let up = -Infinity;
+    for (const v of finite) {
+        if (v < lo)
+            lo = v;
+        if (v > up)
+            up = v;
+    }
+    const d = up - lo;
+    // Step 1: the scale (target cell width)
+    let c;
+    let small;
+    if (d === 0 && up === 0) {
+        c = 1;
+        small = true;
+    }
+    else {
+        c = Math.max(Math.abs(lo), Math.abs(up));
+        const t = h5 >= 1.5 * h + 0.5 ? 1 / (1 + h) : 1.5 / (1 + h5);
+        const bound = (1 + t) * Math.max(1, n) * Number.EPSILON;
+        small = d < c * bound * 3;
+    }
+    if (small) {
+        if (c > 10)
+            c = 9 + c / 10;
+        c *= shrink;
+        if (minN > 1)
+            c /= minN;
+    }
+    else {
+        c = n > 1 ? d / n : d;
+        if (d === Infinity && n >= 2)
+            c = up / n - lo / n;
+    }
+    const tiny = 2 ** -20 * DBL_MIN;
+    if (c < tiny)
+        c = tiny;
+    else if (c > Number.MAX_VALUE / 1.25)
+        c = Number.MAX_VALUE / 1.25;
+    // Step 2: the unit, walking up b, 2b, 5b, 10b while the larger unit is close enough
+    const b = 10 ** Math.floor(Math.log10(c));
+    const steps = [
+        [2 * b, h],
+        [5 * b, h5],
+        [10 * b, h],
+    ];
+    let u = b;
+    for (const [next, w] of steps) {
+        if (next - c < w * (c - u))
+            u = next;
+        else
+            break;
+    }
+    // Step 3: integer multiples of the unit covering the data
+    const rho = 1e-10;
+    let s = Math.floor(lo / u + rho);
+    while (s * u > lo + rho * u)
+        s--;
+    while (!Number.isFinite(s * u))
+        s++;
+    let t = Math.ceil(up / u - rho);
+    while (t * u < up - rho * u)
+        t++;
+    while (!Number.isFinite(t * u))
+        t--;
+    // Step 4: at least minN cells
+    let k = Math.trunc(0.5 + t - s);
+    if (k < minN) {
+        const e = minN - k;
+        const half = Math.floor(e / 2);
+        const odd = e % 2;
+        if (lo === 0 && s === 0 && up !== 0)
+            t += e;
+        else if (up === 0 && t === 0 && lo !== 0)
+            s -= e;
+        else if (s >= 0) {
+            t += half;
+            s -= half + odd;
+        }
+        else {
+            s -= half;
+            t += half + odd;
+        }
+        k = minN;
+    }
+    // Step 5: end points (kept at the data ends when the multiples are within the rounding allowance)
+    const L = s * u < lo ? s * u : lo;
+    const U = t * u > up ? t * u : up;
+    // Step 6: the sequence, with values that are zero up to rounding set to 0
+    if (k <= 0)
+        return [L];
+    let out;
+    if (Number.isFinite(U - L))
+        out = seqLength(L, U, k + 1);
+    else {
+        // U - L overflows: step by U/k - L/k instead
+        const step = U / k - L / k;
+        out = Array.from({ length: k + 1 }, (_, i) => L + i * step);
+        out[k] = U;
+    }
+    const delta = U / k - L / k;
+    return out.map((v) => (Math.abs(v) < 1e-14 * delta ? 0 : v));
+}
+/** Smallest positive normal double */
+const DBL_MIN = 2.2250738585072014e-308;
+/** Rounding to 5 significant decimal digits (0 and non-finite values unchanged) */
+function round5(v) {
+    return v === 0 || !Number.isFinite(v) ? v : Number(v.toPrecision(5));
+}
+/** Suggested number of classes for the data `xs` (finite values) by the named rule */
+function classCount(xs, rule) {
+    const n = xs.length;
+    const [lo, hi] = range(xs);
+    const r = hi - lo;
+    switch (rule.toLowerCase()) {
+        case "sturges":
+            return Math.ceil(Math.log2(n) + 1);
+        case "scott": {
+            const h = 3.5 * sd(xs) * n ** (-1 / 3);
+            return h > 0 ? Math.max(1, Math.ceil(r / h)) : 1;
+        }
+        case "fd":
+        case "freedman-diaconis": {
+            const xr = xs.map(round5);
+            let h = 2 * IQR(xr);
+            for (let alpha = 1 / 8; h === 0 && alpha >= 1 / 512; alpha /= 2) {
+                const [qa, qb] = quantile(xr, [alpha, 1 - alpha]);
+                h = (qb - qa) / (1 - 2 * alpha);
+            }
+            if (h === 0)
+                h = 3.5 * sd(xs);
+            return h > 0 ? Math.ceil((r / h) * n ** (1 / 3)) : 1;
+        }
+        default:
+            throw new RangeError("unknown 'breaks' algorithm");
+    }
+}
+/** Reference cell size for the counting fuzz: median width (> 5 breaks), data range (<= 3), smallest positive width */
+function fuzzScale(br, dataRange) {
+    const widths = br.slice(1).map((v, i) => v - br[i]);
+    if (br.length > 5)
+        return median(widths);
+    if (br.length <= 3)
+        return dataRange;
+    return Math.min(...widths.filter((w) => w > 0));
+}
+/**
+ * Histogram counts. Equivalent to R's `hist(x, plot = FALSE)`: break points (by default pretty points over the range
+ * with about Sturges' number of cells), counts, densities and cell midpoints. Non-finite values are dropped.
+ *
+ * @example
+ * ```ts
+ * hist([1, 2, 2, 3, 3, 3, 4]).counts; // [3, 3, 1] for breaks [1, 2, 3, 4]
+ * ```
+ */
+export function hist(x, options = {}) {
+    const xs = Array.from(x).filter(Number.isFinite);
+    const n = xs.length;
+    const right = options.right ?? true;
+    let includeLowest = options.includeLowest ?? true;
+    const spec = options.breaks ?? "Sturges";
+    let br;
+    if (typeof spec !== "string" && typeof spec !== "number" && spec.length > 1) {
+        br = [...spec].sort((a, b) => a - b);
+    }
+    else {
+        includeLowest = true;
+        let k = typeof spec === "string" ? classCount(xs, spec) : typeof spec === "number" ? spec : spec[0];
+        if (!Number.isFinite(k) || k < 1)
+            throw new RangeError("invalid number of 'breaks'");
+        k = Math.min(k, 1e6);
+        const [lo, hi] = range(xs);
+        br = pretty([lo, hi], { n: k, minN: 1 });
+        for (let i = 1; i < br.length; i++) {
+            if (!(br[i] - br[i - 1] > 0))
+                throw new RangeError("'breaks' are not strictly increasing");
+        }
+    }
+    const nb = br.length;
+    // Breaks moved by a small tolerance so that values on a break up to rounding fall on the intended side
+    const [dlo, dhi] = n > 0 ? range(xs) : [0, 0];
+    const tau = 1e-7 * fuzzScale(br, dhi - dlo);
+    const f = br.map((v, i) => {
+        if (right)
+            return i === 0 && includeLowest ? v - tau : v + tau;
+        if (i < nb - 1)
+            return v - tau;
+        return includeLowest ? v + tau : v - tau;
+    });
+    const counts = new Array(Math.max(0, nb - 1)).fill(0);
+    let total = 0;
+    for (const v of xs) {
+        const cell = cellOf(v, f, right, includeLowest);
+        if (cell >= 0) {
+            counts[cell]++;
+            total++;
+        }
+    }
+    if (total < n)
+        throw new RangeError("some 'x' not counted; maybe 'breaks' do not span range of 'x'");
+    const density = counts.map((c, i) => c / (n * (br[i + 1] - br[i])));
+    const mids = counts.map((_, i) => 0.5 * (br[i + 1] + br[i]));
+    return { breaks: br, counts, density, mids };
+}
+/** 0-based cell of `v` among the (shifted) breaks `f`, or -1 when it is in no cell */
+function cellOf(v, f, right, includeLowest) {
+    const last = f.length - 1;
+    if (last < 1)
+        return -1;
+    if (right) {
+        if (v === f[0] && includeLowest)
+            return 0;
+        if (!(v > f[0] && v <= f[last]))
+            return -1;
+        // smallest j with v <= f[j]; the cell is j - 1
+        let a = 1;
+        let b = last;
+        while (a < b) {
+            const m = (a + b) >> 1;
+            if (v <= f[m])
+                b = m;
+            else
+                a = m + 1;
+        }
+        return a - 1;
+    }
+    if (v === f[last] && includeLowest)
+        return last - 1;
+    if (!(v >= f[0] && v < f[last]))
+        return -1;
+    // largest j with f[j] <= v; the cell is j
+    let a = 0;
+    let b = last - 1;
+    while (a < b) {
+        const m = (a + b + 1) >> 1;
+        if (f[m] <= v)
+            a = m;
+        else
+            b = m - 1;
+    }
+    return a;
+}
+/**
+ * Empirical distribution function of `x`: a function returning the fraction of values at or below its argument.
+ * Equivalent to R's `ecdf()`. `NaN` values are dropped.
+ *
+ * @example
+ * ```ts
+ * ecdf([3, 1, 2])(2); // 2/3
+ * ```
+ */
+export function ecdf(x) {
+    const s = Array.from(x)
+        .filter((v) => !Number.isNaN(v))
+        .sort((a, b) => a - b);
+    const n = s.length;
+    if (n < 1)
+        throw new RangeError("'x' must have 1 or more non-missing values");
+    return (q) => {
+        if (Number.isNaN(q))
+            return NaN;
+        let lo = 0;
+        let hi = n;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (s[mid] <= q)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo / n;
+    };
+}

package/dist/descriptive/moments.d.ts

@@ -0,0 +1,63 @@
+import { type NaRmOptions } from "./basic.js";
+import type { Sample } from "../htest/types.js";
+/** Options for {@link skewness} and {@link kurtosis}. */
+export interface MomentOptions {
+    /** e1071's type: 1, 2 or 3. Default `3`. */
+    type?: 1 | 2 | 3;
+}
+/**
+ * Sample skewness. Equivalent to `e1071::skewness()` (missing values dropped); `{ type: 1 }` is jStat's skewness.
+ */
+export declare function skewness(x: Sample, options?: MomentOptions): number;
+/**
+ * Sample excess kurtosis. Equivalent to `e1071::kurtosis()` (missing values dropped); `{ type: 1 }` is jStat's
+ * kurtosis.
+ */
+export declare function kurtosis(x: Sample, options?: MomentOptions): number;
+/**
+ * Geometric mean exp(mean(log x)). Equivalent to `DescTools::Gmean()`: NaN with a negative value, 0 with a zero.
+ */
+export declare function geometricMean(x: Sample, options?: NaRmOptions): number;
+/**
+ * The most frequent values (all of them, in increasing order) and their frequency. Equivalent to `DescTools::Mode()`
+ * (missing values dropped): `value` is `[NaN]` and `frequency` NaN when every value occurs once.
+ */
+export declare function modes(x: Sample): {
+    value: number[];
+    frequency: number;
+};
+/** Options for {@link meanAD}. */
+export interface MeanADOptions {
+    /** Centre: the mean (default) or `"median"`, or a number. */
+    center?: "mean" | "median" | number;
+}
+/** Mean absolute deviation from the centre. Equivalent to `DescTools::MeanAD()` (missing values dropped). */
+export declare function meanAD(x: Sample, options?: MeanADOptions): number;
+/** Options for {@link cv}. */
+export interface CvOptions extends NaRmOptions {
+    /** Small-sample correction. Default `false`. */
+    unbiased?: boolean;
+}
+/**
+ * Coefficient of variation sd / mean (sample standard deviation). Equivalent to `DescTools::CoefVar()`.
+ */
+export declare function cv(x: Sample, options?: CvOptions): number;
+/** Options for {@link scale}. */
+export interface ScaleOptions {
+    /** Subtract the column means (`true`, default), nothing (`false`) or the given values. */
+    center?: boolean | readonly number[];
+    /**
+     * Divide by the root mean square of each (centred) column, sqrt(sum v^2 / (n - 1)) (`true`, default: the standard
+     * deviation when centred), by nothing (`false`) or by the given values.
+     */
+    scale?: boolean | readonly number[];
+}
+/**
+ * Centre and scale the columns of a matrix (array of rows; a vector is one column). Equivalent to R's `scale()`:
+ * `center` and `scale` report the values used (R's attributes), when any.
+ */
+export declare function scale(x: Sample | readonly (readonly number[])[], options?: ScaleOptions): {
+    scaled: number[][];
+    center?: number[];
+    scale?: number[];
+};

package/dist/descriptive/moments.js

@@ -0,0 +1,158 @@
+// Shape and location summaries that R's base lacks, with the definitions of the packages they are checked against:
+// skewness and kurtosis (e1071, types 1 to 3), geometricMean, modes, meanAD and cv (DescTools' Gmean, Mode, MeanAD
+// and CoefVar). Also scale (R's base).
+//
+// Written for rStats.js from the published definitions (no ported code). With m_k the central moments (divisor n),
+// g1 = m3 / m2^1.5 and g2 = m4 / m2^2 - 3; e1071's type 1 is (g1, g2), type 2 the adjusted estimators of SAS and SPSS
+// (Joanes and Gill, The Statistician 47, 1998), type 3 (the default, as in MINITAB and BMDP) b1 = g1 ((n-1)/n)^1.5 and
+// b2 = (g2 + 3) ((n-1)/n)^2 - 3. The central moments are summed after subtracting the double-double mean.
+import { values } from "./basic.js";
+import { meanDD, mean as meanOf, variance } from "../internal/summary.js";
+import { median } from "./basic.js";
+/** Central sums sum (x - mean)^2, ^3, ^4 of values without NaN */
+function centralSums(xs) {
+    const m = meanDD(xs);
+    let s2 = 0;
+    let s3 = 0;
+    let s4 = 0;
+    for (const v of xs) {
+        const d = v - m[0] - m[1];
+        const d2 = d * d;
+        s2 += d2;
+        s3 += d2 * d;
+        s4 += d2 * d2;
+    }
+    return [s2, s3, s4];
+}
+function checkType(type) {
+    if (![1, 2, 3].includes(type))
+        throw new RangeError("Invalid 'type' argument.");
+}
+/**
+ * Sample skewness. Equivalent to `e1071::skewness()` (missing values dropped); `{ type: 1 }` is jStat's skewness.
+ */
+export function skewness(x, options = {}) {
+    const type = options.type ?? 3;
+    checkType(type);
+    const xs = values(x, true);
+    const n = xs.length;
+    const [s2, s3] = centralSums(xs);
+    const g1 = (Math.sqrt(n) * s3) / s2 ** 1.5;
+    if (type === 1)
+        return g1;
+    if (type === 2) {
+        if (n < 3)
+            throw new RangeError("Need at least 3 complete observations.");
+        return (g1 * Math.sqrt(n * (n - 1))) / (n - 2);
+    }
+    return g1 * (1 - 1 / n) ** 1.5;
+}
+/**
+ * Sample excess kurtosis. Equivalent to `e1071::kurtosis()` (missing values dropped); `{ type: 1 }` is jStat's
+ * kurtosis.
+ */
+export function kurtosis(x, options = {}) {
+    const type = options.type ?? 3;
+    checkType(type);
+    const xs = values(x, true);
+    const n = xs.length;
+    const [s2, , s4] = centralSums(xs);
+    const r = (n * s4) / (s2 * s2);
+    if (type === 1)
+        return r - 3;
+    if (type === 2) {
+        if (n < 4)
+            throw new RangeError("Need at least 4 complete observations.");
+        return (((n + 1) * (r - 3) + 6) * (n - 1)) / ((n - 2) * (n - 3));
+    }
+    return r * (1 - 1 / n) ** 2 - 3;
+}
+/**
+ * Geometric mean exp(mean(log x)). Equivalent to `DescTools::Gmean()`: NaN with a negative value, 0 with a zero.
+ */
+export function geometricMean(x, options = {}) {
+    const xs = values(x, options.naRm);
+    if (xs === undefined)
+        return NaN;
+    if (xs.some((v) => v < 0))
+        return NaN;
+    if (xs.includes(0))
+        return 0;
+    return Math.exp(meanOf(xs.map(Math.log)));
+}
+/**
+ * The most frequent values (all of them, in increasing order) and their frequency. Equivalent to `DescTools::Mode()`
+ * (missing values dropped): `value` is `[NaN]` and `frequency` NaN when every value occurs once.
+ */
+export function modes(x) {
+    const xs = values(x, true);
+    const counts = new Map();
+    for (const v of xs)
+        counts.set(v === 0 ? 0 : v, (counts.get(v === 0 ? 0 : v) ?? 0) + 1);
+    let best = 0;
+    for (const c of counts.values())
+        best = Math.max(best, c);
+    if (best <= 1)
+        return { value: [NaN], frequency: NaN };
+    const value = [...counts.entries()].filter(([, c]) => c === best).map(([v]) => v);
+    return { value: value.sort((a, b) => a - b), frequency: best };
+}
+/** Mean absolute deviation from the centre. Equivalent to `DescTools::MeanAD()` (missing values dropped). */
+export function meanAD(x, options = {}) {
+    const xs = values(x, true);
+    const c = options.center ?? "mean";
+    const center = c === "mean" ? meanOf(xs) : c === "median" ? median(xs) : c;
+    return meanOf(xs.map((v) => Math.abs(v - center)));
+}
+/**
+ * Coefficient of variation sd / mean (sample standard deviation). Equivalent to `DescTools::CoefVar()`.
+ */
+export function cv(x, options = {}) {
+    const xs = values(x, options.naRm);
+    if (xs === undefined)
+        return NaN;
+    const n = xs.length;
+    let res = Math.sqrt(variance(xs)) / meanOf(xs);
+    if (options.unbiased)
+        res *= 1 - 1 / (4 * (n - 1)) + (res * res) / n + 1 / (2 * (n - 1) ** 2);
+    return res;
+}
+/**
+ * Centre and scale the columns of a matrix (array of rows; a vector is one column). Equivalent to R's `scale()`:
+ * `center` and `scale` report the values used (R's attributes), when any.
+ */
+export function scale(x, options = {}) {
+    const rows = x.length > 0 && Array.isArray(x[0]) ? x.map((r) => [...r]) : Array.from(x, (v) => [v]);
+    const nc = rows[0]?.length ?? 0;
+    const col = (j) => rows.map((r) => r[j]);
+    const result = { scaled: rows };
+    const c = options.center ?? true;
+    if (c !== false) {
+        const center = c === true ? Array.from({ length: nc }, (_, j) => meanOf(col(j).filter((v) => !Number.isNaN(v)))) : [...c];
+        if (center.length !== nc)
+            throw new RangeError("length of 'center' must equal the number of columns of 'x'");
+        for (const r of rows)
+            for (let j = 0; j < nc; j++)
+                r[j] = r[j] - center[j];
+        result.center = center;
+    }
+    const s = options.scale ?? true;
+    if (s !== false) {
+        const sc = s === true
+            ? Array.from({ length: nc }, (_, j) => {
+                const v = col(j).filter((t) => !Number.isNaN(t));
+                let ss = 0;
+                for (const t of v)
+                    ss += t * t;
+                return Math.sqrt(ss / Math.max(1, v.length - 1));
+            })
+            : [...s];
+        if (sc.length !== nc)
+            throw new RangeError("length of 'scale' must equal the number of columns of 'x'");
+        for (const r of rows)
+            for (let j = 0; j < nc; j++)
+                r[j] = r[j] / sc[j];
+        result.scale = sc;
+    }
+    return result;
+}