@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/descriptive/quantile.d.ts

@@ -0,0 +1,50 @@
+import { type NaRmOptions } from "./basic.js";
+import type { Sample } from "../htest/types.js";
+/** Options for {@link quantile}. */
+export interface QuantileOptions extends NaRmOptions {
+    /** Hyndman and Fan's definition, 1 to 9. Default `7`. */
+    type?: number;
+}
+/**
+ * Sample quantiles. Equivalent to R's `quantile()` (with `names = FALSE`).
+ *
+ * @param x The data.
+ * @param probs Probabilities in [0, 1]. Default `[0, 0.25, 0.5, 0.75, 1]`. A single number gives a single number.
+ * @param options `type` (1 to 9, default 7) and `naRm`.
+ *
+ * @example
+ * ```ts
+ * quantile([1, 2, 3, 4, 5, 6], 0.25);              // 2.25 (type 7)
+ * quantile([1, 2, 3, 4, 5, 6], 0.25, { type: 9 }); // 1.9375 (jStat's quantiles)
+ * ```
+ */
+export declare function quantile(x: Sample, probs: number, options?: QuantileOptions): number;
+export declare function quantile(x: Sample, probs?: readonly number[], options?: QuantileOptions): number[];
+/** Interquartile range, the difference of the 0.75 and 0.25 quantiles. Equivalent to R's `IQR()`. */
+export declare function IQR(x: Sample, options?: QuantileOptions): number;
+/**
+ * Tukey's five-number summary (minimum, lower hinge, median, upper hinge, maximum). Equivalent to R's `fivenum()`;
+ * `NaN` values are dropped.
+ */
+export declare function fivenum(x: Sample): [number, number, number, number, number];
+/** Options for {@link mad}. */
+export interface MadOptions extends NaRmOptions {
+    /** Centre. Default: the median. */
+    center?: number;
+    /** Scale factor. Default `1.4826` (consistent for the normal standard deviation). */
+    constant?: number;
+    /** For an even count, take the lower of the two middle absolute deviations (the "lo-median"). */
+    low?: boolean;
+    /** For an even count, take the higher one (the "hi-median"). */
+    high?: boolean;
+}
+/**
+ * Median absolute deviation, scaled. Equivalent to R's `mad()`.
+ *
+ * @example
+ * ```ts
+ * mad([1, 2, 3, 4, 100]);                  // 1.4826
+ * mad([1, 2, 3, 4, 100], { constant: 1 }); // 1 (jStat's meddev)
+ * ```
+ */
+export declare function mad(x: Sample, options?: MadOptions): number;

package/dist/descriptive/quantile.js

