scipy 1.15.3__cp312-cp312-macosx_12_0_arm64.whl → 1.16.0rc1__cp312-cp312-macosx_12_0_arm64.whl

scipy/special/xsf/cephes/tandg.h

@@ -1,139 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     tandg.c
- *
- *     Circular tangent of argument in degrees
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, y, tandg();
- *
- * y = tandg( x );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the circular tangent of the argument x in degrees.
- *
- * Range reduction is modulo pi/4.  A rational function
- *       x + x**3 P(x**2)/Q(x**2)
- * is employed in the basic interval [0, pi/4].
- *
- *
- *
- * ACCURACY:
- *
- *                      Relative error:
- * arithmetic   domain     # trials      peak         rms
- *    IEEE     0,10         30000      3.2e-16      8.4e-17
- *
- * ERROR MESSAGES:
- *
- *   message         condition          value returned
- * tandg total loss   x > 1.0e14 (IEEE)     0.0
- * tandg singularity  x = 180 k  +  90     INFINITY
- */
-/*							cotdg.c
- *
- *	Circular cotangent of argument in degrees
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, y, cotdg();
- *
- * y = cotdg( x );
- *
- *
- *
- * DESCRIPTION:
- *
- * Returns the circular cotangent of the argument x in degrees.
- *
- * Range reduction is modulo pi/4.  A rational function
- *       x + x**3 P(x**2)/Q(x**2)
- * is employed in the basic interval [0, pi/4].
- *
- *
- * ERROR MESSAGES:
- *
- *   message         condition          value returned
- * cotdg total loss   x > 1.0e14 (IEEE)     0.0
- * cotdg singularity  x = 180 k            INFINITY
- */
-
-/*
- * 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"
-
-namespace xsf {
-namespace cephes {
-
-    namespace detail {
-        constexpr double tandg_lossth = 1.0e14;
-
-        XSF_HOST_DEVICE inline double tancot(double xx, int cotflg) {
-            double x;
-            int sign;
-
-            /* make argument positive but save the sign */
-            if (xx < 0) {
-                x = -xx;
-                sign = -1;
-            } else {
-                x = xx;
-                sign = 1;
-            }
-
-            if (x > detail::tandg_lossth) {
-                set_error("tandg", SF_ERROR_NO_RESULT, NULL);
-                return 0.0;
-            }
-
-            /* modulo 180 */
-            x = x - 180.0 * std::floor(x / 180.0);
-            if (cotflg) {
-                if (x <= 90.0) {
-                    x = 90.0 - x;
-                } else {
-                    x = x - 90.0;
-                    sign *= -1;
-                }
-            } else {
-                if (x > 90.0) {
-                    x = 180.0 - x;
-                    sign *= -1;
-                }
-            }
-            if (x == 0.0) {
-                return 0.0;
-            } else if (x == 45.0) {
-                return sign * 1.0;
-            } else if (x == 90.0) {
-                set_error((cotflg ? "cotdg" : "tandg"), SF_ERROR_SINGULAR, NULL);
-                return std::numeric_limits<double>::infinity();
-            }
-            /* x is now transformed into [0, 90) */
-            return sign * std::tan(x * detail::PI180);
-        }
-
-    } // namespace detail
-
-    XSF_HOST_DEVICE inline double tandg(double x) { return (detail::tancot(x, 0)); }
-
-    XSF_HOST_DEVICE inline double cotdg(double x) { return (detail::tancot(x, 1)); }
-
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/trig.h

