@numero-uno-jpn/rstats 0.0.0-stage → 0.5.0

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,297 @@
+# Third-party notices
+
+rStats.js contains code ported (translated into TypeScript) from the projects
+listed below. Each ported file names its source at the top.
+
+---
+
+## xsf
+
+- Source: https://github.com/scipy/xsf (commit c6a3afe)
+- Used in: `src/special/beta.ts`, `src/special/constants.ts`, `src/special/erf.ts`, `src/special/gamma.ts`, `src/special/igam.ts`, `src/special/igamAsympCoeff.ts`, `src/special/igami.ts`, `src/special/incbet.ts`, `src/special/log1pmx.ts`, `src/special/ndtri.ts`, `src/special/polevl.ts`
+- License: BSD-3-Clause
+- `include/xsf/ndtri_exp.h` (used in `src/special/ndtri.ts`): Copyright Albert Steppi,
+  distributed under the same license as SciPy (BSD-3-Clause)
+
+```
+BSD 3-Clause License
+
+Copyright (c) 2024, SciPy
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+---
+
+## Cephes Math Library (as bundled in xsf)
+
+- Source: `include/xsf/cephes/*` in xsf
+- Used in: the files above that cite `include/xsf/cephes/*`
+- License: BSD-3-Clause, distributed with permission from the author
+  (see https://lists.debian.org/debian-legal/2004/12/msg00295.html)
+
+```
+Distributed under 3-clause BSD license with permission from the author,
+see https://lists.debian.org/debian-legal/2004/12/msg00295.html
+
+Cephes Math Library Release 2.8:  June, 2000
+Copyright 1984, 1995, 2000 by Stephen L. Moshier
+
+This software is derived from the Cephes Math Library and is
+incorporated herein by permission of the author.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the <organization> nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+```
+
+---
+
+## Boost.Math
+
+- Source: https://github.com/boostorg/math (commit 4a6ce78)
+  - `include/boost/math/distributions/non_central_chi_squared.hpp`
+  - `include/boost/math/distributions/non_central_t.hpp`
+- Used in: `src/internal/poissonMixture.ts`, `src/distributions/nt.ts` (consulted as a reference for the
+  algorithms — Poisson-mixture summation starting near the mode, and the integral
+  P[T <= t] = E[Φ(tS - δ)] for the non-central t; the TypeScript code was written independently)
+- License: Boost Software License 1.0
+
+```
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+```
+
+Boost.Math: Copyright John Maddock 2008, Matt Borland 2024 (and other contributors).
+
+---
+
+## SciPy (scipy.stats)
+
+- Source: https://github.com/scipy/scipy (commit a087e61)
+  - `scipy/stats/_stats_py.py` (ttest_1samp / ttest_ind / ttest_rel, chisquare, fisher_exact, pearsonr)
+  - `scipy/stats/contingency.py` (chi2_contingency, expected_freq)
+  - `scipy/stats/_odds_ratio.py` (conditional odds ratio and its confidence interval)
+  - `scipy/stats/_wilcoxon.py`, `scipy/stats/_mannwhitneyu.py`
+  - `scipy/stats/_mstats_basic.py` (kendalltau, `_kendall_p_exact`)
+- Used in: `src/htest/tTest.ts`, `src/htest/chisqTest.ts`, `src/htest/fisherTest.ts`, `src/htest/wilcoxTest.ts`, `src/htest/cor.ts`
+- License: BSD-3-Clause
+
+```
+Copyright (c) 2001-2002 Enthought, Inc. 2003, SciPy Developers.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above
+   copyright notice, this list of conditions and the following
+   disclaimer in the documentation and/or other materials provided
+   with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+---
+
+## statsmodels
+
+- Source: https://github.com/statsmodels/statsmodels (commit 5c65604)
+  - `statsmodels/stats/multitest.py` (multipletests, method = "hommel")
+- Used in: `src/htest/pAdjust.ts`
+- License: BSD-3-Clause
+
+```
+Copyright (C) 2006, Jonathan E. Taylor
+All rights reserved.
+
+Copyright (c) 2006-2008 Scipy Developers.
+All rights reserved.
+
+Copyright (c) 2009-2018 statsmodels Developers.
+All rights reserved.
+
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  a. Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+  b. Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+  c. Neither the name of statsmodels nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL STATSMODELS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGE.
+```
+
+---
+
+## LAPACK
+
+- Source: https://github.com/Reference-LAPACK/lapack (tag v3.12.0)
+  - `BLAS/SRC/dtrsm.f`, `SRC/dlange.f`, `SRC/dpotf2.f`, `SRC/dpstf2.f`, `SRC/dpotri.f` (`dtrti2.f`, `dlauu2.f`),
+    `SRC/dgeqp3.f` (`dlaqp2.f`, `dlarfg.f`, `dlarf.f`), `SRC/dorm2r.f`, `SRC/dgetf2.f`, `SRC/dgetrs.f`,
+    `SRC/dgecon.f`, `SRC/dtrcon.f`, `SRC/dlacn2.f`
+- Used in: `src/linalg/basic.ts`, `src/linalg/norm.ts`, `src/linalg/chol.ts`, `src/linalg/qr.ts`, `src/linalg/solve.ts`, `src/linalg/svd.ts`
+- License: modified BSD
+
+```
+Copyright (c) 1992-2023 The University of Tennessee and The University
+                        of Tennessee Research Foundation.  All rights
+                        reserved.
+Copyright (c) 2000-2023 The University of California Berkeley. All
+                        rights reserved.
+Copyright (c) 2006-2023 The University of Colorado Denver.  All rights
+                        reserved.
+
+$COPYRIGHT$
+
+Additional copyrights may follow
+
+$HEADER$
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+The copyright holders provide no reassurances that the source code
+provided does not infringe any patent, copyright, or any other
+intellectual property rights of third parties.  The copyright holders
+disclaim any liability to any recipient for claims brought against
+recipient by any third party for infringement of that parties
+intellectual property rights.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+---
+
+## Public-domain sources (listed for attribution)
+
+The following algorithms come from public-domain software. No license terms apply;
+they are listed so that readers can find the originals.
+
+- LINPACK (Dongarra, Bunch, Moler, Stewart 1979): `dqrdc` (Householder QR, used with the
+  column-pivoting rule of R observed from its output) and `dtrco` (condition estimate) —
+  `src/linalg/qr.ts`, `src/linalg/kappa.ts`
+- EISPACK / JAMA (NIST and The MathWorks): `svd` (Golub–Reinsch), `tred2`, `tql2`, `orthes`, `hqr2` —
+  `src/linalg/svd.ts`, `src/linalg/eigen.ts`

package/dist/distributions/beta.d.ts

@@ -0,0 +1,62 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+import type { NoncentralOption } from "../internal/noncentral.js";
+/** Log density (0 < x < 1, 0 < a, b < Inf) */
+export declare function dbetaLog(x: number, _xc: number, a: number, b: number): number;
+export declare function dbeta1(x: number, a: number, b: number, log: boolean): number;
+export declare function pbeta1(q: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Starting value for quantiles (Abramowitz & Stegun 26.5.22). Approximates the x with I_x(a, b) = target if lower,
+ * otherwise 1 - I_x(a, b) = target. Used only for a, b > 1; undefined otherwise.
+ *   x ≈ a / (a + b e^(2w)),  w = y sqrt(h + λ)/h - (1/(2b-1) - 1/(2a-1)) (λ + 5/6 - 2/(3h)),
+ *   h = 2 / (1/(2a-1) + 1/(2b-1)),  λ = (y^2 - 3)/6,  y is the normal point whose upper probability equals I_x
+ */
+export declare function betaQuantileGuess(a: number, b: number, lower: boolean, logTarget: number): number | undefined;
+export declare function qbeta1(p: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the beta distribution. Equivalent to R's `dbeta(x, shape1, shape2, ncp = 0, log = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral beta distribution.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape1 - First shape parameter (a).
+ * @param shape2 - Second shape parameter (b).
+ * @param options - `ncp` (see {@link NoncentralOption}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export declare function dbeta<T extends Vectorizable>(x: T, shape1: number, shape2: number, options?: DensityOptions & NoncentralOption): VectorResult<T>;
+/**
+ * Distribution function of the beta distribution. Equivalent to R's `pbeta(q, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral beta distribution.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape1 - First shape parameter (a).
+ * @param shape2 - Second shape parameter (b).
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pbeta(0.5, 2, 3); // 0.6875 (up to rounding)
+ * ```
+ */
+export declare function pbeta<T extends Vectorizable>(q: T, shape1: number, shape2: number, options?: TailOptions & NoncentralOption): VectorResult<T>;
+/**
+ * Quantile function of the beta distribution. Equivalent to R's `qbeta(p, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral beta distribution.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape1 - First shape parameter (a).
+ * @param shape2 - Second shape parameter (b).
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ *
+ * @example
+ * ```ts
+ * qbeta(0.025, 3, 7);          // 0.07485463141969181
+ * qbeta([0.025, 0.975], 3, 7); // [0.07485463141969181, 0.6000935737163121]
+ * ```
+ */
+export declare function qbeta<T extends Vectorizable>(p: T, shape1: number, shape2: number, options?: TailOptions & NoncentralOption): VectorResult<T>;

package/dist/distributions/beta.js

@@ -0,0 +1,246 @@
+// Beta distribution dbeta / pbeta / qbeta.
+//
+// The density uses the relation to the binomial probability (Loader 2000) (dbetaCore). The distribution function
+// uses the incomplete beta function (src/special/incbet.ts), and quantiles use Newton's method in u = log x
+// (src/internal/invert.ts). Upper-tail quantiles are computed as x = 1 - (lower quantile of Beta(b, a)) to avoid
+// cancellation near 1. Passing ncp gives the noncentral beta (src/distributions/nbeta.ts).
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries, smallerTail } from "../internal/dpq.js";
+import { invertContinuous } from "../internal/invert.js";
+import { lbeta } from "../special/beta.js";
+import { betaInc, betaIncBoth } from "../special/incbet.js";
+import { dbinomExponent } from "../special/loader.js";
+import { ddAdd, ddLog, ddNeg, twoSum } from "../special/dd.js";
+import { dnbeta1, pnbeta1, qnbeta1 } from "./nbeta.js";
+import { qnorm } from "./normal.js";
+/** Form x and 1 - x as a double-double pair based on the smaller of the two (no rounding of 1 - x brought in) */
+function pair(x) {
+    return x <= 0.5 ? [[x, 0], twoSum(1, -x)] : [twoSum(1, -(1 - x)), [1 - x, 0]];
+}
+/**
+ * Density (0 < x < 1, 0 < a, b < Inf).
+ * From the relation to the binomial probability dbinom(a; a + b, x) = Gamma(a+b+1)/(Gamma(a+1) Gamma(b+1)) x^a (1-x)^b,
+ *   f(x) = x^(a-1) (1-x)^(b-1) / B(a, b) = dbinom(a; a + b, x) * a b / ((a + b) x (1 - x))
+ * (valid for any a, b > 0). x and 1 - x are passed as a double-double pair.
+ */
+function dbetaCore(x, a, b, log) {
+    const [xd, xcd] = pair(x);
+    // log f = -E - log(denom)/2 + log(a b / (a + b)) - log x - log(1 - x), assembled entirely in double-double
+    const { e, logDenom } = dbinomExponent(a, b, xd, xcd);
+    const rest = ddAdd(ddNeg(ddAdd(ddLog(xd), ddLog(xcd))), [Math.log((a * b) / (a + b)) - 0.5 * logDenom, 0]);
+    const t = ddAdd(ddNeg(e), rest);
+    return log ? t[0] + t[1] : Math.exp(t[0]) * (1 + t[1]);
+}
+/** Log density (0 < x < 1, 0 < a, b < Inf) */
+export function dbetaLog(x, _xc, a, b) {
+    return dbetaCore(x, a, b, true);
+}
+export function dbeta1(x, a, b, log) {
+    if (Number.isNaN(x) || Number.isNaN(a) || Number.isNaN(b))
+        return NaN;
+    if (a < 0 || b < 0)
+        return NaN;
+    if (x < 0 || x > 1)
+        return d0(log);
+    // Point masses when a parameter is 0 or infinite
+    if (a === 0 || b === 0 || !Number.isFinite(a) || !Number.isFinite(b)) {
+        if (a === 0 && b === 0)
+            return x === 0 || x === 1 ? Infinity : d0(log);
+        if (a === 0 || b / a === Infinity)
+            return x === 0 ? Infinity : d0(log);
+        if (b === 0 || a / b === Infinity)
+            return x === 1 ? Infinity : d0(log);
+        return x === 0.5 ? Infinity : d0(log);
+    }
+    if (x === 0) {
+        if (a > 1)
+            return d0(log);
+        if (a < 1)
+            return Infinity;
+        return log ? Math.log(b) : b;
+    }
+    if (x === 1) {
+        if (b > 1)
+            return d0(log);
+        if (b < 1)
+            return Infinity;
+        return log ? Math.log(a) : a;
+    }
+    return dbetaCore(x, a, b, log);
+}
+export function pbeta1(q, a, b, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(a) || Number.isNaN(b))
+        return NaN;
+    if (a < 0 || b < 0)
+        return NaN;
+    if (q >= 1)
+        return dt1(lowerTail, logP);
+    // Point masses when a parameter is 0 or infinite (R checks this after q >= 1 and before q <= 0)
+    if (a === 0 || b === 0 || !Number.isFinite(a) || !Number.isFinite(b)) {
+        if (a === 0 && b === 0)
+            return logP ? -Math.LN2 : 0.5; // 1/2 each at 0 and 1
+        if (a === 0 || b / a === Infinity)
+            return dt1(lowerTail, logP); // concentrated at 0
+        if (b === 0 || a / b === Infinity)
+            return dt0(lowerTail, logP); // concentrated at 1
+        return q < 0.5 ? dt0(lowerTail, logP) : dt1(lowerTail, logP); // concentrated at 1/2
+    }
+    if (q <= 0)
+        return dt0(lowerTail, logP);
+    return betaInc(a, b, q, 1 - q, lowerTail, logP);
+}
+/**
+ * Starting value for quantiles (Abramowitz & Stegun 26.5.22). Approximates the x with I_x(a, b) = target if lower,
+ * otherwise 1 - I_x(a, b) = target. Used only for a, b > 1; undefined otherwise.
+ *   x ≈ a / (a + b e^(2w)),  w = y sqrt(h + λ)/h - (1/(2b-1) - 1/(2a-1)) (λ + 5/6 - 2/(3h)),
+ *   h = 2 / (1/(2a-1) + 1/(2b-1)),  λ = (y^2 - 3)/6,  y is the normal point whose upper probability equals I_x
+ */
+export function betaQuantileGuess(a, b, lower, logTarget) {
+    if (!(a > 1 && b > 1))
+        return undefined;
+    const z = qnorm(logTarget, { logP: true });
+    const y = lower ? -z : z;
+    const ra = 1 / (2 * a - 1);
+    const rb = 1 / (2 * b - 1);
+    const h = 2 / (ra + rb);
+    const lam = (y * y - 3) / 6;
+    if (!(h + lam > 0))
+        return undefined;
+    const w = (y * Math.sqrt(h + lam)) / h - (rb - ra) * (lam + 5 / 6 - 2 / (3 * h));
+    const x = a / (a + b * Math.exp(2 * w));
+    return x > 0 && x < 1 ? x : undefined;
+}
+/**
+ * Solve for the quantile in frame (a, b) when the answer lies in (0, 1/2].
+ * I_x(a, b) = target if lower, otherwise 1 - I_x(a, b) = target.
+ */
+function solveLeftHalf(a, b, lower, logTarget, linearTarget) {
+    // If the distribution function at the smallest positive number already passes the target, the answer is too small to represent (0)
+    const atMin = betaInc(a, b, Number.MIN_VALUE, 1, lower, true);
+    if (lower ? atMin >= logTarget : atMin <= logTarget)
+        return 0;
+    // Starting value: near 0, the tail approximation I_x(a, b) ≈ x^a / (a B(a, b)); otherwise the A&S 26.5.22 approximation
+    let x0 = 0.25;
+    let tail = Infinity;
+    if (lower) {
+        const lguess = (logTarget + Math.log(a) + lbeta(a, b)) / a;
+        tail = Math.exp(Math.max(lguess, -745));
+        x0 = Math.min(tail, 0.25);
+    }
+    if (!(tail < 1e-3)) {
+        const g = betaQuantileGuess(a, b, lower, logTarget);
+        if (g !== undefined && g < 0.5)
+            x0 = g;
+    }
+    return invertContinuous({
+        logTarget,
+        ...(linearTarget !== undefined && { linearTarget }),
+        lower,
+        cdf: (x, l) => betaInc(a, b, x, 1 - x, l, false),
+        cdfLog: (x, l) => betaInc(a, b, x, 1 - x, l, true),
+        cdfBoth: (x, l) => betaIncBoth(a, b, x, 1 - x, l),
+        pdfLog: (x) => dbetaLog(x, 1 - x, a, b),
+        dlogPdf: (x) => (a - 1) / x - (b - 1) / (1 - x),
+        x0,
+        lo: 0,
+        hi: 0.5,
+        positive: true,
+    });
+}
+export function qbeta1(p, a, b, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(a) || Number.isNaN(b))
+        return NaN;
+    if (a < 0 || b < 0)
+        return NaN;
+    const bd = quantileBoundaries(p, 0, 1, lowerTail, logP);
+    if (bd !== undefined)
+        return bd;
+    // Point masses when a parameter is 0 or infinite
+    if (a === 0 || b === 0 || !Number.isFinite(a) || !Number.isFinite(b)) {
+        if (a === 0 && b === 0) {
+            const lp = logP ? p : Math.log(p);
+            const lower = lowerTail ? lp : Math.log1p(-Math.exp(lp));
+            if (lower < -Math.LN2)
+                return 0;
+            if (lower > -Math.LN2)
+                return 1;
+            return 0.5;
+        }
+        if (a === 0 || b / a === Infinity)
+            return 0;
+        if (b === 0 || a / b === Infinity)
+            return 1;
+        return 0.5;
+    }
+    const { lower, logTarget, linearTarget } = smallerTail(p, lowerTail, logP);
+    // Decide whether the answer lies left or right of 1/2 by comparing with the distribution function at x = 1/2
+    // (for skewed distributions the answer can be near 0 even when the lower probability exceeds 1/2)
+    const atHalf = betaInc(a, b, 0.5, 0.5, lower, true);
+    const leftHalf = lower ? logTarget <= atHalf : logTarget >= atHalf;
+    if (leftHalf)
+        return solveLeftHalf(a, b, lower, logTarget, linearTarget);
+    // Right half: y = 1 - x lies in (0, 1/2] in frame (b, a), with the tails swapped
+    return 1 - solveLeftHalf(b, a, !lower, logTarget, linearTarget);
+}
+/**
+ * Density of the beta distribution. Equivalent to R's `dbeta(x, shape1, shape2, ncp = 0, log = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral beta distribution.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape1 - First shape parameter (a).
+ * @param shape2 - Second shape parameter (b).
+ * @param options - `ncp` (see {@link NoncentralOption}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function dbeta(x, shape1, shape2, options = {}) {
+    const { log = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(x, (v) => dnbeta1(v, shape1, shape2, ncp, log));
+    return vectorize(x, (v) => dbeta1(v, shape1, shape2, log));
+}
+/**
+ * Distribution function of the beta distribution. Equivalent to R's `pbeta(q, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral beta distribution.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape1 - First shape parameter (a).
+ * @param shape2 - Second shape parameter (b).
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pbeta(0.5, 2, 3); // 0.6875 (up to rounding)
+ * ```
+ */
+export function pbeta(q, shape1, shape2, options = {}) {
+    const { lowerTail = true, logP = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(q, (v) => pnbeta1(v, shape1, shape2, ncp, lowerTail, logP));
+    return vectorize(q, (v) => pbeta1(v, shape1, shape2, lowerTail, logP));
+}
+/**
+ * Quantile function of the beta distribution. Equivalent to R's `qbeta(p, shape1, shape2, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral beta distribution.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape1 - First shape parameter (a).
+ * @param shape2 - Second shape parameter (b).
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ *
+ * @example
+ * ```ts
+ * qbeta(0.025, 3, 7);          // 0.07485463141969181
+ * qbeta([0.025, 0.975], 3, 7); // [0.07485463141969181, 0.6000935737163121]
+ * ```
+ */
+export function qbeta(p, shape1, shape2, options = {}) {
+    const { lowerTail = true, logP = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(p, (v) => qnbeta1(v, shape1, shape2, ncp, lowerTail, logP));
+    return vectorize(p, (v) => qbeta1(v, shape1, shape2, lowerTail, logP));
+}

package/dist/distributions/binomial.d.ts

@@ -0,0 +1,41 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+export declare function dbinom1(x: number, size: number, prob: number, log: boolean): number;
+export declare function pbinom1(q: number, size: number, prob: number, lowerTail: boolean, logP: boolean): number;
+export declare function qbinom1(p: number, size: number, prob: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Probability mass function of the binomial distribution. Equivalent to R's `dbinom(x, size, prob, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Number of trials.
+ * @param prob - Probability of success on each trial.
+ * @param options - `log` (see {@link DensityOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function dbinom<T extends Vectorizable>(x: T, size: number, prob: number, options?: DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the binomial distribution. Equivalent to R's `pbinom(q, size, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Number of trials.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pbinom(3, 10, 0.5);      // 0.171875
+ * pbinom([3, 5], 10, 0.5); // [0.171875, 0.623046875]
+ * ```
+ */
+export declare function pbinom<T extends Vectorizable>(q: T, size: number, prob: number, options?: TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the binomial distribution. Equivalent to R's `qbinom(p, size, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Number of trials.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qbinom<T extends Vectorizable>(p: T, size: number, prob: number, options?: TailOptions): VectorResult<T>;