@@ -0,0 +1,131 @@
+// Sample quantiles and robust summaries: R's quantile (types 1 to 9), IQR, fivenum and mad.
+//
+// Written for rStats.js. The nine quantile definitions are those of Hyndman and Fan, "Sample quantiles in
+// statistical packages", The American Statistician 50, 1996, numbered as in that paper and in R's ?quantile. Details
+// that the paper leaves open follow R's documented behaviour and observed output: type 7 interpolates at
+// 1 + (n - 1) p only between order statistics that differ (so that equal infinite neighbours are not turned into
+// NaN); the other types take the integer part of the position after enlarging it by a relative 4 eps, so that a
+// position meant to be an integer is not lost to rounding, and treat a fractional part below 4 eps as 0. fivenum is
+// Tukey's five-number summary; mad scales by 1.4826 by default.
+import { median, values } from "./basic.js";
+/** Relative fuzz for the positions of types 1 to 6, 8 and 9 */
+const FUZZ = 4 * Number.EPSILON;
+/** (a, b) of the continuous types 4 to 6, 8 and 9 (Hyndman and Fan's p(k) = (k - a) / (n + 1 - a - b)) */
+const CONTINUOUS = {
+    4: [0, 1],
+    5: [0.5, 0.5],
+    6: [0, 0],
+    8: [1 / 3, 1 / 3],
+    9: [3 / 8, 3 / 8],
+};
+/** Quantile of type `type` at probability `p` (in [0, 1]) of the ascending values `s` (non-empty) */
+function quantileOfSorted(s, p, type) {
+    const n = s.length;
+    // order statistic j (1-based), extended by the end values outside 1..n
+    const at = (j) => s[Math.min(Math.max(j, 1), n) - 1];
+    if (type === 7) {
+        const m = 1 + (n - 1) * p;
+        const j = Math.floor(m);
+        const lower = at(j);
+        const upper = at(Math.ceil(m));
+        if (m > j && upper !== lower) {
+            const g = m - j;
+            return (1 - g) * lower + g * upper;
+        }
+        return lower;
+    }
+    let j;
+    let g;
+    if (type <= 3) {
+        const m = type === 3 ? n * p - 0.5 : n * p;
+        j = Math.floor(m * (1 + FUZZ));
+        if (type === 1)
+            g = m > j ? 1 : 0;
+        else if (type === 2)
+            g = m > j ? 1 : 0.5;
+        else
+            g = m !== j || Math.abs(j % 2) === 1 ? 1 : 0;
+    }
+    else {
+        const [a, b] = CONTINUOUS[type];
+        const m = a + p * (n + 1 - a - b);
+        j = Math.floor(m * (1 + FUZZ));
+        g = m - j;
+        if (Math.abs(g) < FUZZ)
+            g = 0;
+    }
+    const lower = at(j);
+    const upper = at(j + 1);
+    if (g === 1)
+        return upper;
+    if (g > 0 && g < 1 && lower !== upper)
+        return (1 - g) * lower + g * upper;
+    return lower;
+}
+export function quantile(x, probs = [0, 0.25, 0.5, 0.75, 1], options = {}) {
+    const type = options.type ?? 7;
+    if (!(Number.isInteger(type) && type >= 1 && type <= 9))
+        throw new RangeError("'type' must be an integer in 1..9");
+    const xs = values(x, options.naRm);
+    if (xs === undefined)
+        throw new RangeError("missing values and NaN's not allowed if 'na.rm' is FALSE");
+    const sorted = xs.sort((a, b) => a - b);
+    const ps = typeof probs === "number" ? [probs] : Array.from(probs);
+    const tol = 100 * Number.EPSILON;
+    if (ps.some((p) => p < -tol || p > 1 + tol))
+        throw new RangeError("'probs' outside [0,1]");
+    const out = ps.map((p) => {
+        if (Number.isNaN(p) || sorted.length === 0)
+            return NaN;
+        return quantileOfSorted(sorted, Math.min(Math.max(p, 0), 1), type);
+    });
+    return typeof probs === "number" ? out[0] : out;
+}
+/** Interquartile range, the difference of the 0.75 and 0.25 quantiles. Equivalent to R's `IQR()`. */
+export function IQR(x, options = {}) {
+    const [a, b] = quantile(x, [0.25, 0.75], options);
+    return b - a;
+}
+/**
+ * Tukey's five-number summary (minimum, lower hinge, median, upper hinge, maximum). Equivalent to R's `fivenum()`;
+ * `NaN` values are dropped.
+ */
+export function fivenum(x) {
+    const s = Array.from(x)
+        .filter((v) => !Number.isNaN(v))
+        .sort((a, b) => a - b);
+    const n = s.length;
+    if (n === 0)
+        return [NaN, NaN, NaN, NaN, NaN];
+    const n4 = Math.floor((n + 3) / 2) / 2;
+    const d = [1, n4, (n + 1) / 2, n + 1 - n4, n];
+    return d.map((v) => 0.5 * (s[Math.floor(v) - 1] + s[Math.ceil(v) - 1]));
+}
+/**
+ * Median absolute deviation, scaled. Equivalent to R's `mad()`.
+ *
+ * @example
+ * ```ts
+ * mad([1, 2, 3, 4, 100]);                  // 1.4826
+ * mad([1, 2, 3, 4, 100], { constant: 1 }); // 1 (jStat's meddev)
+ * ```
+ */
+export function mad(x, options = {}) {
+    const xs = values(x, options.naRm);
+    if (xs === undefined)
+        return NaN;
+    const center = options.center ?? median(xs);
+    const constant = options.constant ?? 1.4826;
+    const low = options.low ?? false;
+    const high = options.high ?? false;
+    const dev = xs.map((v) => Math.abs(v - center));
+    const n = dev.length;
+    if ((low || high) && n % 2 === 0) {
+        if (low && high)
+            throw new RangeError("'low' and 'high' cannot be both TRUE");
+        const k = n / 2 + (high ? 1 : 0);
+        const s = dev.sort((a, b) => a - b);
+        return constant * s[k - 1];
+    }
+    return constant * median(dev);
+}

package/dist/descriptive/rank.d.ts

@@ -0,0 +1,23 @@
+import type { Sample } from "../htest/types.js";
+/** How ties are ranked, as R's `ties.method`. */
+export type TiesMethod = "average" | "first" | "last" | "random" | "max" | "min";
+/** Options for {@link rank}. */
+export interface RankOptions {
+    /** Ranks of tied values. Default `"average"`. */
+    tiesMethod?: TiesMethod;
+    /**
+     * Missing values: `"last"` (default, R's `na.last = TRUE`) ranks them after the others, `"first"` (`FALSE`) before
+     * them, `"keep"` leaves them `NaN`.
+     */
+    naLast?: "last" | "first" | "keep";
+}
+/**
+ * Sample ranks. Equivalent to R's `rank()`.
+ *
+ * @example
+ * ```ts
+ * rank([10, 20, 20, 30]);                         // [1, 2.5, 2.5, 4]
+ * rank([10, 20, 20, 30], { tiesMethod: "min" });  // [1, 2, 2, 4]
+ * ```
+ */
+export declare function rank(x: Sample, options?: RankOptions): number[];

package/dist/descriptive/rank.js

