scipy 1.15.2__cp313-cp313t-win_amd64.whl → 1.16.0rc1__cp313-cp313t-win_amd64.whl

scipy/special/xsf/cephes/ndtr.h

@@ -1,275 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     ndtr.c
- *
- *     Normal distribution function
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, y, ndtr();
- *
- * y = ndtr( x );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the area under the Gaussian probability density
- * function, integrated from minus infinity to x:
- *
- *                            x
- *                             -
- *                   1        | |          2
- *    ndtr(x)  = ---------    |    exp( - t /2 ) dt
- *               sqrt(2pi)  | |
- *                           -
- *                          -inf.
- *
- *             =  ( 1 + erf(z) ) / 2
- *             =  erfc(z) / 2
- *
- * where z = x/sqrt(2). Computation is via the functions
- * erf and erfc.
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain     # trials      peak         rms
- *    IEEE     -13,0        30000       3.4e-14     6.7e-15
- *
- *
- * ERROR MESSAGES:
- *
- *   message         condition         value returned
- * erfc underflow    x > 37.519379347       0.0
- *
- */
-/*							erf.c
- *
- *	Error function
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, y, erf();
- *
- * y = erf( x );
- *
- *
- *
- * DESCRIPTION:
- *
- * The integral is
- *
- *                           x
- *                            -
- *                 2         | |          2
- *   erf(x)  =  --------     |    exp( - t  ) dt.
- *              sqrt(pi)   | |
- *                          -
- *                           0
- *
- * For 0 <= |x| < 1, erf(x) = x * P4(x**2)/Q5(x**2); otherwise
- * erf(x) = 1 - erfc(x).
- *
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain     # trials      peak         rms
- *    IEEE      0,1         30000       3.7e-16     1.0e-16
- *
- */
-/*							erfc.c
- *
- *	Complementary error function
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, y, erfc();
- *
- * y = erfc( x );
- *
- *
- *
- * DESCRIPTION:
- *
- *
- *  1 - erf(x) =
- *
- *                           inf.
- *                             -
- *                  2         | |          2
- *   erfc(x)  =  --------     |    exp( - t  ) dt
- *               sqrt(pi)   | |
- *                           -
- *                            x
- *
- *
- * For small x, erfc(x) = 1 - erf(x); otherwise rational
- * approximations are computed.
- *
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain     # trials      peak         rms
- *    IEEE      0,26.6417   30000       5.7e-14     1.5e-14
- */
-
-/*
- * Cephes Math Library Release 2.2:  June, 1992
- * Copyright 1984, 1987, 1988, 1992 by Stephen L. Moshier
- * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
- */
-#pragma once
-
-#include "../config.h"
-
-#include "const.h"
-#include "polevl.h"
-
-namespace xsf {
-namespace cephes {
-
-    namespace detail {
-
-        constexpr double ndtr_P[] = {2.46196981473530512524E-10, 5.64189564831068821977E-1, 7.46321056442269912687E0,
-                                     4.86371970985681366614E1,   1.96520832956077098242E2,  5.26445194995477358631E2,
-                                     9.34528527171957607540E2,   1.02755188689515710272E3,  5.57535335369399327526E2};
-
-        constexpr double ndtr_Q[] = {
-            /* 1.00000000000000000000E0, */
-            1.32281951154744992508E1, 8.67072140885989742329E1, 3.54937778887819891062E2, 9.75708501743205489753E2,
-            1.82390916687909736289E3, 2.24633760818710981792E3, 1.65666309194161350182E3, 5.57535340817727675546E2};
-
-        constexpr double ndtr_R[] = {5.64189583547755073984E-1, 1.27536670759978104416E0, 5.01905042251180477414E0,
-                                     6.16021097993053585195E0,  7.40974269950448939160E0, 2.97886665372100240670E0};
-
-        constexpr double ndtr_S[] = {
-            /* 1.00000000000000000000E0, */
-            2.26052863220117276590E0, 9.39603524938001434673E0, 1.20489539808096656605E1,
-            1.70814450747565897222E1, 9.60896809063285878198E0, 3.36907645100081516050E0};
-
-        constexpr double ndtr_T[] = {9.60497373987051638749E0, 9.00260197203842689217E1, 2.23200534594684319226E3,
-                                     7.00332514112805075473E3, 5.55923013010394962768E4};
-
-        constexpr double ndtr_U[] = {
-            /* 1.00000000000000000000E0, */
-            3.35617141647503099647E1, 5.21357949780152679795E2, 4.59432382970980127987E3, 2.26290000613890934246E4,
-            4.92673942608635921086E4};
-
-        constexpr double ndtri_UTHRESH = 37.519379347;
-
-    } // namespace detail
-
-    XSF_HOST_DEVICE inline double erf(double x);
-
-    XSF_HOST_DEVICE inline double erfc(double a) {
-        double p, q, x, y, z;
-
-        if (std::isnan(a)) {
-            set_error("erfc", SF_ERROR_DOMAIN, NULL);
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-
-        if (a < 0.0) {
-            x = -a;
-        } else {
-            x = a;
-        }
-
-        if (x < 1.0) {
-            return 1.0 - erf(a);
-        }
-
-        z = -a * a;
-
-        if (z < -detail::MAXLOG) {
-            goto under;
-        }
-
-        z = std::exp(z);
-
-        if (x < 8.0) {
-            p = polevl(x, detail::ndtr_P, 8);
-            q = p1evl(x, detail::ndtr_Q, 8);
-        } else {
-            p = polevl(x, detail::ndtr_R, 5);
-            q = p1evl(x, detail::ndtr_S, 6);
-        }
-        y = (z * p) / q;
-
-        if (a < 0) {
-            y = 2.0 - y;
-        }
-
-        if (y != 0.0) {
-            return y;
-        }
-
-    under:
-        set_error("erfc", SF_ERROR_UNDERFLOW, NULL);
-        if (a < 0) {
-            return 2.0;
-        } else {
-            return 0.0;
-        }
-    }
-
-    XSF_HOST_DEVICE inline double erf(double x) {
-        double y, z;
-
-        if (std::isnan(x)) {
-            set_error("erf", SF_ERROR_DOMAIN, NULL);
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-
-        if (x < 0.0) {
-            return -erf(-x);
-        }
-
-        if (std::abs(x) > 1.0) {
-            return (1.0 - erfc(x));
-        }
-        z = x * x;
-
-        y = x * polevl(z, detail::ndtr_T, 4) / p1evl(z, detail::ndtr_U, 5);
-        return y;
-    }
-
-    XSF_HOST_DEVICE inline double ndtr(double a) {
-        double x, y, z;
-
-        if (std::isnan(a)) {
-            set_error("ndtr", SF_ERROR_DOMAIN, NULL);
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-
-        x = a * M_SQRT1_2;
-        z = std::abs(x);
-
-        if (z < 1.0) {
-            y = 0.5 + 0.5 * erf(x);
-        } else {
-            y = 0.5 * erfc(z);
-            if (x > 0) {
-                y = 1.0 - y;
-            }
-        }
-
-        return y;
-    }
-
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/poch.h

@@ -1,85 +0,0 @@
-/*
- * Pochhammer symbol (a)_m = gamma(a + m) / gamma(a)
- */
-
-#pragma once
-
-#include "../config.h"
-#include "gamma.h"
-
-namespace xsf {
-namespace cephes {
-
-    namespace detail {
-
-        XSF_HOST_DEVICE inline double is_nonpos_int(double x) {
-            return x <= 0 && x == std::ceil(x) && std::abs(x) < 1e13;
-        }
-    } // namespace detail
-
-    XSF_HOST_DEVICE inline double poch(double a, double m) {
-        double r = 1.0;
-
-        /*
-         * 1. Reduce magnitude of `m` to |m| < 1 by using recurrence relations.
-         *
-         * This may end up in over/underflow, but then the function itself either
-         * diverges or goes to zero. In case the remainder goes to the opposite
-         * direction, we end up returning 0*INF = NAN, which is OK.
-         */
-
-        /* Recurse down */
-        while (m >= 1.0) {
-            if (a + m == 1) {
-                break;
-            }
-            m -= 1.0;
-            r *= (a + m);
-            if (!std::isfinite(r) || r == 0) {
-                break;
-            }
-        }
-
-        /* Recurse up */
-        while (m <= -1.0) {
-            if (a + m == 0) {
-                break;
-            }
-            r /= (a + m);
-            m += 1.0;
-            if (!std::isfinite(r) || r == 0) {
-                break;
-            }
-        }
-
-        /*
-         * 2. Evaluate function with reduced `m`
-         *
-         * Now either `m` is not big, or the `r` product has over/underflown.
-         * If so, the function itself does similarly.
-         */
-
-        if (m == 0) {
-            /* Easy case */
-            return r;
-        } else if (a > 1e4 && std::abs(m) <= 1) {
-            /* Avoid loss of precision */
-            return r * std::pow(a, m) *
-                   (1 + m * (m - 1) / (2 * a) + m * (m - 1) * (m - 2) * (3 * m - 1) / (24 * a * a) +
-                    m * m * (m - 1) * (m - 1) * (m - 2) * (m - 3) / (48 * a * a * a));
-        }
-
-        /* Check for infinity */
-        if (detail::is_nonpos_int(a + m) && !detail::is_nonpos_int(a) && a + m != m) {
-            return std::numeric_limits<double>::infinity();
-        }
-
-        /* Check for zero */
-        if (!detail::is_nonpos_int(a + m) && detail::is_nonpos_int(a)) {
-            return 0;
-        }
-
-        return r * std::exp(lgam(a + m) - lgam(a)) * gammasgn(a + m) * gammasgn(a);
-    }
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/polevl.h

@@ -1,167 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     polevl.c
- *                                                     p1evl.c
- *
- *     Evaluate polynomial
- *
- *
- *
- * SYNOPSIS:
- *
- * int N;
- * double x, y, coef[N+1], polevl[];
- *
- * y = polevl( x, coef, N );
- *
- *
- *
- * DESCRIPTION:
- *
- * Evaluates polynomial of degree N:
- *
- *                     2          N
- * y  =  C  + C x + C x  +...+ C x
- *        0    1     2          N
- *
- * Coefficients are stored in reverse order:
- *
- * coef[0] = C  , ..., coef[N] = C  .
- *            N                   0
- *
- * The function p1evl() assumes that c_N = 1.0 so that coefficent
- * is omitted from the array.  Its calling arguments are
- * otherwise the same as polevl().
- *
- *
- * SPEED:
- *
- * In the interest of speed, there are no checks for out
- * of bounds arithmetic.  This routine is used by most of
- * the functions in the library.  Depending on available
- * equipment features, the user may wish to rewrite the
- * program in microcode or assembly language.
- *
- */
-
-/*
- * Cephes Math Library Release 2.1:  December, 1988
- * Copyright 1984, 1987, 1988 by Stephen L. Moshier
- * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
- */
-
-/* Sources:
- * [1] Holin et. al., "Polynomial and Rational Function Evaluation",
- *     https://www.boost.org/doc/libs/1_61_0/libs/math/doc/html/math_toolkit/roots/rational.html
- */
-
-/* Scipy changes:
- * - 06-23-2016: add code for evaluating rational functions
- */
-
-#pragma once
-
-#include "../config.h"
-
-namespace xsf {
-namespace cephes {
-    XSF_HOST_DEVICE inline double polevl(double x, const double coef[], int N) {
-        double ans;
-        int i;
-        const double *p;
-
-        p = coef;
-        ans = *p++;
-        i = N;
-
-        do {
-            ans = ans * x + *p++;
-        } while (--i);
-
-        return (ans);
-    }
-
-    /*                                                     p1evl() */
-    /*                                          N
-     * Evaluate polynomial when coefficient of x  is 1.0.
-     * That is, C_{N} is assumed to be 1, and that coefficient
-     * is not included in the input array coef.
-     * coef must have length N and contain the polynomial coefficients
-     * stored as
-     *     coef[0] = C_{N-1}
-     *     coef[1] = C_{N-2}
-     *          ...
-     *     coef[N-2] = C_1
-     *     coef[N-1] = C_0
-     * Otherwise same as polevl.
-     */
-
-    XSF_HOST_DEVICE inline double p1evl(double x, const double coef[], int N) {
-        double ans;
-        const double *p;
-        int i;
-
-        p = coef;
-        ans = x + *p++;
-        i = N - 1;
-
-        do
-            ans = ans * x + *p++;
-        while (--i);
-
-        return (ans);
-    }
-
-    /* Evaluate a rational function. See [1]. */
-
-    /* The function ratevl is only used once in cephes/lanczos.h. */
-    XSF_HOST_DEVICE inline double ratevl(double x, const double num[], int M, const double denom[], int N) {
-        int i, dir;
-        double y, num_ans, denom_ans;
-        double absx = std::abs(x);
-        const double *p;
-
-        if (absx > 1) {
-            /* Evaluate as a polynomial in 1/x. */
-            dir = -1;
-            p = num + M;
-            y = 1 / x;
-        } else {
-            dir = 1;
-            p = num;
-            y = x;
-        }
-
-        /* Evaluate the numerator */
-        num_ans = *p;
-        p += dir;
-        for (i = 1; i <= M; i++) {
-            num_ans = num_ans * y + *p;
-            p += dir;
-        }
-
-        /* Evaluate the denominator */
-        if (absx > 1) {
-            p = denom + N;
-        } else {
-            p = denom;
-        }
-
-        denom_ans = *p;
-        p += dir;
-        for (i = 1; i <= N; i++) {
-            denom_ans = denom_ans * y + *p;
-            p += dir;
-        }
-
-        if (absx > 1) {
-            i = M - N;
-            return std::pow(x, i) * num_ans / denom_ans;
-        } else {
-            return num_ans / denom_ans;
-        }
-    }
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/psi.h

@@ -1,194 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     psi.c
- *
- *     Psi (digamma) function
- *
- *
- * SYNOPSIS:
- *
- * double x, y, psi();
- *
- * y = psi( x );
- *
- *
- * DESCRIPTION:
- *
- *              d      -
- *   psi(x)  =  -- ln | (x)
- *              dx
- *
- * is the logarithmic derivative of the gamma function.
- * For integer x,
- *                   n-1
- *                    -
- * psi(n) = -EUL  +   >  1/k.
- *                    -
- *                   k=1
- *
- * This formula is used for 0 < n <= 10.  If x is negative, it
- * is transformed to a positive argument by the reflection
- * formula  psi(1-x) = psi(x) + pi cot(pi x).
- * For general positive x, the argument is made greater than 10
- * using the recurrence  psi(x+1) = psi(x) + 1/x.
- * Then the following asymptotic expansion is applied:
- *
- *                           inf.   B
- *                            -      2k
- * psi(x) = log(x) - 1/2x -   >   -------
- *                            -        2k
- *                           k=1   2k x
- *
- * where the B2k are Bernoulli numbers.
- *
- * ACCURACY:
- *    Relative error (except absolute when |psi| < 1):
- * arithmetic   domain     # trials      peak         rms
- *    IEEE      0,30        30000       1.3e-15     1.4e-16
- *    IEEE      -30,0       40000       1.5e-15     2.2e-16
- *
- * ERROR MESSAGES:
- *     message         condition      value returned
- * psi singularity    x integer <=0      INFINITY
- */
-
-/*
- * Cephes Math Library Release 2.8:  June, 2000
- * Copyright 1984, 1987, 1992, 2000 by Stephen L. Moshier
- */
-
-/*
- * Code for the rational approximation on [1, 2] is:
- *
- * (C) Copyright John Maddock 2006.
- * Use, modification and distribution are subject to the
- * Boost Software License, Version 1.0. (See accompanying file
- * LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
- */
-#pragma once
-
-#include "../config.h"
-#include "../error.h"
-#include "const.h"
-#include "polevl.h"
-
-namespace xsf {
-namespace cephes {
-    namespace detail {
-        constexpr double psi_A[] = {8.33333333333333333333E-2,  -2.10927960927960927961E-2, 7.57575757575757575758E-3,
-                                    -4.16666666666666666667E-3, 3.96825396825396825397E-3,  -8.33333333333333333333E-3,
-                                    8.33333333333333333333E-2};
-
-        constexpr float psi_Y = 0.99558162689208984f;
-
-        constexpr double psi_root1 = 1569415565.0 / 1073741824.0;
-        constexpr double psi_root2 = (381566830.0 / 1073741824.0) / 1073741824.0;
-        constexpr double psi_root3 = 0.9016312093258695918615325266959189453125e-19;
-
-        constexpr double psi_P[] = {-0.0020713321167745952, -0.045251321448739056, -0.28919126444774784,
-                                    -0.65031853770896507,   -0.32555031186804491,  0.25479851061131551};
-        constexpr double psi_Q[] = {-0.55789841321675513e-6,
-                                    0.0021284987017821144,
-                                    0.054151797245674225,
-                                    0.43593529692665969,
-                                    1.4606242909763515,
-                                    2.0767117023730469,
-                                    1.0};
-
-        XSF_HOST_DEVICE double digamma_imp_1_2(double x) {
-            /*
-             * Rational approximation on [1, 2] taken from Boost.
-             *
-             * Now for the approximation, we use the form:
-             *
-             * digamma(x) = (x - root) * (Y + R(x-1))
-             *
-             * Where root is the location of the positive root of digamma,
-             * Y is a constant, and R is optimised for low absolute error
-             * compared to Y.
-             *
-             * Maximum Deviation Found:               1.466e-18
-             * At double precision, max error found:  2.452e-17
-             */
-            double r, g;
-
-            g = x - psi_root1;
-            g -= psi_root2;
-            g -= psi_root3;
-            r = xsf::cephes::polevl(x - 1.0, psi_P, 5) / xsf::cephes::polevl(x - 1.0, psi_Q, 6);
-
-            return g * psi_Y + g * r;
-        }
-
-        XSF_HOST_DEVICE double psi_asy(double x) {
-            double y, z;
-
-            if (x < 1.0e17) {
-                z = 1.0 / (x * x);
-                y = z * xsf::cephes::polevl(z, psi_A, 6);
-            } else {
-                y = 0.0;
-            }
-
-            return std::log(x) - (0.5 / x) - y;
-        }
-    } // namespace detail
-
-    XSF_HOST_DEVICE double psi(double x) {
-        double y = 0.0;
-        double q, r;
-        int i, n;
-
-        if (std::isnan(x)) {
-            return x;
-        } else if (x == std::numeric_limits<double>::infinity()) {
-            return x;
-        } else if (x == -std::numeric_limits<double>::infinity()) {
-            return std::numeric_limits<double>::quiet_NaN();
-        } else if (x == 0) {
-            set_error("psi", SF_ERROR_SINGULAR, NULL);
-            return std::copysign(std::numeric_limits<double>::infinity(), -x);
-        } else if (x < 0.0) {
-            /* argument reduction before evaluating tan(pi * x) */
-            r = std::modf(x, &q);
-            if (r == 0.0) {
-                set_error("psi", SF_ERROR_SINGULAR, NULL);
-                return std::numeric_limits<double>::quiet_NaN();
-            }
-            y = -M_PI / std::tan(M_PI * r);
-            x = 1.0 - x;
-        }
-
-        /* check for positive integer up to 10 */
-        if ((x <= 10.0) && (x == std::floor(x))) {
-            n = static_cast<int>(x);
-            for (i = 1; i < n; i++) {
-                y += 1.0 / i;
-            }
-            y -= detail::SCIPY_EULER;
-            return y;
-        }
-
-        /* use the recurrence relation to move x into [1, 2] */
-        if (x < 1.0) {
-            y -= 1.0 / x;
-            x += 1.0;
-        } else if (x < 10.0) {
-            while (x > 2.0) {
-                x -= 1.0;
-                y += 1.0 / x;
-            }
-        }
-        if ((1.0 <= x) && (x <= 2.0)) {
-            y += detail::digamma_imp_1_2(x);
-            return y;
-        }
-
-        /* x is large, use the asymptotic series */
-        y += detail::psi_asy(x);
-        return y;
-    }
-} // namespace cephes
-} // namespace xsf