@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/special/igam.js

@@ -9,6 +9,7 @@
 // - The prefactor x^a e^-x / Gamma(a) is computed with Loader's dpoisRaw (= x^a e^-x / Gamma(a+1)),
 //   to avoid cancellation in the log for large a and x
 import { erfc } from "./erf.js";
+import { SPLITTER } from "./dd.js";
 import { MACHEP } from "./constants.js";
 import { lgamma, lgamma1p } from "./gamma.js";
 import { IGAM_ASYMP_COEFF_D, IGAM_ASYMP_COEFF_K, IGAM_ASYMP_COEFF_N } from "./igamAsympCoeff.js";
@@ -34,7 +35,10 @@ function igamSeriesBoth(a, x) {
     const d = dpoisRawBoth(a, x);
     return [d[0] + Math.log(ans), d[1] * ans];
 }
-function igamSeriesSum(a, x) {
+/** sum_n x^n / ((a + 1) ... (a + n)): P(a, x) = x^a e^-x / Gamma(a + 1) times this */
+export function igamSeriesSum(a, x) {
+    if (a > 1000 && x > 0.97 * a)
+        return igamSeriesSumDD(a, x);
     let r = a;
     let c = 1;
     let ans = 1;
@@ -47,6 +51,56 @@ function igamSeriesSum(a, x) {
     }
     return ans;
 }
+/**
+ * igamSeriesSum in double-double, for large a with x above 0.97 a (the mpmath audit needs it from about there; below,
+ * the series is short enough for double). The terms then shrink slowly (ratio x / (a + n) close to 1, thousands
+ * of terms), and in double precision the roundings of the ratios, correlated between neighbouring terms, add up to
+ * 2e-14 relative; stopping at c <= eps ans also leaves out a tail of up to c (a + n) / (a + n - x). Written out on
+ * scalars (no arrays), as the loop is long
+ */
+const TAIL = 2 ** -64;
+function igamSeriesSumDD(a, x) {
+    let ch = 1;
+    let cl = 0;
+    let ah = 1;
+    let al = 0;
+    for (let i = 1; i < MAXITER; i++) {
+        // d = a + i exactly (dh + dl)
+        const dh = a + i;
+        const bb = dh - a;
+        const dl = a - (dh - bb) + (i - bb);
+        // q = x / d: q1 + q2
+        const q1 = x / dh;
+        let t = SPLITTER * q1;
+        const q1h = t - (t - q1);
+        const q1l = q1 - q1h;
+        t = SPLITTER * dh;
+        const dhh = t - (t - dh);
+        const dhl = dh - dhh;
+        const p = q1 * dh;
+        const pe = q1h * dhh - p + q1h * dhl + q1l * dhh + q1l * dhl;
+        const q2 = (x - p - pe - q1 * dl) / dh;
+        // c = c q
+        t = SPLITTER * ch;
+        const chh = t - (t - ch);
+        const chl = ch - chh;
+        const m = ch * q1;
+        const me = chh * q1h - m + chh * q1l + chl * q1h + chl * q1l + (ch * q2 + cl * q1);
+        ch = m + me;
+        cl = me - (ch - m);
+        // ans += c
+        const s = ah + ch;
+        const sb = s - ah;
+        const e = ah - (s - sb) + (ch - sb) + (al + cl);
+        ah = s + e;
+        al = e - (ah - s);
+        // the rest is at most c q / (1 - q) (q decreasing); stop once that is below 2^-64 ans, well under the
+        // rounding of the double result
+        if (ch * q1 <= TAIL * ah * (1 - q1))
+            break;
+    }
+    return ah + al;
+}
 /** Continued fraction for Q(a, x) (DLMF 8.9.2) */
 function igamcContinuedFraction(a, x, log) {
     const ans = igamcContinuedFractionValue(a, x);
@@ -61,7 +115,8 @@ function igamcContinuedFractionBoth(a, x) {
     const d = dpoisRawBoth(a, x);
     return [Math.log(a) + d[0] + Math.log(ans), a * d[1] * ans];
 }
-function igamcContinuedFractionValue(a, x) {
+/** The continued fraction of DLMF 8.9.2: Q(a, x) = x^a e^-x / Gamma(a) times this */
+export function igamcContinuedFractionValue(a, x) {
     let y = 1 - a;
     let z = x + y + 1;
     let c = 0;

package/dist/special/incbet.js

@@ -12,8 +12,8 @@
 //   Loader's dbinomRaw (avoids cancellation in the log for large a, b)
 // - The log is formed directly from the result of each computation
 import { MACHEP } from "./constants.js";
-import { dbinomRawDD } from "./loader.js";
-import { ddAdd, ddDiv, ddLog, ddMul, ddMulNum, twoProd, twoSum } from "./dd.js";
+import { dbinomExponent, dbinomRawDD } from "./loader.js";
+import { ddAdd, ddDiv, ddLog, ddMul, ddMulNum, ddSub, twoProd, twoSum } from "./dd.js";
 import { lgamma1p } from "./gamma.js";
 import { lgammaDiff } from "./lgammaDiff.js";
 const BIG = 4.503599627370496e15;
@@ -33,6 +33,21 @@ function prefactor(a, b, x, xc) {
 }
 /** Lower limit of normal numbers. If the prefactor is larger, multiply on the linear scale */
 const NORMAL_MIN = 2.2250738585072014e-308 * 1e3;
+/**
+ * m x^a (1-x)^b / B(a, b) for a prefactor below NORMAL_MIN (m a moderate factor such as the series sum).
+ * Going through the log would round an exponent near -708 to 0.5 ulp, which is 1e-13 relative after exp,
+ * so the exponent of dbinom(a; a+b, x) is kept in double-double and exp is taken once at the end.
+ * (multiplying by exp(-700) last rounds once, so a subnormal result is still correctly rounded).
+ * Returns undefined when the result underflows to 0 (the caller then works on the log scale)
+ */
+function smallPrefactorTimes(a, b, x, xc, m) {
+    const { e } = dbinomExponent(a, b, x, xc);
+    const c = (m * ((a * b) / (a + b))) / Math.sqrt(2 * Math.PI * a * (b / (a + b)));
+    if (!(e[0] < 1400) || !Number.isFinite(c) || c === 0)
+        return undefined;
+    const v = Math.exp(700 - e[0]) * (1 - e[1]) * c * Math.exp(-700);
+    return v > 0 ? v : undefined;
+}
 /**
  * Series sum S = Σ_{n>=1} (1-b)_n / n! x^n / (a + n) (the core of xsf's pseries).
  * xsf stops on the relative error of the sum including 1/a; here we stop on S itself
@@ -98,6 +113,9 @@ function pseries(a, b, xd, xcd, log) {
         const pf = prefactor(a, b, xd, xcd);
         if (pf > NORMAL_MIN)
             return (s * pf) / Math.exp(b * l1m);
+        const v = smallPrefactorTimes(a, b, xd, xcd, s / Math.exp(b * l1m));
+        if (v !== undefined)
+            return v;
     }
     const lv = Math.log(s) + logPrefactor(a, b, xd, xcd) - b * l1m;
     return log ? lv : Math.exp(lv);
@@ -110,32 +128,47 @@ function pseries(a, b, xd, xcd, log) {
  * the rounding of x = 0.999 (1e-19) alone shifts the result by 6e-13 relative (measured at a = 1e5, b = 100;
  * reference values checked with Rmpfr). So x is kept as an exact double-double and the recurrence also runs in
  * double-double.
+ *
+ * For the same reason a + b and b - 1 are kept in double-double: with a ≫ b, rounding a + b loses digits of b
+ * (5e-11 relative at a = 1e8, b = 0.01, x = 1 - 1e-6; checked against mpmath). From 2^52 on, the steps k += 1 of
+ * the other coefficients would be lost as well, so there every coefficient is a double-double (huge)
  */
 function continuedFractionCore(a, b, xd, xcd, second) {
     // #1: coefficients use x; #2: coefficients use z = x/(1-x)
     const z = second ? ddDiv(xd, xcd) : xd;
+    const huge = Math.max(a, b) >= 2 ** 52;
+    // Partial numerators k1 x k2 / (k3 k4) and k5 x k6 / (k7 k8). k1, k3, k4, k7, k8 are doubles, with
+    // double-double copies (h1, ...) that are used and advanced only when huge
     let k1 = a;
-    let k2 = second ? b - 1 : a + b;
+    let k2 = second ? twoSum(b, -1) : twoSum(a, b);
     let k3 = a;
     let k4 = a + 1;
     let k5 = 1;
-    let k6 = second ? a + b : b - 1;
+    let k6 = second ? twoSum(a, b) : twoSum(b, -1);
     let k7 = a + 1;
     let k8 = a + 2;
+    let h1 = [a, 0];
+    let h3 = [a, 0];
+    let h4 = twoSum(a, 1);
+    let h7 = twoSum(a, 1);
+    let h8 = twoSum(a, 2);
+    const d1 = second ? -1 : 1;
     let pkm2 = [0, 0];
     let qkm2 = [1, 0];
     let pkm1 = [1, 0];
     let qkm1 = [1, 0];
     let ans = [1, 0];
     for (let n = 0; n < 100000; n++) {
-        let xk = ddDiv(ddMulNum(ddMulNum(z, -k1), k2), twoProd(k3, k4));
-        let pk = ddAdd(pkm1, ddMul(pkm2, xk));
-        let qk = ddAdd(qkm1, ddMul(qkm2, xk));
+        let xk = huge
+            ? ddDiv(ddMul(ddMul(z, h1), k2), ddMul(h3, h4))
+            : ddDiv(ddMul(ddMulNum(z, k1), k2), twoProd(k3, k4));
+        let pk = ddSub(pkm1, ddMul(pkm2, xk));
+        let qk = ddSub(qkm1, ddMul(qkm2, xk));
         pkm2 = pkm1;
         pkm1 = pk;
         qkm2 = qkm1;
         qkm1 = qk;
-        xk = ddDiv(ddMulNum(ddMulNum(z, k5), k6), twoProd(k7, k8));
+        xk = ddDiv(ddMul(ddMulNum(z, k5), k6), huge ? ddMul(h7, h8) : twoProd(k7, k8));
         pk = ddAdd(pkm1, ddMul(pkm2, xk));
         qk = ddAdd(qkm1, ddMul(qkm2, xk));
         pkm2 = pkm1;
@@ -149,21 +182,23 @@ function continuedFractionCore(a, b, xd, xcd, second) {
             if (t < MACHEP && n > 1)
                 break;
         }
-        if (second) {
-            k1 += 1;
-            k2 -= 1;
-            k6 += 1;
+        k2 = ddAdd(k2, [d1, 0]);
+        k6 = ddAdd(k6, [-d1, 0]);
+        k5 += 1;
+        if (huge) {
+            h1 = ddAdd(h1, [1, 0]);
+            h3 = ddAdd(h3, [2, 0]);
+            h4 = ddAdd(h4, [2, 0]);
+            h7 = ddAdd(h7, [2, 0]);
+            h8 = ddAdd(h8, [2, 0]);
         }
         else {
             k1 += 1;
-            k2 += 1;
-            k6 -= 1;
+            k3 += 2;
+            k4 += 2;
+            k7 += 2;
+            k8 += 2;
         }
-        k3 += 2;
-        k4 += 2;
-        k5 += 1;
-        k7 += 2;
-        k8 += 2;
         const mag = Math.abs(qk[0]) + Math.abs(pk[0]);
         if (mag > BIG) {
             pkm2 = ddMulNum(pkm2, BIGINV);
@@ -198,8 +233,12 @@ function continuedFraction(a, b, xd, xcd, log) {
     // I = x^a (1-x)^b / (a B(a, b)) * w
     if (!log) {
         const pf = prefactor(a, b, xd, xcd);
+        // w / a first: pf / a can fall into the subnormal range for huge a (1e-316 at a = 7e18) and lose digits
         if (pf > NORMAL_MIN)
-            return (pf / a) * w;
+            return pf * (w / a);
+        const v = smallPrefactorTimes(a, b, xd, xcd, w / a);
+        if (v !== undefined)
+            return v;
     }
     const lv = logPrefactor(a, b, xd, xcd) - Math.log(a) + Math.log(w);
     return log ? lv : Math.exp(lv);
@@ -292,8 +331,13 @@ function betaIncCore(a, b, xd, xcd, lower, wantLog) {
     const otherDirect = () => {
         if (pseriesOk(oa, ob, ox[0]))
             return pseries(oa, ob, ox, oxc, false);
-        if (pseriesOk(pa, pb, px[0]))
-            return pseriesComplement(pa, pb, px, false);
+        if (pseriesOk(pa, pb, px[0])) {
+            const v = pseriesComplement(pa, pb, px, false);
+            // Cancellation check as for the requested tail (see below)
+            if (pa * Math.abs(Math.log(px[0])) > 32 * v && cfOk(oa, ob, ox[0]))
+                return continuedFraction(oa, ob, ox, oxc, false);
+            return v;
+        }
         if (cfOk(oa, ob, ox[0]))
             return continuedFraction(oa, ob, ox, oxc, false);
         return undefined;
@@ -308,6 +352,17 @@ function betaIncCore(a, b, xd, xcd, lower, wantLog) {
     }
     if (pseriesOk(oa, ob, ox[0])) {
         const v = pseriesComplement(oa, ob, ox, false);
+        // The exponent L of pseriesComplement is a sum of terms of size a |log x| that can cancel, and their rounding
+        // (absolute, about ε a |log x|) is then large relative to a small result (1e-14 at a = 0.01, b = 1e4, x = 1e-4).
+        // When a |log x| exceeds the result 32 times and the continued fraction applies in this tail's frame, use it
+        // instead (a lower threshold would also send cases where the series is accurate, e.g. most of pt near 0, to the
+        // slower continued fraction)
+        if (oa * Math.abs(Math.log(ox[0])) > 32 * v && cfOk(pa, pb, px[0])) {
+            const w = continuedFraction(pa, pb, px, pxc, false);
+            if (wantLog && w < TINY)
+                return [continuedFraction(pa, pb, px, pxc, true), w];
+            return finish(w, otherDirect);
+        }
         return finish(v, () => pseries(oa, ob, ox, oxc, false));
     }
     if (cfOk(pa, pb, px[0])) {

package/dist/special/lgammaDiff.d.ts

@@ -1,2 +1,9 @@
+import { type DD } from "./dd.js";
 /** lgamma(b + a) - lgamma(b). a >= 0, b > 0 */
 export declare function lgammaDiff(a: number, b: number): number;
+/**
+ * lgammaDiff in double-double: the term a log(B + a), which reaches hundreds for large b (exp of it would turn its
+ * rounding into a relative error of 1e-14 at B(0.5, 1e300)), is formed in double-double; the others are of the size
+ * of a or less and stay in double precision
+ */
+export declare function lgammaDiffDD(a: number, b: number): DD;

package/dist/special/lgammaDiff.js

@@ -9,11 +9,21 @@
 //      D(a, B) = (B - 1/2) log1p(a/B) + a log(B + a) - a + [stirlerr(B + a) - stirlerr(B)]
 //    and compute the stirlerr difference with expm1 from the differences of the Stirling series terms,
 //    B^-k ((1 + a/B)^-k - 1)
+import { ddAdd, ddLog, ddMulNum, twoSum } from "./dd.js";
 const S = [1 / 12, -1 / 360, 1 / 1260, -1 / 1680, 1 / 1188, -691 / 360360, 1 / 156];
 /** lgamma(b + a) - lgamma(b). a >= 0, b > 0 */
 export function lgammaDiff(a, b) {
+    const d = lgammaDiffDD(a, b);
+    return d[0] + d[1];
+}
+/**
+ * lgammaDiff in double-double: the term a log(B + a), which reaches hundreds for large b (exp of it would turn its
+ * rounding into a relative error of 1e-14 at B(0.5, 1e300)), is formed in double-double; the others are of the size
+ * of a or less and stay in double precision
+ */
+export function lgammaDiffDD(a, b) {
     if (a === 0)
-        return 0;
+        return [0, 0];
     let acc = 0;
     let B = b;
     while (B <= 15) {
@@ -21,7 +31,10 @@ export function lgammaDiff(a, b) {
         B += 1;
     }
     const l1p = Math.log1p(a / B);
-    let d = (B - 0.5) * l1p + a * Math.log(B + a) - a;
+    const lead0 = a * Math.log(B + a);
+    // (in double precision where it is small: its rounding is then below the others', and incbet calls this often)
+    const lead = Math.abs(lead0) > 2 && Number.isFinite(lead0) && a < 1e300 ? ddMulNum(ddLog(twoSum(B, a)), a) : [lead0, 0];
+    let d = (B - 0.5) * l1p - a;
     // stirlerr(B + a) - stirlerr(B) = Σ S_k [ (B + a)^-(2k+1) - B^-(2k+1) ]
     let pw = 1 / B;
     const inv2 = 1 / (B * B);
@@ -30,5 +43,5 @@ export function lgammaDiff(a, b) {
         d += S[k] * pw * Math.expm1(-m * l1p);
         pw *= inv2;
     }
-    return acc + d;
+    return ddAdd(lead, [acc + d, 0]);
 }

package/dist/special/psigamma.d.ts

@@ -0,0 +1,48 @@
+import type { RCompatibleOptions } from "./rCompatible.js";
+/**
+ * Digamma function, the derivative of `lgamma`. Equivalent to R's `digamma(x)` for a single number.
+ *
+ * @param x - Argument.
+ * @returns psi(x) (`NaN` at zero and the negative integers).
+ *
+ * @example
+ * ```ts
+ * digamma(1);  // -0.5772156649015329 (minus Euler's constant)
+ * ```
+ */
+export declare function digamma(x: number): number;
+/**
+ * Trigamma function, the second derivative of `lgamma`. Equivalent to R's `trigamma(x)` for a single number.
+ *
+ * `trigamma(-Infinity)` is `Infinity` as in R (`NaN` with `rCompatible: false`).
+ *
+ * @param x - Argument.
+ * @param options - `rCompatible` (default `true`).
+ * @returns psi'(x) (`Infinity` at zero and the negative integers).
+ *
+ * @example
+ * ```ts
+ * trigamma(1);  // 1.6449340668482264 (pi^2 / 6)
+ * ```
+ */
+export declare function trigamma(x: number, options?: RCompatibleOptions): number;
+/**
+ * Polygamma function, the derivative of order `deriv` of `digamma`. Equivalent to R's
+ * `psigamma(x, deriv)` for a single number.
+ *
+ * `psigamma(-Infinity, deriv)` is `Infinity` for odd `deriv` as in R, which treats it like the poles
+ * (`NaN` with `rCompatible: false`). Unlike R, which returns `NaN` for `x < 0` with `deriv >= 6` and
+ * where the result overflows, the value is computed there.
+ *
+ * @param x - Argument.
+ * @param deriv - Order of the derivative, an integer from 0 to 100 (rounded half to even; default 0, digamma).
+ * @param options - `rCompatible` (default `true`).
+ * @returns psi^(deriv)(x). At zero and the negative integers, `Infinity` for odd `deriv` and `NaN` for even.
+ *   `NaN` if `deriv` is outside 0 to 100.
+ *
+ * @example
+ * ```ts
+ * psigamma(2, 2);  // -0.40411380631918853 (-2 (zeta(3) - 1))
+ * ```
+ */
+export declare function psigamma(x: number, deriv?: number, options?: RCompatibleOptions): number;

package/dist/special/psigamma.js

@@ -0,0 +1,318 @@
+// Digamma and polygamma functions: digamma, trigamma, psigamma.
+//
+// digamma is ported from xsf include/xsf/cephes/psi.h and include/xsf/digamma.h (xsf commit c6a3afe; the
+// rational approximation on [1, 2] in psi.h is from Boost.Math, (C) John Maddock 2006, BSL-1.0).
+// Cephes Math Library Release 2.8, Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier.
+// xsf Copyright (c) 2024, SciPy. BSD-3-Clause. See THIRD_PARTY_NOTICES.md.
+//
+// The derivatives (deriv >= 1) are written for rStats.js:
+//   psi^(n)(x) = (-1)^(n+1) n! zeta(n + 1, x)                                  (x > 0)
+// with the Hurwitz zeta function summed by Euler-Maclaurin as in xsf include/xsf/cephes/zeta.h, but scaled by
+// x^(n+1) so that n! / x^(n+1) and the sum can be combined without overflow, and with direct terms up to
+// a >= n + 1 so that the Bernoulli corrections converge for large n. For x < 0 the reflection formula
+//   psi^(n)(x) = (-1)^n psi^(n)(1 - x) - pi^(n+1) P_n(cot(pi x))
+// is used, where d^n/dx^n cot(pi x) = pi^n P_n(cot(pi x)), P_0(t) = t, P_(k+1)(t) = -(1 + t^2) P_k'(t)
+// (P_n has terms of one parity only, all of the same sign, so it is evaluated without cancellation).
+import { roundHalfEven } from "../internal/integer.js";
+import { EULER, MACHEP } from "./constants.js";
+import { polevl } from "./polevl.js";
+const PSI_A = [
+    8.33333333333333333333e-2, -2.10927960927960927961e-2, 7.57575757575757575758e-3, -4.16666666666666666667e-3,
+    3.96825396825396825397e-3, -8.33333333333333333333e-3, 8.33333333333333333333e-2,
+];
+const PSI_Y = 0.99558162689208984; // a float constant in Boost
+const PSI_ROOT1 = 1569415565.0 / 1073741824.0;
+const PSI_ROOT2 = 381566830.0 / 1073741824.0 / 1073741824.0;
+const PSI_ROOT3 = 0.9016312093258695918615325266959189453125e-19;
+const PSI_P = [
+    -0.0020713321167745952, -0.045251321448739056, -0.28919126444774784, -0.65031853770896507, -0.32555031186804491,
+    0.25479851061131551,
+];
+const PSI_Q = [
+    -0.55789841321675513e-6, 0.0021284987017821144, 0.054151797245674225, 0.43593529692665969, 1.4606242909763515,
+    2.0767117023730469, 1.0,
+];
+/** Rational approximation on [1, 2]: digamma(x) = (x - root) (Y + R(x - 1)) */
+function digammaImp12(x) {
+    let g = x - PSI_ROOT1;
+    g -= PSI_ROOT2;
+    g -= PSI_ROOT3;
+    const r = polevl(x - 1, PSI_P) / polevl(x - 1, PSI_Q);
+    return g * PSI_Y + g * r;
+}
+function psiAsy(x) {
+    let y = 0;
+    if (x < 1e17) {
+        const z = 1 / (x * x);
+        y = z * polevl(z, PSI_A);
+    }
+    return Math.log(x) - 0.5 / x - y;
+}
+/** Cephes psi */
+function psi(x) {
+    let y = 0;
+    if (Number.isNaN(x) || x === Infinity)
+        return x;
+    if (x === -Infinity)
+        return NaN;
+    if (x === 0)
+        return NaN;
+    if (x < 0) {
+        // argument reduction before evaluating tan(pi x)
+        const r = x - Math.trunc(x);
+        if (r === 0)
+            return NaN;
+        y = -Math.PI / Math.tan(Math.PI * r);
+        x = 1 - x;
+    }
+    // positive integers up to 10
+    if (x <= 10 && x === Math.floor(x)) {
+        const n = x;
+        for (let i = 1; i < n; i++)
+            y += 1 / i;
+        return y - EULER;
+    }
+    // use the recurrence to move x into [1, 2]
+    if (x < 1) {
+        y -= 1 / x;
+        x += 1;
+    }
+    else if (x < 10) {
+        while (x > 2) {
+            x -= 1;
+            y += 1 / x;
+        }
+    }
+    if (x >= 1 && x <= 2)
+        return y + digammaImp12(x);
+    return y + psiAsy(x);
+}
+// Series around the negative root closest to 0 (xsf digamma.h; values computed with mpmath there)
+const NEGROOT = -0.504083008264455409;
+const NEGROOTVAL = 7.2897639029768949e-17;
+/** zeta(n + 1, NEGROOT) for n = 1, 2, ... (the series coefficients), computed on first use */
+let negrootZeta;
+function digammaNearNegroot(x) {
+    negrootZeta ??= Array.from({ length: 100 }, (_, i) => hurwitzZeta(i + 2, NEGROOT));
+    let res = NEGROOTVAL;
+    let coeff = -1;
+    const z = x - NEGROOT;
+    for (let n = 1; n < 100; n++) {
+        coeff *= -z;
+        const term = coeff * negrootZeta[n - 1];
+        res += term;
+        if (Math.abs(term) < Number.EPSILON * Math.abs(res))
+            break;
+    }
+    return res;
+}
+/** Expansion coefficients (2k)! / B_2k for the Euler-Maclaurin formula (xsf cephes/zeta.h) */
+const ZETA_A = [
+    12.0, -720.0, 30240.0, -1209600.0, 47900160.0, -1.8924375803183791606e9, 7.47242496e10, -2.950130727918164224e12,
+    1.1646782814350067249e14, -4.5979787224074726105e15, 1.8152105401943546773e17, -7.1661652561756670113e18,
+];
+/**
+ * Hurwitz zeta function zeta(s, q) times q^s, for s > 1 and q > 0 (Euler-Maclaurin summation as in Cephes, with
+ * every term scaled by q^s). Direct terms are added until the term is negligible or a = q + i exceeds both 9 and s,
+ * so that the Bernoulli corrections, whose ratio is about ((s + 2i) / (2 pi a))^2, converge
+ */
+function hurwitzZetaScaled(s, q) {
+    let sum = 1;
+    let a = q;
+    let b = 1;
+    let i = 0;
+    // Above 1e8 no direct terms: the expansion at a = q itself, q / (s - 1) + 1/2 + s / (12 q) - ... (cutting it after
+    // the 1/2 left out s / (12 q), 1e-14 relative at q = 1e8, s = 39)
+    while (q <= 1e8 && (i < 9 || a <= 9 || a < s)) {
+        i += 1;
+        a += 1;
+        b = Math.exp(-s * Math.log1p(i / q)); // (q / a)^s
+        sum += b;
+        if (Math.abs(b / sum) < MACHEP)
+            return sum;
+    }
+    const w = a;
+    sum += (b * w) / (s - 1);
+    sum -= 0.5 * b;
+    let fac = 1;
+    let k = 0;
+    for (let j = 0; j < 12; j++) {
+        fac *= s + k;
+        b /= w;
+        const t = (fac * b) / ZETA_A[j];
+        sum += t;
+        if (Math.abs(t / sum) < MACHEP)
+            break;
+        k += 1;
+        fac *= s + k;
+        b /= w;
+        k += 1;
+    }
+    return sum;
+}
+/**
+ * Hurwitz zeta function zeta(s, q) for integer s > 1 and any q that is not a non-positive integer, unscaled as in
+ * Cephes (negative q are allowed for integer s: the direct sum runs until q + i > 9). Used for the series
+ * coefficients around the negative root of digamma
+ */
+function hurwitzZeta(s, q) {
+    let sum = Math.pow(q, -s);
+    let a = q;
+    let b = 0;
+    let i = 0;
+    while (i < 9 || a <= 9 || a < s) {
+        i += 1;
+        a += 1;
+        b = Math.pow(a, -s);
+        sum += b;
+        if (Math.abs(b / sum) < MACHEP)
+            return sum;
+    }
+    const w = a;
+    sum += (b * w) / (s - 1);
+    sum -= 0.5 * b;
+    let fac = 1;
+    let k = 0;
+    for (let j = 0; j < 12; j++) {
+        fac *= s + k;
+        b /= w;
+        const t = (fac * b) / ZETA_A[j];
+        sum += t;
+        if (Math.abs(t / sum) < MACHEP)
+            break;
+        k += 1;
+        fac *= s + k;
+        b /= w;
+        k += 1;
+    }
+    return sum;
+}
+/** psi^(n)(x) for x > 0, n >= 1: (-1)^(n+1) n! / x^(n+1) * [x^(n+1) zeta(n + 1, x)] */
+function polygammaPositive(n, x) {
+    if (x === Infinity)
+        return n % 2 === 0 ? -0 : 0;
+    // n! / x^n as a running product (no overflow before the result does), then the sum divided by x
+    let p = 1;
+    for (let k = 1; k <= n; k++)
+        p *= k / x;
+    const v = p * (hurwitzZetaScaled(n + 1, x) / x);
+    return n % 2 === 0 ? -v : v;
+}
+/** Coefficients of P_n in t^2: P_n(t) = t^(n+1 mod 2) * sum_j c_j t^(2j), computed on first use */
+const cotDerivCache = [];
+function cotDerivPoly(n) {
+    // Dense coefficients of P_k(t) by recurrence, then keep those of the parity of n + 1
+    if (cotDerivCache[n] !== undefined)
+        return cotDerivCache[n];
+    let p = [0, 1]; // P_0 = t
+    for (let k = 0; k < n; k++) {
+        // P' then -(1 + t^2) P'
+        const d = p.slice(1).map((c, i) => c * (i + 1));
+        const next = new Array(d.length + 2).fill(0);
+        d.forEach((c, i) => {
+            next[i] = next[i] - c;
+            next[i + 2] = next[i + 2] - c;
+        });
+        p = next;
+    }
+    const parity = (n + 1) % 2;
+    const coef = [];
+    for (let i = parity; i < p.length; i += 2)
+        coef.push(p[i]);
+    cotDerivCache[n] = coef;
+    return coef;
+}
+/** P_n(t) (all coefficients of one sign, so no cancellation) */
+function cotDeriv(n, t) {
+    const c = cotDerivPoly(n);
+    const t2 = t * t;
+    // Horner from the leading coefficient (starting from 0 would give 0 * Infinity = NaN when t^2 overflows)
+    let s = c[c.length - 1];
+    for (let j = c.length - 2; j >= 0; j--)
+        s = s * t2 + c[j];
+    return (n + 1) % 2 === 1 ? s * t : s;
+}
+/**
+ * cot(pi x), with x reduced exactly to r in [-1/2, 1/2]. The cosine is taken as sin(pi (1/2 - |r|)), where 1/2 - |r|
+ * is exact near 1/2, so that cot is exactly 0 at half-integers and keeps its relative accuracy near them (P_n
+ * multiplies the error of a cot that should be 0 by its huge linear coefficient: 1e174 instead of -6e117 for
+ * psigamma(-1.5, 100))
+ */
+function cotpi(x) {
+    const r = x - Math.round(x);
+    const c = Math.sin(Math.PI * (0.5 - Math.abs(r)));
+    return c / Math.sin(Math.PI * r);
+}
+function polygamma(n, x, rCompatible) {
+    if (Number.isNaN(x))
+        return NaN;
+    // R treats -Infinity like the poles (it equals its own rounding)
+    if (x === -Infinity)
+        return rCompatible && n % 2 === 1 ? Infinity : NaN;
+    if (x <= 0 && x === Math.floor(x))
+        return n % 2 === 1 ? Infinity : NaN;
+    if (x > 0)
+        return polygammaPositive(n, x);
+    const refl = polygammaPositive(n, 1 - x);
+    return (n % 2 === 0 ? refl : -refl) - Math.pow(Math.PI, n + 1) * cotDeriv(n, cotpi(x));
+}
+/**
+ * Digamma function, the derivative of `lgamma`. Equivalent to R's `digamma(x)` for a single number.
+ *
+ * @param x - Argument.
+ * @returns psi(x) (`NaN` at zero and the negative integers).
+ *
+ * @example
+ * ```ts
+ * digamma(1);  // -0.5772156649015329 (minus Euler's constant)
+ * ```
+ */
+export function digamma(x) {
+    if (Math.abs(x - NEGROOT) < 0.3)
+        return digammaNearNegroot(x);
+    return psi(x);
+}
+/**
+ * Trigamma function, the second derivative of `lgamma`. Equivalent to R's `trigamma(x)` for a single number.
+ *
+ * `trigamma(-Infinity)` is `Infinity` as in R (`NaN` with `rCompatible: false`).
+ *
+ * @param x - Argument.
+ * @param options - `rCompatible` (default `true`).
+ * @returns psi'(x) (`Infinity` at zero and the negative integers).
+ *
+ * @example
+ * ```ts
+ * trigamma(1);  // 1.6449340668482264 (pi^2 / 6)
+ * ```
+ */
+export function trigamma(x, options) {
+    return polygamma(1, x, options?.rCompatible ?? true);
+}
+/**
+ * Polygamma function, the derivative of order `deriv` of `digamma`. Equivalent to R's
+ * `psigamma(x, deriv)` for a single number.
+ *
+ * `psigamma(-Infinity, deriv)` is `Infinity` for odd `deriv` as in R, which treats it like the poles
+ * (`NaN` with `rCompatible: false`). Unlike R, which returns `NaN` for `x < 0` with `deriv >= 6` and
+ * where the result overflows, the value is computed there.
+ *
+ * @param x - Argument.
+ * @param deriv - Order of the derivative, an integer from 0 to 100 (rounded half to even; default 0, digamma).
+ * @param options - `rCompatible` (default `true`).
+ * @returns psi^(deriv)(x). At zero and the negative integers, `Infinity` for odd `deriv` and `NaN` for even.
+ *   `NaN` if `deriv` is outside 0 to 100.
+ *
+ * @example
+ * ```ts
+ * psigamma(2, 2);  // -0.40411380631918853 (-2 (zeta(3) - 1))
+ * ```
+ */
+export function psigamma(x, deriv = 0, options) {
+    const n = roundHalfEven(deriv);
+    if (Number.isNaN(n) || n < 0 || n > 100)
+        return NaN;
+    if (n === 0)
+        return digamma(x);
+    return polygamma(n, x, options?.rCompatible ?? true);
+}