@@ -0,0 +1,72 @@
+// Ranks with R's tie methods and placement of missing values (R's rank).
+//
+// Written for rStats.js (no ported code). Missing values (NaN) are ranked apart: kept as NaN, or given the ranks after
+// (or before) all the others in their order of appearance. "random" breaks ties with R's uniform random numbers, one
+// per non-missing value, so the result follows setSeed as R's follows set.seed.
+import { runif } from "../random/continuous.js";
+/** Ranks of values without NaN */
+function rankValues(x, method) {
+    const n = x.length;
+    const r = new Array(n);
+    if (method === "first" || method === "last" || method === "random") {
+        const u = method === "random" ? runif(n) : [];
+        const idx = Array.from({ length: n }, (_, i) => i);
+        idx.sort((a, b) => {
+            const d = x[a] - x[b];
+            if (d !== 0)
+                return d;
+            if (method === "first")
+                return a - b;
+            if (method === "last")
+                return b - a;
+            return u[a] - u[b] || a - b;
+        });
+        idx.forEach((i, k) => (r[i] = k + 1));
+        return r;
+    }
+    const idx = Array.from({ length: n }, (_, i) => i).sort((a, b) => x[a] - x[b] || a - b);
+    let i = 0;
+    while (i < n) {
+        let j = i;
+        while (j + 1 < n && x[idx[j + 1]] === x[idx[i]])
+            j++;
+        const v = method === "average" ? (i + j + 2) / 2 : method === "min" ? i + 1 : j + 1;
+        for (let k = i; k <= j; k++)
+            r[idx[k]] = v;
+        i = j + 1;
+    }
+    return r;
+}
+/**
+ * Sample ranks. Equivalent to R's `rank()`.
+ *
+ * @example
+ * ```ts
+ * rank([10, 20, 20, 30]);                         // [1, 2.5, 2.5, 4]
+ * rank([10, 20, 20, 30], { tiesMethod: "min" });  // [1, 2, 2, 4]
+ * ```
+ */
+export function rank(x, options = {}) {
+    const method = options.tiesMethod ?? "average";
+    if (!["average", "first", "last", "random", "max", "min"].includes(method)) {
+        throw new RangeError(`invalid tiesMethod "${method}"`);
+    }
+    const naLast = options.naLast ?? "last";
+    const xs = Array.from(x);
+    const present = xs.filter((v) => !Number.isNaN(v));
+    const r = rankValues(present, method);
+    const nMissing = xs.length - present.length;
+    const out = [];
+    let k = 0;
+    let m = 0;
+    for (const v of xs) {
+        if (Number.isNaN(v)) {
+            m++;
+            out.push(naLast === "keep" ? NaN : naLast === "last" ? present.length + m : m);
+        }
+        else {
+            out.push(naLast === "first" ? r[k++] + nMissing : r[k++]);
+        }
+    }
+    return out;
+}

package/dist/descriptive/table.d.ts

@@ -0,0 +1,54 @@
+import type { Sample } from "../htest/types.js";
+/**
+ * Counts of the integers 1..nbins in `bin` (values truncated towards 0; others and NaN are not counted).
+ * Equivalent to R's `tabulate()`; `nbins` defaults to max(1, bin).
+ */
+export declare function tabulate(bin: Sample, nbins?: number): number[];
+/** Options for {@link table}. */
+export interface TableOptions {
+    /** Count missing values: `"no"` (default), `"ifany"` (when there are some) or `"always"`. */
+    useNA?: "no" | "ifany" | "always";
+}
+/**
+ * Frequency table of the distinct values. Equivalent to R's `table()` for one numeric vector: `values` in increasing
+ * order (NaN last when counted) with their `counts`.
+ *
+ * @example
+ * ```ts
+ * table([3, 1, 3, 2, 3]); // { values: [1, 2, 3], counts: [1, 1, 3] }
+ * ```
+ */
+export declare function table(x: Sample, options?: TableOptions): {
+    values: number[];
+    counts: number[];
+};
+/** Distinct values in order of first appearance (one NaN at most). Equivalent to R's `unique()`. */
+export declare function unique(x: Sample): number[];
+/** Options for {@link cut}. */
+export interface CutOptions {
+    /** Intervals closed on the right, (a, b] (default `true`); otherwise [a, b). */
+    right?: boolean;
+    /** Close the first interval on the left (or the last on the right when `right` is false). Default `false`. */
+    includeLowest?: boolean;
+}
+/**
+ * Interval numbers (1-based) of the values, or NaN outside the breaks. Equivalent to R's `cut(..., labels = FALSE)`.
+ *
+ * @param breaks The break points, or a number of intervals (at least 2): then equal intervals over the range of `x`,
+ *   widened by 1/1000 of the range at each end, as R does.
+ */
+export declare function cut(x: Sample, breaks: number | readonly number[], options?: CutOptions): number[];
+/** Options for {@link findInterval}. */
+export interface FindIntervalOptions {
+    /** Treat the last interval as closed on the right (with `leftOpen`, the first as closed on the left). */
+    rightmostClosed?: boolean;
+    /** Map results below 1 to 1 and above N - 1 to N - 1. */
+    allInside?: boolean;
+    /** Intervals (v_i, v_(i+1)] instead of [v_i, v_(i+1)). */
+    leftOpen?: boolean;
+}
+/**
+ * For each value, the number of break points at or below it (the interval index). Equivalent to R's
+ * `findInterval()`; `vec` must be non-decreasing.
+ */
+export declare function findInterval(x: Sample, vec: readonly number[], options?: FindIntervalOptions): number[];

package/dist/descriptive/table.js