@@ -1,58 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- *
- * Original author: Josh Wilson, 2020.
- */
-
-/*
- * Implement sin(pi * x) and cos(pi * x) for real x. Since the periods
- * of these functions are integral (and thus representable in double
- * precision), it's possible to compute them with greater accuracy
- * than sin(x) and cos(x).
- */
-#pragma once
-
-#include "../config.h"
-
-namespace xsf {
-namespace cephes {
-
-    /* Compute sin(pi * x). */
-    template <typename T>
-    XSF_HOST_DEVICE T sinpi(T x) {
-        T s = 1.0;
-
-        if (x < 0.0) {
-            x = -x;
-            s = -1.0;
-        }
-
-        T r = std::fmod(x, 2.0);
-        if (r < 0.5) {
-            return s * std::sin(M_PI * r);
-        } else if (r > 1.5) {
-            return s * std::sin(M_PI * (r - 2.0));
-        } else {
-            return -s * std::sin(M_PI * (r - 1.0));
-        }
-    }
-
-    /* Compute cos(pi * x) */
-    template <typename T>
-    XSF_HOST_DEVICE T cospi(T x) {
-        if (x < 0.0) {
-            x = -x;
-        }
-
-        T r = std::fmod(x, 2.0);
-        if (r == 0.5) {
-            // We don't want to return -0.0
-            return 0.0;
-        }
-        if (r < 1.0) {
-            return -std::sin(M_PI * (r - 0.5));
-        } else {
-            return std::sin(M_PI * (r - 1.5));
-        }
-    }
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/unity.h

@@ -1,186 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024. */
-
-/*                                                     unity.c
- *
- * Relative error approximations for function arguments near
- * unity.
- *
- *    log1p(x) = log(1+x)
- *    expm1(x) = exp(x) - 1
- *    cosm1(x) = cos(x) - 1
- *    lgam1p(x) = lgam(1+x)
- *
- */
-
-/* Scipy changes:
- * - 06-10-2016: added lgam1p
- */
-#pragma once
-
-#include "../config.h"
-
-#include "const.h"
-#include "gamma.h"
-#include "polevl.h"
-#include "zeta.h"
-
-namespace xsf {
-namespace cephes {
-
-    namespace detail {
-
-        /* log1p(x) = log(1 + x)  */
-
-        /* Coefficients for log(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
-         * 1/sqrt(2) <= x < sqrt(2)
-         * Theoretical peak relative error = 2.32e-20
-         */
-
-        constexpr double unity_LP[] = {
-            4.5270000862445199635215E-5, 4.9854102823193375972212E-1, 6.5787325942061044846969E0,
-            2.9911919328553073277375E1,  6.0949667980987787057556E1,  5.7112963590585538103336E1,
-            2.0039553499201281259648E1,
-        };
-
-        constexpr double unity_LQ[] = {
-            /* 1.0000000000000000000000E0, */
-            1.5062909083469192043167E1, 8.3047565967967209469434E1, 2.2176239823732856465394E2,
-            3.0909872225312059774938E2, 2.1642788614495947685003E2, 6.0118660497603843919306E1,
-        };
-
-    } // namespace detail
-
-    XSF_HOST_DEVICE inline double log1p(double x) {
-        double z;
-
-        z = 1.0 + x;
-        if ((z < M_SQRT1_2) || (z > M_SQRT2))
-            return (std::log(z));
-        z = x * x;
-        z = -0.5 * z + x * (z * polevl(x, detail::unity_LP, 6) / p1evl(x, detail::unity_LQ, 6));
-        return (x + z);
-    }
-
-    /* log(1 + x) - x */
-    XSF_HOST_DEVICE inline double log1pmx(double x) {
-        if (std::abs(x) < 0.5) {
-            uint64_t n;
-            double xfac = x;
-            double term;
-            double res = 0;
-
-            for (n = 2; n < detail::MAXITER; n++) {
-                xfac *= -x;
-                term = xfac / n;
-                res += term;
-                if (std::abs(term) < detail::MACHEP * std::abs(res)) {
-                    break;
-                }
-            }
-            return res;
-        } else {
-            return log1p(x) - x;
-        }
-    }
-
-    /* expm1(x) = exp(x) - 1  */
-
-    /*  e^x =  1 + 2x P(x^2)/( Q(x^2) - P(x^2) )
-     * -0.5 <= x <= 0.5
-     */
-
-    namespace detail {
-
-        constexpr double unity_EP[3] = {
-            1.2617719307481059087798E-4,
-            3.0299440770744196129956E-2,
-            9.9999999999999999991025E-1,
-        };
-
-        constexpr double unity_EQ[4] = {
-            3.0019850513866445504159E-6,
-            2.5244834034968410419224E-3,
-            2.2726554820815502876593E-1,
-            2.0000000000000000000897E0,
-        };
-
-    } // namespace detail
-
-    XSF_HOST_DEVICE inline double expm1(double x) {
-        double r, xx;
-
-        if (!std::isfinite(x)) {
-            if (std::isnan(x)) {
-                return x;
-            } else if (x > 0) {
-                return x;
-            } else {
-                return -1.0;
-            }
-        }
-        if ((x < -0.5) || (x > 0.5))
-            return (std::exp(x) - 1.0);
-        xx = x * x;
-        r = x * polevl(xx, detail::unity_EP, 2);
-        r = r / (polevl(xx, detail::unity_EQ, 3) - r);
-        return (r + r);
-    }
-
-    /* cosm1(x) = cos(x) - 1  */
-
-    namespace detail {
-        constexpr double unity_coscof[7] = {
-            4.7377507964246204691685E-14, -1.1470284843425359765671E-11, 2.0876754287081521758361E-9,
-            -2.7557319214999787979814E-7, 2.4801587301570552304991E-5,   -1.3888888888888872993737E-3,
-            4.1666666666666666609054E-2,
-        };
-
-    }
-
-    XSF_HOST_DEVICE inline double cosm1(double x) {
-        double xx;
-
-        if ((x < -M_PI_4) || (x > M_PI_4))
-            return (std::cos(x) - 1.0);
-        xx = x * x;
-        xx = -0.5 * xx + xx * xx * polevl(xx, detail::unity_coscof, 6);
-        return xx;
-    }
-
-    namespace detail {
-        /* Compute lgam(x + 1) around x = 0 using its Taylor series. */
-        XSF_HOST_DEVICE inline double lgam1p_taylor(double x) {
-            int n;
-            double xfac, coeff, res;
-
-            if (x == 0) {
-                return 0;
-            }
-            res = -SCIPY_EULER * x;
-            xfac = -x;
-            for (n = 2; n < 42; n++) {
-                xfac *= -x;
-                coeff = xsf::cephes::zeta(n, 1) * xfac / n;
-                res += coeff;
-                if (std::abs(coeff) < detail::MACHEP * std::abs(res)) {
-                    break;
-                }
-            }
-
-            return res;
-        }
-    } // namespace detail
-
-    /* Compute lgam(x + 1). */
-    XSF_HOST_DEVICE inline double lgam1p(double x) {
-        if (std::abs(x) <= 0.5) {
-            return detail::lgam1p_taylor(x);
-        } else if (std::abs(x - 1) < 0.5) {
-            return std::log(x) + detail::lgam1p_taylor(x - 1);
-        } else {
-            return lgam(x + 1);
-        }
-    }
-
-} // namespace cephes
-} // namespace xsf

scipy/special/xsf/cephes/zeta.h

@@ -1,172 +0,0 @@
-/* Translated into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/*                                                     zeta.c
- *
- *     Riemann zeta function of two arguments
- *
- *
- *
- * SYNOPSIS:
- *
- * double x, q, y, zeta();
- *
- * y = zeta( x, q );
- *
- *
- *
- * DESCRIPTION:
- *
- *
- *
- *                 inf.
- *                  -        -x
- *   zeta(x,q)  =   >   (k+q)
- *                  -
- *                 k=0
- *
- * where x > 1 and q is not a negative integer or zero.
- * The Euler-Maclaurin summation formula is used to obtain
- * the expansion
- *
- *                n
- *                -       -x
- * zeta(x,q)  =   >  (k+q)
- *                -
- *               k=1
- *
- *           1-x                 inf.  B   x(x+1)...(x+2j)
- *      (n+q)           1         -     2j
- *  +  ---------  -  -------  +   >    --------------------
- *        x-1              x      -                   x+2j+1
- *                   2(n+q)      j=1       (2j)! (n+q)
- *
- * where the B2j are Bernoulli numbers.  Note that (see zetac.c)
- * zeta(x,1) = zetac(x) + 1.
- *
- *
- *
- * ACCURACY:
- *
- *
- *
- * REFERENCE:
- *
- * Gradshteyn, I. S., and I. M. Ryzhik, Tables of Integrals,
- * Series, and Products, p. 1073; Academic Press, 1980.
- *
- */
-
-/*
- * 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 "const.h"
-
-namespace xsf {
-namespace cephes {
-
-    namespace detail {
-        /* Expansion coefficients
-         * for Euler-Maclaurin summation formula
-         * (2k)! / B2k
-         * where B2k are Bernoulli numbers
-         */
-        constexpr double zeta_A[] = {
-            12.0,
-            -720.0,
-            30240.0,
-            -1209600.0,
-            47900160.0,
-            -1.8924375803183791606e9, /*1.307674368e12/691 */
-            7.47242496e10,
-            -2.950130727918164224e12,  /*1.067062284288e16/3617 */
-            1.1646782814350067249e14,  /*5.109094217170944e18/43867 */
-            -4.5979787224074726105e15, /*8.028576626982912e20/174611 */
-            1.8152105401943546773e17,  /*1.5511210043330985984e23/854513 */
-            -7.1661652561756670113e18  /*1.6938241367317436694528e27/236364091 */
-        };
-
-        /* 30 Nov 86 -- error in third coefficient fixed */
-    } // namespace detail
-
-    XSF_HOST_DEVICE double inline zeta(double x, double q) {
-        int i;
-        double a, b, k, s, t, w;
-
-        if (x == 1.0)
-            goto retinf;
-
-        if (x < 1.0) {
-        domerr:
-            set_error("zeta", SF_ERROR_DOMAIN, NULL);
-            return (std::numeric_limits<double>::quiet_NaN());
-        }
-
-        if (q <= 0.0) {
-            if (q == floor(q)) {
-                set_error("zeta", SF_ERROR_SINGULAR, NULL);
-            retinf:
-                return (std::numeric_limits<double>::infinity());
-            }
-            if (x != std::floor(x))
-                goto domerr; /* because q^-x not defined */
-        }
-
-        /* Asymptotic expansion
-         * https://dlmf.nist.gov/25.11#E43
-         */
-        if (q > 1e8) {
-            return (1 / (x - 1) + 1 / (2 * q)) * std::pow(q, 1 - x);
-        }
-
-        /* Euler-Maclaurin summation formula */
-
-        /* Permit negative q but continue sum until n+q > +9 .
-         * This case should be handled by a reflection formula.
-         * If q<0 and x is an integer, there is a relation to
-         * the polyGamma function.
-         */
-        s = std::pow(q, -x);
-        a = q;
-        i = 0;
-        b = 0.0;
-        while ((i < 9) || (a <= 9.0)) {
-            i += 1;
-            a += 1.0;
-            b = std::pow(a, -x);
-            s += b;
-            if (std::abs(b / s) < detail::MACHEP)
-                goto done;
-        }
-
-        w = a;
-        s += b * w / (x - 1.0);
-        s -= 0.5 * b;
-        a = 1.0;
-        k = 0.0;
-        for (i = 0; i < 12; i++) {
-            a *= x + k;
-            b /= w;
-            t = a * b / detail::zeta_A[i];
-            s = s + t;
-            t = std::abs(t / s);
-            if (t < detail::MACHEP)
-                goto done;
-            k += 1.0;
-            a *= x + k;
-            b /= w;
-            k += 1.0;
-        }
-    done:
-        return (s);
-    }
-
-} // namespace cephes
-} // namespace xsf