scipy 1.15.3__cp311-cp311-musllinux_1_2_aarch64.whl → 1.16.0__cp311-cp311-musllinux_1_2_aarch64.whl

scipy/special/xsf/cephes/beta.h

@@ -1,257 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     beta.c
- *
- *     Beta function
- *
- *
- *
- * SYNOPSIS:
- *
- * double a, b, y, beta();
- *
- * y = beta( a, b );
- *
- *
- *
- * DESCRIPTION:
- *
- *                   -     -
- *                  | (a) | (b)
- * beta( a, b )  =  -----------.
- *                     -
- *                    | (a+b)
- *
- * For large arguments the logarithm of the function is
- * evaluated using lgam(), then exponentiated.
- *
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain     # trials      peak         rms
- *    IEEE       0,30       30000       8.1e-14     1.1e-14
- *
- * ERROR MESSAGES:
- *
- *   message         condition          value returned
- * beta overflow    log(beta) > MAXLOG       0.0
- *                  a or b <0 integer        0.0
- *
- */
-
-/*
- * Cephes Math Library Release 2.0:  April, 1987
- * Copyright 1984, 1987 by Stephen L. Moshier
- * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
- */
-#pragma once
-
-#include "../config.h"
-#include "const.h"
-#include "gamma.h"
-#include "rgamma.h"
-
-namespace xsf {
-namespace cephes {
-
-    XSF_HOST_DEVICE double beta(double, double);
-    XSF_HOST_DEVICE double lbeta(double, double);
-
-    namespace detail {
-        constexpr double beta_ASYMP_FACTOR = 1e6;
-
-        /*
-         * Asymptotic expansion for  ln(|B(a, b)|) for a > ASYMP_FACTOR*max(|b|, 1).
-         */
-        XSF_HOST_DEVICE inline double lbeta_asymp(double a, double b, int *sgn) {
-            double r = lgam_sgn(b, sgn);
-            r -= b * std::log(a);
-
-            r += b * (1 - b) / (2 * a);
-            r += b * (1 - b) * (1 - 2 * b) / (12 * a * a);
-            r += -b * b * (1 - b) * (1 - b) / (12 * a * a * a);
-
-            return r;
-        }
-
-        /*
-         * Special case for a negative integer argument
-         */
-
-        XSF_HOST_DEVICE inline double beta_negint(int a, double b) {
-            int sgn;
-            if (b == static_cast<int>(b) && 1 - a - b > 0) {
-                sgn = (static_cast<int>(b) % 2 == 0) ? 1 : -1;
-                return sgn * xsf::cephes::beta(1 - a - b, b);
-            } else {
-                set_error("lbeta", SF_ERROR_OVERFLOW, NULL);
-                return std::numeric_limits<double>::infinity();
-            }
-        }
-
-        XSF_HOST_DEVICE inline double lbeta_negint(int a, double b) {
-            double r;
-            if (b == static_cast<int>(b) && 1 - a - b > 0) {
-                r = xsf::cephes::lbeta(1 - a - b, b);
-                return r;
-            } else {
-                set_error("lbeta", SF_ERROR_OVERFLOW, NULL);
-                return std::numeric_limits<double>::infinity();
-            }
-        }
-    } // namespace detail
-
-    XSF_HOST_DEVICE inline double beta(double a, double b) {
-        double y;
-        int sign = 1;
-
-        if (a <= 0.0) {
-            if (a == std::floor(a)) {
-                if (a == static_cast<int>(a)) {
-                    return detail::beta_negint(static_cast<int>(a), b);
-                } else {
-                    goto overflow;
-                }
-            }
-        }
-
-        if (b <= 0.0) {
-            if (b == std::floor(b)) {
-                if (b == static_cast<int>(b)) {
-                    return detail::beta_negint(static_cast<int>(b), a);
-                } else {
-                    goto overflow;
-                }
-            }
-        }
-
-        if (std::abs(a) < std::abs(b)) {
-            y = a;
-            a = b;
-            b = y;
-        }
-
-        if (std::abs(a) > detail::beta_ASYMP_FACTOR * std::abs(b) && a > detail::beta_ASYMP_FACTOR) {
-            /* Avoid loss of precision in lgam(a + b) - lgam(a) */
-            y = detail::lbeta_asymp(a, b, &sign);
-            return sign * std::exp(y);
-        }
-
-        y = a + b;
-        if (std::abs(y) > detail::MAXGAM || std::abs(a) > detail::MAXGAM || std::abs(b) > detail::MAXGAM) {
-            int sgngam;
-            y = detail::lgam_sgn(y, &sgngam);
-            sign *= sgngam; /* keep track of the sign */
-            y = detail::lgam_sgn(b, &sgngam) - y;
-            sign *= sgngam;
-            y = detail::lgam_sgn(a, &sgngam) + y;
-            sign *= sgngam;
-            if (y > detail::MAXLOG) {
-                goto overflow;
-            }
-            return (sign * std::exp(y));
-        }
-
-        y = rgamma(y);
-        a = Gamma(a);
-        b = Gamma(b);
-        if (std::isinf(y)) {
-            goto overflow;
-	}
-
-        if (std::abs(std::abs(a*y) - 1.0) > std::abs(std::abs(b*y) - 1.0)) {
-            y = b * y;
-            y *= a;
-        } else {
-            y = a * y;
-            y *= b;
-        }
-
-        return (y);
-
-    overflow:
-        set_error("beta", SF_ERROR_OVERFLOW, NULL);
-        return (sign * std::numeric_limits<double>::infinity());
-    }
-
-    /* Natural log of |beta|. */
-
-    XSF_HOST_DEVICE inline double lbeta(double a, double b) {
-        double y;
-        int sign;
-
-        sign = 1;
-
-        if (a <= 0.0) {
-            if (a == std::floor(a)) {
-                if (a == static_cast<int>(a)) {
-                    return detail::lbeta_negint(static_cast<int>(a), b);
-                } else {
-                    goto over;
-                }
-            }
-        }
-
-        if (b <= 0.0) {
-            if (b == std::floor(b)) {
-                if (b == static_cast<int>(b)) {
-                    return detail::lbeta_negint(static_cast<int>(b), a);
-                } else {
-                    goto over;
-                }
-            }
-        }
-
-        if (std::abs(a) < std::abs(b)) {
-            y = a;
-            a = b;
-            b = y;
-        }
-
-        if (std::abs(a) > detail::beta_ASYMP_FACTOR * std::abs(b) && a > detail::beta_ASYMP_FACTOR) {
-            /* Avoid loss of precision in lgam(a + b) - lgam(a) */
-            y = detail::lbeta_asymp(a, b, &sign);
-            return y;
-        }
-
-        y = a + b;
-        if (std::abs(y) > detail::MAXGAM || std::abs(a) > detail::MAXGAM || std::abs(b) > detail::MAXGAM) {
-            int sgngam;
-            y = detail::lgam_sgn(y, &sgngam);
-            sign *= sgngam; /* keep track of the sign */
-            y = detail::lgam_sgn(b, &sgngam) - y;
-            sign *= sgngam;
-            y = detail::lgam_sgn(a, &sgngam) + y;
-            sign *= sgngam;
-            return (y);
-        }
-
-        y = rgamma(y);
-        a = Gamma(a);
-        b = Gamma(b);
-        if (std::isinf(y)) {
-        over:
-            set_error("lbeta", SF_ERROR_OVERFLOW, NULL);
-            return (sign * std::numeric_limits<double>::infinity());
-        }
-
-        if (std::abs(std::abs(a*y) - 1.0) > std::abs(std::abs(b*y) - 1.0)) {
-            y = b * y;
-            y *= a;
-        } else {
-            y = a * y;
-            y *= b;
-        }
-
-        if (y < 0) {
-            y = -y;
-        }
-
-        return (std::log(y));
-    }
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/cbrt.h

@@ -1,131 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     cbrt.c
- *
- *     Cube root
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, y, cbrt();
- *
- * y = cbrt( x );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the cube root of the argument, which may be negative.
- *
- * Range reduction involves determining the power of 2 of
- * the argument.  A polynomial of degree 2 applied to the
- * mantissa, and multiplication by the cube root of 1, 2, or 4
- * approximates the root to within about 0.1%.  Then Newton's
- * iteration is used three times to converge to an accurate
- * result.
- *
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain     # trials      peak         rms
- *    IEEE       0,1e308     30000      1.5e-16     5.0e-17
- *
- */
-/*							cbrt.c  */
-
-/*
- * Cephes Math Library Release 2.2:  January, 1991
- * Copyright 1984, 1991 by Stephen L. Moshier
- * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
- */
-#pragma once
-
-#include "../config.h"
-
-namespace xsf {
-namespace cephes {
-
-    namespace detail {
-
-        constexpr double CBRT2 = 1.2599210498948731647672;
-        constexpr double CBRT4 = 1.5874010519681994747517;
-        constexpr double CBRT2I = 0.79370052598409973737585;
-        constexpr double CBRT4I = 0.62996052494743658238361;
-
-        XSF_HOST_DEVICE inline double cbrt(double x) {
-            int e, rem, sign;
-            double z;
-
-            if (!std::isfinite(x)) {
-                return x;
-            }
-            if (x == 0) {
-                return (x);
-            }
-            if (x > 0) {
-                sign = 1;
-            } else {
-                sign = -1;
-                x = -x;
-            }
-
-            z = x;
-            /* extract power of 2, leaving
-             * mantissa between 0.5 and 1
-             */
-            x = std::frexp(x, &e);
-
-            /* Approximate cube root of number between .5 and 1,
-             * peak relative error = 9.2e-6
-             */
-            x = (((-1.3466110473359520655053e-1 * x + 5.4664601366395524503440e-1) * x - 9.5438224771509446525043e-1) *
-                     x +
-                 1.1399983354717293273738e0) *
-                    x +
-                4.0238979564544752126924e-1;
-
-            /* exponent divided by 3 */
-            if (e >= 0) {
-                rem = e;
-                e /= 3;
-                rem -= 3 * e;
-                if (rem == 1) {
-                    x *= CBRT2;
-                } else if (rem == 2) {
-                    x *= CBRT4;
-                }
-            }
-            /* argument less than 1 */
-            else {
-                e = -e;
-                rem = e;
-                e /= 3;
-                rem -= 3 * e;
-                if (rem == 1) {
-                    x *= CBRT2I;
-                } else if (rem == 2) {
-                    x *= CBRT4I;
-                }
-                e = -e;
-            }
-
-            /* multiply by power of 2 */
-            x = std::ldexp(x, e);
-
-            /* Newton iteration */
-            x -= (x - (z / (x * x))) * 0.33333333333333333333;
-            x -= (x - (z / (x * x))) * 0.33333333333333333333;
-
-            if (sign < 0)
-                x = -x;
-            return (x);
-        }
-    } // namespace detail
-
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/chbevl.h

@@ -1,85 +0,0 @@
-/*                                                     chbevl.c
- *
- *     Evaluate Chebyshev series
- *
- *
- *
- * SYNOPSIS:
- *
- * int N;
- * double x, y, coef[N], chebevl();
- *
- * y = chbevl( x, coef, N );
- *
- *
- *
- * DESCRIPTION:
- *
- * Evaluates the series
- *
- *        N-1
- *         - '
- *  y  =   >   coef[i] T (x/2)
- *         -            i
- *        i=0
- *
- * of Chebyshev polynomials Ti at argument x/2.
- *
- * Coefficients are stored in reverse order, i.e. the zero
- * order term is last in the array.  Note N is the number of
- * coefficients, not the order.
- *
- * If coefficients are for the interval a to b, x must
- * have been transformed to x -> 2(2x - b - a)/(b-a) before
- * entering the routine.  This maps x from (a, b) to (-1, 1),
- * over which the Chebyshev polynomials are defined.
- *
- * If the coefficients are for the inverted interval, in
- * which (a, b) is mapped to (1/b, 1/a), the transformation
- * required is x -> 2(2ab/x - b - a)/(b-a).  If b is infinity,
- * this becomes x -> 4a/x - 1.
- *
- *
- *
- * SPEED:
- *
- * Taking advantage of the recurrence properties of the
- * Chebyshev polynomials, the routine requires one more
- * addition per loop than evaluating a nested polynomial of
- * the same degree.
- *
- */
-/*							chbevl.c	*/
-
-/*
- * Cephes Math Library Release 2.0:  April, 1987
- * Copyright 1985, 1987 by Stephen L. Moshier
- * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
- */
-#pragma once
-
-#include "../config.h"
-
-namespace xsf {
-namespace cephes {
-
-    XSF_HOST_DEVICE double chbevl(double x, const double array[], int n) {
-        double b0, b1, b2;
-        const double *p;
-        int i;
-
-        p = array;
-        b0 = *p++;
-        b1 = 0.0;
-        i = n - 1;
-
-        do {
-            b2 = b1;
-            b1 = b0;
-            b0 = x * b1 - b2 + *p++;
-        } while (--i);
-
-        return (0.5 * (b0 - b2));
-    }
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/chdtr.h

@@ -1,193 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     chdtr.c
- *
- *     Chi-square distribution
- *
- *
- *
- * SYNOPSIS:
- *
- * double df, x, y, chdtr();
- *
- * y = chdtr( df, x );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the area under the left hand tail (from 0 to x)
- * of the Chi square probability density function with
- * v degrees of freedom.
- *
- *
- *                                  inf.
- *                                    -
- *                        1          | |  v/2-1  -t/2
- *  P( x | v )   =   -----------     |   t      e     dt
- *                    v/2  -       | |
- *                   2    | (v/2)   -
- *                                   x
- *
- * where x is the Chi-square variable.
- *
- * The incomplete Gamma integral is used, according to the
- * formula
- *
- *     y = chdtr( v, x ) = igam( v/2.0, x/2.0 ).
- *
- *
- * The arguments must both be positive.
- *
- *
- *
- * ACCURACY:
- *
- * See igam().
- *
- * ERROR MESSAGES:
- *
- *   message         condition      value returned
- * chdtr domain   x < 0 or v < 1        0.0
- */
-/*							chdtrc()
- *
- *	Complemented Chi-square distribution
- *
- *
- *
- * SYNOPSIS:
- *
- * double v, x, y, chdtrc();
- *
- * y = chdtrc( v, x );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the area under the right hand tail (from x to
- * infinity) of the Chi square probability density function
- * with v degrees of freedom:
- *
- *
- *                                  inf.
- *                                    -
- *                        1          | |  v/2-1  -t/2
- *  P( x | v )   =   -----------     |   t      e     dt
- *                    v/2  -       | |
- *                   2    | (v/2)   -
- *                                   x
- *
- * where x is the Chi-square variable.
- *
- * The incomplete Gamma integral is used, according to the
- * formula
- *
- *	y = chdtr( v, x ) = igamc( v/2.0, x/2.0 ).
- *
- *
- * The arguments must both be positive.
- *
- *
- *
- * ACCURACY:
- *
- * See igamc().
- *
- * ERROR MESSAGES:
- *
- *   message         condition      value returned
- * chdtrc domain  x < 0 or v < 1        0.0
- */
-/*							chdtri()
- *
- *	Inverse of complemented Chi-square distribution
- *
- *
- *
- * SYNOPSIS:
- *
- * double df, x, y, chdtri();
- *
- * x = chdtri( df, y );
- *
- *
- *
- *
- * DESCRIPTION:
- *
- * Finds the Chi-square argument x such that the integral
- * from x to infinity of the Chi-square density is equal
- * to the given cumulative probability y.
- *
- * This is accomplished using the inverse Gamma integral
- * function and the relation
- *
- *    x/2 = igamci( df/2, y );
- *
- *
- *
- *
- * ACCURACY:
- *
- * See igami.c.
- *
- * ERROR MESSAGES:
- *
- *   message         condition      value returned
- * chdtri domain   y < 0 or y > 1        0.0
- *                     v < 1
- *
- */
-
-/*                                                             chdtr() */
-
-/*
- * Cephes Math Library Release 2.0:  April, 1987
- * Copyright 1984, 1987 by Stephen L. Moshier
- * Direct inquiries to 30 Frost Street, Cambridge, MA 02140
- */
-#pragma once
-
-#include "../config.h"
-#include "../error.h"
-
-#include "igam.h"
-#include "igami.h"
-
-namespace xsf {
-namespace cephes {
-
-    XSF_HOST_DEVICE inline double chdtrc(double df, double x) {
-
-        if (x < 0.0)
-            return 1.0; /* modified by T. Oliphant */
-        return (igamc(df / 2.0, x / 2.0));
-    }
-
-    XSF_HOST_DEVICE inline double chdtr(double df, double x) {
-
-        if ((x < 0.0)) { /* || (df < 1.0) ) */
-            set_error("chdtr", SF_ERROR_DOMAIN, NULL);
-            return (std::numeric_limits<double>::quiet_NaN());
-        }
-        return (igam(df / 2.0, x / 2.0));
-    }
-
-    XSF_HOST_DEVICE double chdtri(double df, double y) {
-        double x;
-
-        if ((y < 0.0) || (y > 1.0)) { /* || (df < 1.0) ) */
-            set_error("chdtri", SF_ERROR_DOMAIN, NULL);
-            return (std::numeric_limits<double>::quiet_NaN());
-        }
-
-        x = igamci(0.5 * df, y);
-        return (2.0 * x);
-    }
-
-} // namespace cephes
-} // namespace xsf