@@ -0,0 +1,160 @@
+// Counting and binning: R's tabulate, table (for one vector), unique, cut (codes) and findInterval.
+//
+// Written for rStats.js. cut's generation of breaks from a number of intervals follows R's behaviour: equal spacing
+// over the range, ends widened by 1/1000 of the range, and a special case for a zero range. NaN stands for R's NA:
+// unique keeps one NaN; table counts it according to `useNA`; cut and findInterval return NaN for it.
+import { seqLength } from "../internal/seq.js";
+/**
+ * Counts of the integers 1..nbins in `bin` (values truncated towards 0; others and NaN are not counted).
+ * Equivalent to R's `tabulate()`; `nbins` defaults to max(1, bin).
+ */
+export function tabulate(bin, nbins) {
+    const b = Array.from(bin).map((v) => Math.trunc(v));
+    const nb = nbins ?? Math.max(1, ...b.filter((v) => !Number.isNaN(v)));
+    const out = new Array(Math.max(0, nb)).fill(0);
+    for (const v of b)
+        if (v >= 1 && v <= nb)
+            out[v - 1]++;
+    return out;
+}
+/**
+ * Frequency table of the distinct values. Equivalent to R's `table()` for one numeric vector: `values` in increasing
+ * order (NaN last when counted) with their `counts`.
+ *
+ * @example
+ * ```ts
+ * table([3, 1, 3, 2, 3]); // { values: [1, 2, 3], counts: [1, 1, 3] }
+ * ```
+ */
+export function table(x, options = {}) {
+    const useNA = options.useNA ?? "no";
+    const xs = Array.from(x);
+    const map = new Map();
+    let nas = 0;
+    for (const v of xs) {
+        if (Number.isNaN(v))
+            nas++;
+        else
+            map.set(v === 0 ? 0 : v, (map.get(v === 0 ? 0 : v) ?? 0) + 1);
+    }
+    const values = Array.from(map.keys()).sort((a, b) => a - b);
+    const counts = values.map((v) => map.get(v));
+    if (useNA === "always" || (useNA === "ifany" && nas > 0)) {
+        values.push(NaN);
+        counts.push(nas);
+    }
+    return { values, counts };
+}
+/** Distinct values in order of first appearance (one NaN at most). Equivalent to R's `unique()`. */
+export function unique(x) {
+    const seen = new Set();
+    const out = [];
+    for (const v of Array.from(x)) {
+        const k = v === 0 ? 0 : v; // -0 and 0 are the same value
+        if (!seen.has(k)) {
+            seen.add(k);
+            out.push(v);
+        }
+    }
+    return out;
+}
+/**
+ * Interval numbers (1-based) of the values, or NaN outside the breaks. Equivalent to R's `cut(..., labels = FALSE)`.
+ *
+ * @param breaks The break points, or a number of intervals (at least 2): then equal intervals over the range of `x`,
+ *   widened by 1/1000 of the range at each end, as R does.
+ */
+export function cut(x, breaks, options = {}) {
+    const right = options.right ?? true;
+    const includeLowest = options.includeLowest ?? false;
+    const xs = Array.from(x);
+    let br;
+    if (typeof breaks === "number" || breaks.length === 1) {
+        const k = typeof breaks === "number" ? breaks : breaks[0];
+        if (!(k >= 2))
+            throw new RangeError("invalid number of intervals");
+        const nb = Math.trunc(k + 1);
+        const finite = xs.filter((v) => !Number.isNaN(v));
+        const lo = Math.min(...finite);
+        const hi = Math.max(...finite);
+        let dx = hi - lo;
+        if (dx === 0) {
+            dx = lo !== 0 ? Math.abs(lo) : 1;
+            br = seqLength(lo - dx / 1000, hi + dx / 1000, nb);
+        }
+        else {
+            br = seqLength(lo, hi, nb);
+            br[0] = lo - dx / 1000;
+            br[nb - 1] = hi + dx / 1000;
+        }
+    }
+    else
+        br = [...breaks].sort((a, b) => a - b);
+    if (new Set(br).size < br.length)
+        throw new RangeError("'breaks' are not unique");
+    return binCode(xs, br, right, includeLowest);
+}
+/** Interval codes as R's .bincode */
+function binCode(xs, br, right, includeLowest) {
+    const nb = br.length;
+    return xs.map((v) => {
+        if (Number.isNaN(v))
+            return NaN;
+        // first index i with br[i] >= v (right) or br[i] > v (left)
+        let lo = 0;
+        let hi = nb;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (right ? br[mid] < v : br[mid] <= v)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        let code = lo; // v in (br[code - 1], br[code]] (right) or [br[code - 1], br[code]) (left)
+        if (includeLowest) {
+            if (right && v === br[0])
+                code = 1;
+            if (!right && v === br[nb - 1])
+                code = nb - 1;
+        }
+        return code >= 1 && code <= nb - 1 ? code : NaN;
+    });
+}
+/**
+ * For each value, the number of break points at or below it (the interval index). Equivalent to R's
+ * `findInterval()`; `vec` must be non-decreasing.
+ */
+export function findInterval(x, vec, options = {}) {
+    const n = vec.length;
+    for (let i = 1; i < n; i++) {
+        if (!(vec[i] >= vec[i - 1]))
+            throw new RangeError("'vec' must be sorted non-decreasingly and not contain NAs");
+    }
+    if (vec.some(Number.isNaN))
+        throw new RangeError("'vec' must be sorted non-decreasingly and not contain NAs");
+    const { rightmostClosed = false, allInside = false, leftOpen = false } = options;
+    return Array.from(x).map((v) => {
+        if (Number.isNaN(v))
+            return NaN;
+        // count of vec <= v (or < v when left-open)
+        let lo = 0;
+        let hi = n;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (leftOpen ? vec[mid] < v : vec[mid] <= v)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        let i = lo;
+        if (rightmostClosed && n > 0) {
+            if (!leftOpen && i === n && v === vec[n - 1])
+                i = n - 1;
+            if (leftOpen && i === 0 && v === vec[0])
+                i = 1;
+        }
+        if (allInside)
+            i = Math.min(Math.max(i, 1), n - 1);
+        return i;
+    });
+}

package/dist/descriptive.js

