@svgrid/enterprise 3.0.1 → 3.0.3

package/dist/sheet/packs/math-stats.js

@@ -0,0 +1,372 @@
+/**
+ * More of Excel's math, statistics and reference functions: rounding to a
+ * multiple, logs, integers, order statistics, variances, the *IFS
+ * aggregates, simple regression, CHOOSE and the range dimensions.
+ *
+ * Rounding to a multiple is where floating point bites: 1.5 / 0.1 is
+ * 15.000000000000002, which CEILING would happily read as 16. `snap` treats a
+ * quotient within a hair of an integer as that integer, and `tidy` trims
+ * the drift off the product, so `=CEILING(1.5, 0.1)` is 1.5 and not 1.6.
+ */
+import { err } from '../ast.js';
+import { toNumber, numericOnly, multiCriteriaHits, criteriaPairs } from '../coerce.js';
+const nth = (a, i) => a.args[i]?.[0] ?? '';
+const num = (a, i) => toNumber(nth(a, i));
+function opt(a, i, fallback) {
+    const v = a.args[i]?.[0];
+    return v === undefined || v === '' ? fallback : toNumber(v);
+}
+const snap = (q) => (Math.abs(q - Math.round(q)) < 1e-9 ? Math.round(q) : q);
+const tidy = (x) => (Number.isFinite(x) ? Number(x.toPrecision(15)) : x);
+/** Round half away from zero, which is what Excel does and Math.round does not
+ *  for negatives. */
+const roundHalfAway = (x) => Math.sign(x) * Math.round(Math.abs(x));
+function sorted(values) {
+    return numericOnly(values).sort((x, y) => x - y);
+}
+/** PERCENTILE.INC: linear interpolation between the order statistics. */
+function percentileInc(values, k) {
+    if (!values.length || k < 0 || k > 1)
+        return err('#NUM!');
+    const pos = k * (values.length - 1);
+    const lo = Math.floor(pos);
+    const hi = Math.ceil(pos);
+    return values[lo] + (values[hi] - values[lo]) * (pos - lo);
+}
+/** PERCENTILE.EXC: the same idea over n+1 slots, undefined at the ends. */
+function percentileExc(values, k) {
+    const n = values.length;
+    if (!n || k <= 0 || k >= 1)
+        return err('#NUM!');
+    const pos = k * (n + 1) - 1;
+    if (pos < 0 || pos > n - 1)
+        return err('#NUM!');
+    const lo = Math.floor(pos);
+    const hi = Math.ceil(pos);
+    return values[lo] + (values[hi] - values[lo]) * (pos - lo);
+}
+function variance(values, sample) {
+    const n = values.length;
+    if (n < (sample ? 2 : 1))
+        return err('#DIV/0!');
+    const mean = values.reduce((x, y) => x + y, 0) / n;
+    const ss = values.reduce((acc, v) => acc + (v - mean) ** 2, 0);
+    return ss / (sample ? n - 1 : n);
+}
+const stdev = (values, sample) => {
+    const v = variance(values, sample);
+    return typeof v === 'number' ? Math.sqrt(v) : v;
+};
+/** The (x, y) pairs where both sides are numbers, as Excel pairs its
+ *  known_y's and known_x's, dropping the rest. */
+function pairs(ys, xs) {
+    if (ys.length !== xs.length)
+        return null;
+    const out = [];
+    for (let i = 0; i < ys.length; i += 1) {
+        const y = ys[i];
+        const x = xs[i];
+        if (typeof y === 'number' && typeof x === 'number')
+            out.push([x, y]);
+    }
+    return out;
+}
+const isLine = (r) => typeof r === 'object' && r !== null && 'slope' in r;
+function regression(ys, xs) {
+    const p = pairs(ys, xs);
+    if (!p)
+        return err('#N/A');
+    const n = p.length;
+    if (n < 2)
+        return err('#DIV/0!');
+    const mx = p.reduce((s, [x]) => s + x, 0) / n;
+    const my = p.reduce((s, [, y]) => s + y, 0) / n;
+    let sxx = 0;
+    let sxy = 0;
+    for (const [x, y] of p) {
+        sxx += (x - mx) ** 2;
+        sxy += (x - mx) * (y - my);
+    }
+    if (sxx === 0)
+        return err('#DIV/0!');
+    const slope = sxy / sxx;
+    return { slope, intercept: my - slope * mx };
+}
+function gcd(x, y) {
+    let a = Math.abs(x);
+    let b = Math.abs(y);
+    while (b) {
+        const t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+function ifsAggregate(a, pick) {
+    const target = a.args[0] ?? [];
+    const hits = multiCriteriaHits(criteriaPairs(a.args, 1)).map((i) => target[i] ?? '');
+    return pick(numericOnly(hits));
+}
+function ceilingLegacy(number, significance) {
+    if (significance === 0)
+        return 0;
+    if (number > 0 && significance < 0)
+        return err('#NUM!');
+    return tidy(Math.ceil(snap(number / significance)) * significance);
+}
+function floorLegacy(number, significance) {
+    if (significance === 0)
+        return err('#DIV/0!');
+    if (number > 0 && significance < 0)
+        return err('#NUM!');
+    return tidy(Math.floor(snap(number / significance)) * significance);
+}
+/** CEILING.MATH / FLOOR.MATH: the sign of `significance` is ignored, and
+ *  `mode` says which way a negative number goes: toward zero by default for
+ *  CEILING.MATH and away from it for FLOOR.MATH, the other way when set. */
+function ceilingMath(number, significance, mode) {
+    const sig = Math.abs(significance);
+    if (sig === 0)
+        return 0;
+    const q = snap(number / sig);
+    const away = number < 0 && mode !== 0;
+    return tidy((away ? Math.floor(q) : Math.ceil(q)) * sig);
+}
+function floorMath(number, significance, mode) {
+    const sig = Math.abs(significance);
+    if (sig === 0)
+        return 0;
+    const q = snap(number / sig);
+    const towardZero = number < 0 && mode !== 0;
+    return tidy((towardZero ? Math.ceil(q) : Math.floor(q)) * sig);
+}
+function mode(values) {
+    const counts = new Map();
+    let best = null;
+    let bestCount = 1;
+    for (const v of values) {
+        const c = (counts.get(v) ?? 0) + 1;
+        counts.set(v, c);
+        if (c > bestCount) {
+            best = v;
+            bestCount = c;
+        }
+    }
+    return best === null ? err('#N/A') : best;
+}
+function forecast(a) {
+    const r = regression(a.args[1] ?? [], a.args[2] ?? []);
+    if (!isLine(r))
+        return r;
+    return r.intercept + r.slope * num(a, 0);
+}
+export const MATH_STATS_FUNCTIONS = {
+    // ---- Math ------------------------------------------------------------
+    PRODUCT: (a) => numericOnly(a.flat).reduce((x, y) => x * y, 1),
+    SUMSQ: (a) => numericOnly(a.flat).reduce((x, y) => x + y * y, 0),
+    // SUMPRODUCT: the ranges must be the same shape; a cell that is not a
+    // number counts as zero, as in Excel.
+    SUMPRODUCT: (a) => {
+        const lists = a.args;
+        if (!lists.length)
+            return 0;
+        const n = lists[0].length;
+        if (lists.some((l) => l.length !== n))
+            return err('#VALUE!');
+        let total = 0;
+        for (let i = 0; i < n; i += 1) {
+            let product = 1;
+            for (const l of lists) {
+                const v = l[i];
+                product *= typeof v === 'number' ? v : 0;
+            }
+            total += product;
+        }
+        return total;
+    },
+    CEILING: (a) => ceilingLegacy(num(a, 0), num(a, 1)),
+    'CEILING.MATH': (a) => ceilingMath(num(a, 0), opt(a, 1, 1), opt(a, 2, 0)),
+    FLOOR: (a) => floorLegacy(num(a, 0), num(a, 1)),
+    'FLOOR.MATH': (a) => floorMath(num(a, 0), opt(a, 1, 1), opt(a, 2, 0)),
+    MROUND: (a) => {
+        const n = num(a, 0);
+        const m = num(a, 1);
+        if (m === 0)
+            return 0;
+        if ((n > 0 && m < 0) || (n < 0 && m > 0))
+            return err('#NUM!');
+        return tidy(roundHalfAway(snap(n / m)) * m);
+    },
+    TRUNC: (a) => {
+        const digits = Math.trunc(opt(a, 1, 0));
+        const f = Math.pow(10, digits);
+        return tidy(Math.trunc(snap(num(a, 0) * f)) / f);
+    },
+    LOG: (a) => {
+        const n = num(a, 0);
+        const base = opt(a, 1, 10);
+        if (n <= 0 || base <= 0)
+            return err('#NUM!');
+        if (base === 1)
+            return err('#DIV/0!');
+        return tidy(Math.log(n) / Math.log(base));
+    },
+    LOG10: (a) => {
+        const n = num(a, 0);
+        return n <= 0 ? err('#NUM!') : Math.log10(n);
+    },
+    LN: (a) => {
+        const n = num(a, 0);
+        return n <= 0 ? err('#NUM!') : Math.log(n);
+    },
+    EXP: (a) => Math.exp(num(a, 0)),
+    PI: () => Math.PI,
+    RAND: () => Math.random(),
+    RANDBETWEEN: (a) => {
+        const lo = Math.ceil(num(a, 0));
+        const hi = Math.floor(num(a, 1));
+        if (lo > hi)
+            return err('#NUM!');
+        return lo + Math.floor(Math.random() * (hi - lo + 1));
+    },
+    SIGN: (a) => Math.sign(num(a, 0)),
+    // EVEN and ODD round away from zero to the next even or odd integer.
+    EVEN: (a) => {
+        const n = num(a, 0);
+        if (n === 0)
+            return 0;
+        const up = Math.ceil(Math.abs(n));
+        return Math.sign(n) * (up % 2 === 0 ? up : up + 1);
+    },
+    ODD: (a) => {
+        const n = num(a, 0);
+        if (n === 0)
+            return 1;
+        const up = Math.ceil(Math.abs(n));
+        return Math.sign(n) * (up % 2 === 1 ? up : up + 1);
+    },
+    QUOTIENT: (a) => {
+        const d = num(a, 1);
+        return d === 0 ? err('#DIV/0!') : Math.trunc(num(a, 0) / d);
+    },
+    GCD: (a) => {
+        const ns = numericOnly(a.flat).map(Math.trunc);
+        if (ns.some((n) => n < 0))
+            return err('#NUM!');
+        return ns.reduce((x, y) => gcd(x, y), 0);
+    },
+    LCM: (a) => {
+        const ns = numericOnly(a.flat).map(Math.trunc);
+        if (ns.some((n) => n < 0))
+            return err('#NUM!');
+        if (ns.some((n) => n === 0))
+            return 0;
+        return ns.reduce((x, y) => (x * y) / gcd(x, y), 1);
+    },
+    FACT: (a) => {
+        const n = Math.trunc(num(a, 0));
+        if (n < 0 || n > 170)
+            return err('#NUM!');
+        let out = 1;
+        for (let i = 2; i <= n; i += 1)
+            out *= i;
+        return out;
+    },
+    ISEVEN: (a) => Math.trunc(num(a, 0)) % 2 === 0,
+    ISODD: (a) => Math.trunc(num(a, 0)) % 2 !== 0,
+    // ---- Statistics ------------------------------------------------------
+    LARGE: (a) => {
+        const values = sorted(a.args[0] ?? []);
+        const k = Math.trunc(num(a, 1));
+        if (k < 1 || k > values.length)
+            return err('#NUM!');
+        return values[values.length - k];
+    },
+    SMALL: (a) => {
+        const values = sorted(a.args[0] ?? []);
+        const k = Math.trunc(num(a, 1));
+        if (k < 1 || k > values.length)
+            return err('#NUM!');
+        return values[k - 1];
+    },
+    PERCENTILE: (a) => percentileInc(sorted(a.args[0] ?? []), num(a, 1)),
+    'PERCENTILE.INC': (a) => percentileInc(sorted(a.args[0] ?? []), num(a, 1)),
+    'PERCENTILE.EXC': (a) => percentileExc(sorted(a.args[0] ?? []), num(a, 1)),
+    QUARTILE: (a) => {
+        const q = Math.trunc(num(a, 1));
+        return q < 0 || q > 4 ? err('#NUM!') : percentileInc(sorted(a.args[0] ?? []), q / 4);
+    },
+    'QUARTILE.INC': (a) => {
+        const q = Math.trunc(num(a, 1));
+        return q < 0 || q > 4 ? err('#NUM!') : percentileInc(sorted(a.args[0] ?? []), q / 4);
+    },
+    'QUARTILE.EXC': (a) => {
+        const q = Math.trunc(num(a, 1));
+        return q < 1 || q > 3 ? err('#NUM!') : percentileExc(sorted(a.args[0] ?? []), q / 4);
+    },
+    VAR: (a) => variance(numericOnly(a.flat), true),
+    'VAR.S': (a) => variance(numericOnly(a.flat), true),
+    'VAR.P': (a) => variance(numericOnly(a.flat), false),
+    VARP: (a) => variance(numericOnly(a.flat), false),
+    'STDEV.S': (a) => stdev(numericOnly(a.flat), true),
+    'STDEV.P': (a) => stdev(numericOnly(a.flat), false),
+    STDEVP: (a) => stdev(numericOnly(a.flat), false),
+    // MODE: the most frequent number, the first one at that count when tied;
+    // #N/A when nothing repeats, as Excel gives.
+    MODE: (a) => mode(numericOnly(a.flat)),
+    'MODE.SNGL': (a) => mode(numericOnly(a.flat)),
+    GEOMEAN: (a) => {
+        const values = numericOnly(a.flat);
+        if (!values.length || values.some((v) => v <= 0))
+            return err('#NUM!');
+        return Math.exp(values.reduce((s, v) => s + Math.log(v), 0) / values.length);
+    },
+    AVERAGEIFS: (a) => ifsAggregate(a, (ns) => (ns.length ? ns.reduce((x, y) => x + y, 0) / ns.length : err('#DIV/0!'))),
+    MAXIFS: (a) => ifsAggregate(a, (ns) => (ns.length ? Math.max(...ns) : 0)),
+    MINIFS: (a) => ifsAggregate(a, (ns) => (ns.length ? Math.min(...ns) : 0)),
+    CORREL: (a) => {
+        const p = pairs(a.args[0] ?? [], a.args[1] ?? []);
+        if (!p)
+            return err('#N/A');
+        const n = p.length;
+        if (n < 2)
+            return err('#DIV/0!');
+        const mx = p.reduce((s, [x]) => s + x, 0) / n;
+        const my = p.reduce((s, [, y]) => s + y, 0) / n;
+        let sxx = 0;
+        let syy = 0;
+        let sxy = 0;
+        for (const [x, y] of p) {
+            sxx += (x - mx) ** 2;
+            syy += (y - my) ** 2;
+            sxy += (x - mx) * (y - my);
+        }
+        if (sxx === 0 || syy === 0)
+            return err('#DIV/0!');
+        return sxy / Math.sqrt(sxx * syy);
+    },
+    SLOPE: (a) => {
+        const r = regression(a.args[0] ?? [], a.args[1] ?? []);
+        return isLine(r) ? r.slope : r;
+    },
+    INTERCEPT: (a) => {
+        const r = regression(a.args[0] ?? [], a.args[1] ?? []);
+        return isLine(r) ? r.intercept : r;
+    },
+    // FORECAST(x, known_y's, known_x's): the line through the pairs, read at x.
+    FORECAST: forecast,
+    'FORECAST.LINEAR': forecast,
+    // ---- Reference -------------------------------------------------------
+    CHOOSE: (a) => {
+        const index = Math.trunc(num(a, 0));
+        if (index < 1 || index >= a.args.length)
+            return err('#VALUE!');
+        return a.args[index][0] ?? '';
+    },
+    ROWS: (a) => a.grids[0]?.length ?? 1,
+    COLUMNS: (a) => a.grids[0]?.[0]?.length ?? 1,
+    ISNONTEXT: (a) => {
+        const v = a.flat[0] ?? '';
+        return typeof v !== 'string' || v === '';
+    },
+};

package/dist/sheet/packs/special.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The special functions every statistical distribution is built out of:
+ * the log gamma, the two regularised incomplete integrals, and the error
+ * function that falls out of the first of them.
+ *
+ * Not exported from the package. Distributions call these; nothing else
+ * should need them.
+ *
+ * Accuracy is the point here rather than speed. A spreadsheet evaluates one
+ * of these per cell, not per frame, and a model that disagrees with Excel
+ * in the fourth decimal is a support ticket. Every routine below iterates
+ * to a relative tolerance well inside the fifteen digits a double carries,
+ * so the answers round to Excel's published examples.
+ */
+/** log(gamma(x)) for x > 0. Reflection carries the negative half. */
+export declare function lgamma(x: number): number;
+/** gamma(x) itself, sign included, for the places Excel exposes it. */
+export declare function gammaFn(x: number): number;
+/** The regularised lower incomplete gamma, P(a, x), in [0, 1]. */
+export declare function gammaP(a: number, x: number): number;
+/** The regularised upper incomplete gamma, Q(a, x) = 1 - P(a, x). */
+export declare function gammaQ(a: number, x: number): number;
+/** The regularised incomplete beta, I_x(a, b), in [0, 1]. */
+export declare function betaI(a: number, b: number, x: number): number;
+/** The error function, which is P(1/2, x^2) carrying x's sign. */
+export declare function erf(x: number): number;
+/** The complementary error function, taken from Q where that is the
+ *  accurate half, so erfc(20) does not cancel to zero. */
+export declare function erfc(x: number): number;
+/** The standard normal's cumulative distribution. */
+export declare function normalCdf(z: number): number;
+/** The standard normal's density. */
+export declare function normalPdf(z: number): number;
+/**
+ * Invert a cumulative distribution by bisection over a bracket that is
+ * widened until it holds the answer.
+ *
+ * Bisection rather than Newton on purpose: every distribution here is
+ * monotone in x, so bisection cannot diverge, and fifty rounds already
+ * carries more digits than a spreadsheet shows. A Newton step would be
+ * quicker and would need a derivative per distribution and a fallback for
+ * the flat tails, which is three ways to be subtly wrong for no gain.
+ */
+export declare function invertCdf(cdf: (x: number) => number, p: number, lo: number, hi: number): number;

package/dist/sheet/packs/special.js

@@ -0,0 +1,187 @@
+/**
+ * The special functions every statistical distribution is built out of:
+ * the log gamma, the two regularised incomplete integrals, and the error
+ * function that falls out of the first of them.
+ *
+ * Not exported from the package. Distributions call these; nothing else
+ * should need them.
+ *
+ * Accuracy is the point here rather than speed. A spreadsheet evaluates one
+ * of these per cell, not per frame, and a model that disagrees with Excel
+ * in the fourth decimal is a support ticket. Every routine below iterates
+ * to a relative tolerance well inside the fifteen digits a double carries,
+ * so the answers round to Excel's published examples.
+ */
+/** Lanczos g = 7, n = 9. Good to about fifteen digits over the half plane. */
+const LANCZOS = [
+    0.99999999999980993, 676.5203681218851, -1259.1392167224028,
+    771.32342877765313, -176.61502916214059, 12.507343278686905,
+    -0.13857109526572012, 9.9843695780195716e-6, 1.5056327351493116e-7,
+];
+/** log(gamma(x)) for x > 0. Reflection carries the negative half. */
+export function lgamma(x) {
+    if (x < 0.5) {
+        // Reflection: gamma(x) gamma(1-x) = pi / sin(pi x)
+        return Math.log(Math.PI / Math.abs(Math.sin(Math.PI * x))) - lgamma(1 - x);
+    }
+    const z = x - 1;
+    let a = LANCZOS[0];
+    const t = z + 7.5;
+    for (let i = 1; i < 9; i += 1)
+        a += LANCZOS[i] / (z + i);
+    return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(a);
+}
+/** gamma(x) itself, sign included, for the places Excel exposes it. */
+export function gammaFn(x) {
+    if (x < 0.5)
+        return Math.PI / (Math.sin(Math.PI * x) * gammaFn(1 - x));
+    return Math.exp(lgamma(x));
+}
+const ITMAX = 300;
+const EPS = 1e-15;
+const FPMIN = 1e-300;
+/** P(a, x) by its series, which converges quickly while x < a + 1. */
+function gammaSeries(a, x) {
+    let ap = a;
+    let sum = 1 / a;
+    let del = sum;
+    for (let n = 0; n < ITMAX; n += 1) {
+        ap += 1;
+        del *= x / ap;
+        sum += del;
+        if (Math.abs(del) < Math.abs(sum) * EPS)
+            break;
+    }
+    return sum * Math.exp(-x + a * Math.log(x) - lgamma(a));
+}
+/** Q(a, x) by its continued fraction, which takes over once x >= a + 1. */
+function gammaContinued(a, x) {
+    let b = x + 1 - a;
+    let c = 1 / FPMIN;
+    let d = 1 / b;
+    let h = d;
+    for (let i = 1; i <= ITMAX; i += 1) {
+        const an = -i * (i - a);
+        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;
+    }
+    return Math.exp(-x + a * Math.log(x) - lgamma(a)) * h;
+}
+/** The regularised lower incomplete gamma, P(a, x), in [0, 1]. */
+export function gammaP(a, x) {
+    if (x <= 0 || a <= 0)
+        return 0;
+    return x < a + 1 ? gammaSeries(a, x) : 1 - gammaContinued(a, x);
+}
+/** The regularised upper incomplete gamma, Q(a, x) = 1 - P(a, x). */
+export function gammaQ(a, x) {
+    if (x <= 0 || a <= 0)
+        return 1;
+    return x < a + 1 ? 1 - gammaSeries(a, x) : gammaContinued(a, x);
+}
+/** The continued fraction behind the incomplete beta, by Lentz's method. */
+function betaContinued(a, b, x) {
+    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 <= ITMAX; m += 1) {
+        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;
+}
+/** The regularised incomplete beta, I_x(a, b), in [0, 1]. */
+export function betaI(a, b, x) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    const front = Math.exp(lgamma(a + b) - lgamma(a) - lgamma(b) + a * Math.log(x) + b * Math.log(1 - x));
+    // The fraction converges fast on one side of the mode only; past it the
+    // symmetry I_x(a, b) = 1 - I_(1-x)(b, a) puts us back on the fast side.
+    return x < (a + 1) / (a + b + 2)
+        ? (front * betaContinued(a, b, x)) / a
+        : 1 - (front * betaContinued(b, a, 1 - x)) / b;
+}
+/** The error function, which is P(1/2, x^2) carrying x's sign. */
+export function erf(x) {
+    return x < 0 ? -gammaP(0.5, x * x) : gammaP(0.5, x * x);
+}
+/** The complementary error function, taken from Q where that is the
+ *  accurate half, so erfc(20) does not cancel to zero. */
+export function erfc(x) {
+    return x < 0 ? 1 + gammaP(0.5, x * x) : gammaQ(0.5, x * x);
+}
+/** The standard normal's cumulative distribution. */
+export function normalCdf(z) {
+    return 0.5 * erfc(-z / Math.SQRT2);
+}
+/** The standard normal's density. */
+export function normalPdf(z) {
+    return Math.exp((-z * z) / 2) / Math.sqrt(2 * Math.PI);
+}
+/**
+ * Invert a cumulative distribution by bisection over a bracket that is
+ * widened until it holds the answer.
+ *
+ * Bisection rather than Newton on purpose: every distribution here is
+ * monotone in x, so bisection cannot diverge, and fifty rounds already
+ * carries more digits than a spreadsheet shows. A Newton step would be
+ * quicker and would need a derivative per distribution and a fallback for
+ * the flat tails, which is three ways to be subtly wrong for no gain.
+ */
+export function invertCdf(cdf, p, lo, hi) {
+    let a = lo;
+    let b = hi;
+    // Widen, in case the caller's bracket was optimistic.
+    for (let i = 0; i < 200 && cdf(b) < p; i += 1)
+        b = b === 0 ? 1 : b * 2;
+    for (let i = 0; i < 200 && cdf(a) > p; i += 1)
+        a = a === 0 ? -1 : a * 2;
+    for (let i = 0; i < 200; i += 1) {
+        const mid = (a + b) / 2;
+        if (b - a < Math.abs(mid) * 1e-14 + 1e-300)
+            return mid;
+        if (cdf(mid) < p)
+            a = mid;
+        else
+            b = mid;
+    }
+    return (a + b) / 2;
+}

package/dist/sheet/packs/stats-dist.d.ts

@@ -0,0 +1,2 @@
+import type { SheetFunction } from '../functions.js';
+export declare const STATS_DIST_FUNCTIONS: Record<string, SheetFunction>;