@@ -0,0 +1,2 @@
+/*! rStats.js 0.6.1 | MIT License | includes code ported from SciPy, Boost.Math, statsmodels, LAPACK and others: see THIRD_PARTY_NOTICES.md at https://github.com/numero-uno-jpn/rStats.js */
+import{j as V}from"./chunks/chunk-NAYDS7CL.js";import{d as T,e as O}from"./chunks/chunk-AJYQNFXK.js";import"./chunks/chunk-XM2TVD63.js";import{a as q,b as Z,c as $,d as H,e as W,f as G,g as v,h as x,i as L,j as J,k as K,l as Y,m as ee,n as te,o as ne,p as re,q as oe,r as se,s as ie,t as ae,u as fe}from"./chunks/chunk-Y4IZV7XK.js";import{a as j,b as ce,c as le,d as ue,e as me,f as he}from"./chunks/chunk-NOCEAM44.js";import{d as P}from"./chunks/chunk-7NK4SA6B.js";import"./chunks/chunk-QNAIK4PY.js";import"./chunks/chunk-UGUQYWRQ.js";var B=4*Number.EPSILON,de={4:[0,1],5:[.5,.5],6:[0,0],8:[1/3,1/3],9:[3/8,3/8]};function Ne(t,e,r){let s=t.length,f=i=>t[Math.min(Math.max(i,1),s)-1];if(r===7){let i=1+(s-1)*e,d=Math.floor(i),u=f(d),w=f(Math.ceil(i));if(i>d&&w!==u){let b=i-d;return(1-b)*u+b*w}return u}let o,n;if(r<=3){let i=r===3?s*e-.5:s*e;o=Math.floor(i*(1+B)),r===1?n=i>o?1:0:r===2?n=i>o?1:.5:n=i!==o||Math.abs(o%2)===1?1:0}else{let[i,d]=de[r],u=i+e*(s+1-i-d);o=Math.floor(u*(1+B)),n=u-o,Math.abs(n)<B&&(n=0)}let a=f(o),c=f(o+1);return n===1?c:n>0&&n<1&&a!==c?(1-n)*a+n*c:a}function F(t,e=[0,.25,.5,.75,1],r={}){let s=r.type??7;if(!(Number.isInteger(s)&&s>=1&&s<=9))throw new RangeError("'type' must be an integer in 1..9");let f=q(t,r.naRm);if(f===void 0)throw new RangeError("missing values and NaN's not allowed if 'na.rm' is FALSE");let o=f.sort((i,d)=>i-d),n=typeof e=="number"?[e]:Array.from(e),a=100*Number.EPSILON;if(n.some(i=>i<-a||i>1+a))throw new RangeError("'probs' outside [0,1]");let c=n.map(i=>Number.isNaN(i)||o.length===0?NaN:Ne(o,Math.min(Math.max(i,0),1),s));return typeof e=="number"?c[0]:c}function D(t,e={}){let[r,s]=F(t,[.25,.75],e);return s-r}function pe(t){let e=Array.from(t).filter(o=>!Number.isNaN(o)).sort((o,n)=>o-n),r=e.length;if(r===0)return[NaN,NaN,NaN,NaN,NaN];let s=Math.floor((r+3)/2)/2;return[1,s,(r+1)/2,r+1-s,r].map(o=>.5*(e[Math.floor(o)-1]+e[Math.ceil(o)-1]))}function ge(t,e={}){let r=q(t,e.naRm);if(r===void 0)return NaN;let s=e.center??x(r),f=e.constant??1.4826,o=e.low??!1,n=e.high??!1,a=r.map(i=>Math.abs(i-s)),c=a.length;if((o||n)&&c%2===0){if(o&&n)throw new RangeError("'low' and 'high' cannot be both TRUE");let i=c/2+(n?1:0),d=a.sort((u,w)=>u-w);return f*d[i-1]}return f*x(a)}function we(t,e){let r=t.length,s=new Array(r);if(e==="first"||e==="last"||e==="random"){let n=e==="random"?V(r):[],a=Array.from({length:r},(c,i)=>i);return a.sort((c,i)=>{let d=t[c]-t[i];return d!==0?d:e==="first"?c-i:e==="last"?i-c:n[c]-n[i]||c-i}),a.forEach((c,i)=>s[c]=i+1),s}let f=Array.from({length:r},(n,a)=>a).sort((n,a)=>t[n]-t[a]||n-a),o=0;for(;o<r;){let n=o;for(;n+1<r&&t[f[n+1]]===t[f[o]];)n++;let a=e==="average"?(o+n+2)/2:e==="min"?o+1:n+1;for(let c=o;c<=n;c++)s[f[c]]=a;o=n+1}return s}function I(t,e={}){let r=e.tiesMethod??"average";if(!["average","first","last","random","max","min"].includes(r))throw new RangeError(`invalid tiesMethod "${r}"`);let s=e.naLast??"last",f=Array.from(t),o=f.filter(u=>!Number.isNaN(u)),n=we(o,r),a=f.length-o.length,c=[],i=0,d=0;for(let u of f)Number.isNaN(u)?(d++,c.push(s==="keep"?NaN:s==="last"?o.length+d:d)):c.push(s==="first"?n[i++]+a:n[i++]);return c}var be=["pearson","kendall","spearman"],Me=["all.obs","complete.obs","pairwise.complete.obs","everything","na.or.complete"];function C(t,e,r,s){if(t===void 0)return r;if(e.includes(t))return t;let f=e.filter(o=>o.startsWith(t));if(t.length===0||f.length!==1)throw new RangeError(`invalid '${s}' argument`);return f[0]}function R(t){return t.length>0&&Array.isArray(t[0])}function Q(t){if(!R(t))return[Array.from(t)];let e=t[0].length;return Array.from({length:e},(r,s)=>t.map(f=>f[s]))}function U(t,e,r,s){let f=C(r.method,be,"pearson","method"),o=C(r.use,Me,"everything","use");if(e===void 0&&!R(t))throw new TypeError("supply both 'x' and 'y' or a matrix-like 'x'");let n=Q(t),a=e===void 0?n:Q(e),c=n[0]?.length??0;if(a.some(h=>h.length!==c))throw new RangeError("incompatible dimensions");let i=[...n,...a];if(o==="all.obs"&&i.some(h=>h.some(Number.isNaN)))throw new RangeError("missing observations in cov/cor");if(!s&&o==="pairwise.complete.obs"&&f!=="pearson")throw new RangeError("cannot handle 'pairwise.complete.obs'");let d;if((o==="complete.obs"||o==="na.or.complete")&&(d=Array.from({length:c},(h,m)=>i.every(l=>!Number.isNaN(l[m]))),!d.some(Boolean))){if(o==="complete.obs")throw new RangeError("no complete element pairs");return e===void 0||R(t)||R(e)?n.map(()=>a.map(()=>NaN)):NaN}let u=h=>{let m=d===void 0?h:h.filter((l,N)=>d[N]);return f==="spearman"&&o!=="pairwise.complete.obs"?I(m,{naLast:"keep"}):m},w=n.map(u),b=e===void 0?w:a.map(u),y=(h,m)=>{let l=h,N=m;if(o==="pairwise.complete.obs"){let p=h.map((k,M)=>!Number.isNaN(k)&&!Number.isNaN(m[M]));l=h.filter((k,M)=>p[M]),N=m.filter((k,M)=>p[M]),f==="spearman"&&(l=I(l),N=I(N))}else if(l.some(Number.isNaN)||N.some(Number.isNaN))return NaN;return f==="kendall"?s?O(l,N).tau:2*O(l,N).s:s?T(l,N)[0]:P(l,N)},E=w.map(h=>b.map(m=>y(h,m)));return s&&e===void 0&&o!=="pairwise.complete.obs"&&E.forEach((h,m)=>h[m]=1),e!==void 0&&!R(t)&&!R(e)?E[0][0]:E}function ke(t,e,r={}){return e!==void 0&&!Array.isArray(e)&&!ArrayBuffer.isView(e)?U(t,void 0,e,!1):U(t,e,r,!1)}function ye(t,e,r={}){return e!==void 0&&!Array.isArray(e)&&!ArrayBuffer.isView(e)?U(t,void 0,e,!0):U(t,e,r,!0)}function z(t,e={}){let r=Array.from(t).filter(Number.isFinite);if(r.length===0)return[];let s=e.n??5,f=e.minN??Math.floor(s/3),o=e.shrinkSml??.75,n=e.highUBias??1.5,a=e.u5Bias??.5+1.5*n,c=1/0,i=-1/0;for(let g of r)g<c&&(c=g),g>i&&(i=g);let d=i-c,u,w;if(d===0&&i===0)u=1,w=!0;else{u=Math.max(Math.abs(c),Math.abs(i));let A=(1+(a>=1.5*n+.5?1/(1+n):1.5/(1+a)))*Math.max(1,s)*Number.EPSILON;w=d<u*A*3}w?(u>10&&(u=9+u/10),u*=o,f>1&&(u/=f)):(u=s>1?d/s:d,d===1/0&&s>=2&&(u=i/s-c/s));let b=2**-20*Ae;u<b?u=b:u>Number.MAX_VALUE/1.25&&(u=Number.MAX_VALUE/1.25);let y=10**Math.floor(Math.log10(u)),E=[[2*y,n],[5*y,a],[10*y,n]],h=y;for(let[g,A]of E)if(g-u<A*(u-h))h=g;else break;let m=1e-10,l=Math.floor(c/h+m);for(;l*h>c+m*h;)l--;for(;!Number.isFinite(l*h);)l++;let N=Math.ceil(i/h-m);for(;N*h<i-m*h;)N++;for(;!Number.isFinite(N*h);)N--;let p=Math.trunc(.5+N-l);if(p<f){let g=f-p,A=Math.floor(g/2),_=g%2;c===0&&l===0&&i!==0?N+=g:i===0&&N===0&&c!==0?l-=g:l>=0?(N+=A,l-=A+_):(l-=A,N+=A+_),p=f}let k=l*h<c?l*h:c,M=N*h>i?N*h:i;if(p<=0)return[k];let S;if(Number.isFinite(M-k))S=j(k,M,p+1);else{let g=M/p-k/p;S=Array.from({length:p+1},(A,_)=>k+_*g),S[p]=M}let X=M/p-k/p;return S.map(g=>Math.abs(g)<1e-14*X?0:g)}var Ae=22250738585072014e-324;function Ee(t){return t===0||!Number.isFinite(t)?t:Number(t.toPrecision(5))}function xe(t,e){let r=t.length,[s,f]=L(t),o=f-s;switch(e.toLowerCase()){case"sturges":return Math.ceil(Math.log2(r)+1);case"scott":{let n=3.5*v(t)*r**-.3333333333333333;return n>0?Math.max(1,Math.ceil(o/n)):1}case"fd":case"freedman-diaconis":{let n=t.map(Ee),a=2*D(n);for(let c=1/8;a===0&&c>=1/512;c/=2){let[i,d]=F(n,[c,1-c]);a=(d-i)/(1-2*c)}return a===0&&(a=3.5*v(t)),a>0?Math.ceil(o/a*r**(1/3)):1}default:throw new RangeError("unknown 'breaks' algorithm")}}function Re(t,e){let r=t.slice(1).map((s,f)=>s-t[f]);return t.length>5?x(r):t.length<=3?e:Math.min(...r.filter(s=>s>0))}function Le(t,e={}){let r=Array.from(t).filter(Number.isFinite),s=r.length,f=e.right??!0,o=e.includeLowest??!0,n=e.breaks??"Sturges",a;if(typeof n!="string"&&typeof n!="number"&&n.length>1)a=[...n].sort((m,l)=>m-l);else{o=!0;let m=typeof n=="string"?xe(r,n):typeof n=="number"?n:n[0];if(!Number.isFinite(m)||m<1)throw new RangeError("invalid number of 'breaks'");m=Math.min(m,1e6);let[l,N]=L(r);a=z([l,N],{n:m,minN:1});for(let p=1;p<a.length;p++)if(!(a[p]-a[p-1]>0))throw new RangeError("'breaks' are not strictly increasing")}let c=a.length,[i,d]=s>0?L(r):[0,0],u=1e-7*Re(a,d-i),w=a.map((m,l)=>f?l===0&&o?m-u:m+u:l<c-1?m-u:o?m+u:m-u),b=new Array(Math.max(0,c-1)).fill(0),y=0;for(let m of r){let l=Ie(m,w,f,o);l>=0&&(b[l]++,y++)}if(y<s)throw new RangeError("some 'x' not counted; maybe 'breaks' do not span range of 'x'");let E=b.map((m,l)=>m/(s*(a[l+1]-a[l]))),h=b.map((m,l)=>.5*(a[l+1]+a[l]));return{breaks:a,counts:b,density:E,mids:h}}function Ie(t,e,r,s){let f=e.length-1;if(f<1)return-1;if(r){if(t===e[0]&&s)return 0;if(!(t>e[0]&&t<=e[f]))return-1;let a=1,c=f;for(;a<c;){let i=a+c>>1;t<=e[i]?c=i:a=i+1}return a-1}if(t===e[f]&&s)return f-1;if(!(t>=e[0]&&t<e[f]))return-1;let o=0,n=f-1;for(;o<n;){let a=o+n+1>>1;e[a]<=t?o=a:n=a-1}return o}function Se(t){let e=Array.from(t).filter(s=>!Number.isNaN(s)).sort((s,f)=>s-f),r=e.length;if(r<1)throw new RangeError("'x' must have 1 or more non-missing values");return s=>{if(Number.isNaN(s))return NaN;let f=0,o=r;for(;f<o;){let n=f+o>>1;e[n]<=s?f=n+1:o=n}return f/r}}export{D as IQR,ye as cor,ke as cov,Y as cummax,ee as cummin,K as cumprod,J as cumsum,me as cut,ae as cv,te as diff,Se as ecdf,he as findInterval,pe as fivenum,oe as geometricMean,Le as hist,re as kurtosis,ge as mad,H as mean,ie as meanAD,x as median,se as modes,z as pretty,$ as prod,F as quantile,L as range,I as rank,fe as scale,v as sd,ne as skewness,Z as sum,le as table,ce as tabulate,ue as unique,G as variance,W as weightedMean};

package/dist/distributions/arcsine.d.ts

@@ -0,0 +1,24 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/** Limits of the arcsine distribution. */
+export interface ArcsineParams {
+    /** Lower limit. Default `0`. */
+    a?: number;
+    /** Upper limit. Default `1`. */
+    b?: number;
+}
+export declare function darcsine1(x: number, a: number, b: number, log: boolean): number;
+export declare function parcsine1(q: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+export declare function qarcsine1(p: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the arcsine distribution on (a, b), f(x) = 1 / (pi sqrt((x - a)(b - x))). R has no arcsine
+ * distribution; this equals `dbeta((x - a) / (b - a), 0.5, 0.5) / (b - a)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `a` and `b` (see {@link ArcsineParams}) and `log` (see {@link DensityOptions}).
+ */
+export declare function darcsine<T extends Vectorizable>(x: T, options?: ArcsineParams & DensityOptions): VectorResult<T>;
+/** Distribution function of the arcsine distribution on (a, b): `pbeta((q - a) / (b - a), 0.5, 0.5)`. */
+export declare function parcsine<T extends Vectorizable>(q: T, options?: ArcsineParams & TailOptions): VectorResult<T>;
+/** Quantile function of the arcsine distribution on (a, b): `a + (b - a) qbeta(p, 0.5, 0.5)`. */
+export declare function qarcsine<T extends Vectorizable>(p: T, options?: ArcsineParams & TailOptions): VectorResult<T>;

package/dist/distributions/arcsine.js

@@ -0,0 +1,73 @@
+// Arcsine distribution darcsine / parcsine / qarcsine on (a, b): the beta(1/2, 1/2) distribution moved to (a, b).
+//
+// Written for rStats.js (no ported code). With z = (x - a) / (b - a): f(x) = dbeta(z, 1/2, 1/2) / (b - a)
+// = 1 / (pi sqrt((x - a)(b - x))), P[X <= x] = pbeta(z, 1/2, 1/2) = (2/pi) asin(sqrt(z)), and
+// q(p) = a + (b - a) qbeta(p, 1/2, 1/2).
+// Near b, 1 - z would cancel once z is rounded, so the density takes x - a and b - x directly, and in the upper half
+// the distribution function and the quantile use the mirrored variable (b - x) / (b - a) with the tails swapped
+// (the beta(1/2, 1/2) distribution is symmetric).
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { ddAdd, ddLog, twoSum } from "../special/dd.js";
+import { pbeta1, qbeta1 } from "./beta.js";
+const valid = (a, b) => Number.isFinite(a) && Number.isFinite(b) && a < b;
+export function darcsine1(x, a, b, log) {
+    if (Number.isNaN(x) || !valid(a, b))
+        return NaN;
+    if (x < a || x > b)
+        return d0(log);
+    if (x === a || x === b)
+        return Infinity;
+    if (!log)
+        return 1 / (Math.PI * Math.sqrt(x - a) * Math.sqrt(b - x)); // sqrt of each: the product can over- or underflow
+    // -log(pi) - (log(x - a) + log(b - x)) / 2 in double-double from the exact differences (the log of a density near 1
+    // would turn its rounding into a large relative error)
+    const l = ddAdd(ddLog(twoSum(x, -a)), ddLog(twoSum(b, -x)));
+    return -LOGPI_DD[0] - 0.5 * l[0] - (LOGPI_DD[1] + 0.5 * l[1]);
+}
+const LOGPI_DD = [1.1447298858494002, 1.0265951162707826e-17];
+export function parcsine1(q, a, b, lowerTail, logP) {
+    if (Number.isNaN(q) || !valid(a, b))
+        return NaN;
+    if (q <= a)
+        return dt0(lowerTail, logP);
+    if (q >= b)
+        return dt1(lowerTail, logP);
+    const w = b - a;
+    if (q - a <= b - q)
+        return pbeta1((q - a) / w, 0.5, 0.5, lowerTail, logP);
+    return pbeta1((b - q) / w, 0.5, 0.5, !lowerTail, logP);
+}
+export function qarcsine1(p, a, b, lowerTail, logP) {
+    if (Number.isNaN(p) || !valid(a, b))
+        return NaN;
+    const bd = quantileBoundaries(p, a, b, lowerTail, logP);
+    if (bd !== undefined)
+        return bd;
+    const z = qbeta1(p, 0.5, 0.5, lowerTail, logP);
+    if (z <= 0.5)
+        return a + (b - a) * z;
+    // upper half: from b, with the mirrored probability (z near 1 has lost the digits of 1 - z)
+    return b - (b - a) * qbeta1(p, 0.5, 0.5, !lowerTail, logP);
+}
+/**
+ * Density of the arcsine distribution on (a, b), f(x) = 1 / (pi sqrt((x - a)(b - x))). R has no arcsine
+ * distribution; this equals `dbeta((x - a) / (b - a), 0.5, 0.5) / (b - a)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `a` and `b` (see {@link ArcsineParams}) and `log` (see {@link DensityOptions}).
+ */
+export function darcsine(x, options = {}) {
+    const { a = 0, b = 1, log = false } = options;
+    return vectorize(x, (v) => darcsine1(v, a, b, log));
+}
+/** Distribution function of the arcsine distribution on (a, b): `pbeta((q - a) / (b - a), 0.5, 0.5)`. */
+export function parcsine(q, options = {}) {
+    const { a = 0, b = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => parcsine1(v, a, b, lowerTail, logP));
+}
+/** Quantile function of the arcsine distribution on (a, b): `a + (b - a) qbeta(p, 0.5, 0.5)`. */
+export function qarcsine(p, options = {}) {
+    const { a = 0, b = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qarcsine1(v, a, b, lowerTail, logP));
+}

package/dist/distributions/invgamma.d.ts

@@ -0,0 +1,29 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/** Scale parameter of the inverse gamma distribution. */
+export interface InvgammaParams {
+    /** Scale (the rate of the gamma distribution of 1/X). Default `1`. */
+    beta?: number;
+}
+export declare function dinvgamma1(x: number, alpha: number, beta: number, log: boolean): number;
+export declare function pinvgamma1(q: number, alpha: number, beta: number, lowerTail: boolean, logP: boolean): number;
+export declare function qinvgamma1(p: number, alpha: number, beta: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the inverse gamma distribution. Equivalent to `extraDistr::dinvgamma(x, alpha, beta = 1, log = FALSE)`:
+ * f(x) = beta^alpha x^(-alpha-1) exp(-beta/x) / Gamma(alpha).
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param alpha - Shape parameter.
+ * @param options - `beta` (see {@link InvgammaParams}) and `log` (see {@link DensityOptions}).
+ */
+export declare function dinvgamma<T extends Vectorizable>(x: T, alpha: number, options?: InvgammaParams & DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the inverse gamma distribution. Equivalent to
+ * `extraDistr::pinvgamma(q, alpha, beta = 1, lower.tail = TRUE, log.p = FALSE)`.
+ */
+export declare function pinvgamma<T extends Vectorizable>(q: T, alpha: number, options?: InvgammaParams & TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the inverse gamma distribution. Equivalent to
+ * `extraDistr::qinvgamma(p, alpha, beta = 1, lower.tail = TRUE, log.p = FALSE)`.
+ */
+export declare function qinvgamma<T extends Vectorizable>(p: T, alpha: number, options?: InvgammaParams & TailOptions): VectorResult<T>;