scipy 1.15.3__cp312-cp312-win_amd64.whl → 1.16.0rc2__cp312-cp312-win_amd64.whl

scipy/special/xsf/config.h

@@ -1,304 +0,0 @@
-#pragma once
-
-// Define math constants if they are not available
-#ifndef M_E
-#define M_E 2.71828182845904523536
-#endif
-
-#ifndef M_LOG2E
-#define M_LOG2E 1.44269504088896340736
-#endif
-
-#ifndef M_LOG10E
-#define M_LOG10E 0.434294481903251827651
-#endif
-
-#ifndef M_LN2
-#define M_LN2 0.693147180559945309417
-#endif
-
-#ifndef M_LN10
-#define M_LN10 2.30258509299404568402
-#endif
-
-#ifndef M_PI
-#define M_PI 3.14159265358979323846
-#endif
-
-#ifndef M_PI_2
-#define M_PI_2 1.57079632679489661923
-#endif
-
-#ifndef M_PI_4
-#define M_PI_4 0.785398163397448309616
-#endif
-
-#ifndef M_1_PI
-#define M_1_PI 0.318309886183790671538
-#endif
-
-#ifndef M_2_PI
-#define M_2_PI 0.636619772367581343076
-#endif
-
-#ifndef M_2_SQRTPI
-#define M_2_SQRTPI 1.12837916709551257390
-#endif
-
-#ifndef M_SQRT2
-#define M_SQRT2 1.41421356237309504880
-#endif
-
-#ifndef M_SQRT1_2
-#define M_SQRT1_2 0.707106781186547524401
-#endif
-
-#ifdef __CUDACC__
-#define XSF_HOST_DEVICE __host__ __device__
-
-#include <cuda/std/cmath>
-#include <cuda/std/cstddef>
-#include <cuda/std/cstdint>
-#include <cuda/std/limits>
-#include <cuda/std/tuple>
-#include <cuda/std/type_traits>
-#include <cuda/std/utility>
-
-// Fallback to global namespace for functions unsupported on NVRTC Jit
-#ifdef _LIBCUDACXX_COMPILER_NVRTC
-#include <cuda_runtime.h>
-#endif
-
-namespace std {
-
-XSF_HOST_DEVICE inline double abs(double num) { return cuda::std::abs(num); }
-
-XSF_HOST_DEVICE inline double exp(double num) { return cuda::std::exp(num); }
-
-XSF_HOST_DEVICE inline double log(double num) { return cuda::std::log(num); }
-
-XSF_HOST_DEVICE inline double sqrt(double num) { return cuda::std::sqrt(num); }
-
-XSF_HOST_DEVICE inline bool isinf(double num) { return cuda::std::isinf(num); }
-
-XSF_HOST_DEVICE inline bool isnan(double num) { return cuda::std::isnan(num); }
-
-XSF_HOST_DEVICE inline bool isfinite(double num) { return cuda::std::isfinite(num); }
-
-XSF_HOST_DEVICE inline double pow(double x, double y) { return cuda::std::pow(x, y); }
-
-XSF_HOST_DEVICE inline double sin(double x) { return cuda::std::sin(x); }
-
-XSF_HOST_DEVICE inline double cos(double x) { return cuda::std::cos(x); }
-
-XSF_HOST_DEVICE inline double tan(double x) { return cuda::std::tan(x); }
-
-XSF_HOST_DEVICE inline double atan(double x) { return cuda::std::atan(x); }
-
-XSF_HOST_DEVICE inline double acos(double x) { return cuda::std::acos(x); }
-
-XSF_HOST_DEVICE inline double sinh(double x) { return cuda::std::sinh(x); }
-
-XSF_HOST_DEVICE inline double cosh(double x) { return cuda::std::cosh(x); }
-
-XSF_HOST_DEVICE inline double asinh(double x) { return cuda::std::asinh(x); }
-
-XSF_HOST_DEVICE inline bool signbit(double x) { return cuda::std::signbit(x); }
-
-// Fallback to global namespace for functions unsupported on NVRTC
-#ifndef _LIBCUDACXX_COMPILER_NVRTC
-XSF_HOST_DEVICE inline double ceil(double x) { return cuda::std::ceil(x); }
-XSF_HOST_DEVICE inline double floor(double x) { return cuda::std::floor(x); }
-XSF_HOST_DEVICE inline double round(double x) { return cuda::std::round(x); }
-XSF_HOST_DEVICE inline double trunc(double x) { return cuda::std::trunc(x); }
-XSF_HOST_DEVICE inline double fma(double x, double y, double z) { return cuda::std::fma(x, y, z); }
-XSF_HOST_DEVICE inline double copysign(double x, double y) { return cuda::std::copysign(x, y); }
-XSF_HOST_DEVICE inline double modf(double value, double *iptr) { return cuda::std::modf(value, iptr); }
-XSF_HOST_DEVICE inline double fmax(double x, double y) { return cuda::std::fmax(x, y); }
-XSF_HOST_DEVICE inline double fmin(double x, double y) { return cuda::std::fmin(x, y); }
-XSF_HOST_DEVICE inline double log10(double num) { return cuda::std::log10(num); }
-XSF_HOST_DEVICE inline double log1p(double num) { return cuda::std::log1p(num); }
-XSF_HOST_DEVICE inline double frexp(double num, int *exp) { return cuda::std::frexp(num, exp); }
-XSF_HOST_DEVICE inline double ldexp(double num, int exp) { return cuda::std::ldexp(num, exp); }
-XSF_HOST_DEVICE inline double fmod(double x, double y) { return cuda::std::fmod(x, y); }
-XSF_HOST_DEVICE inline double nextafter(double from, double to) { return cuda::std::nextafter(from, to); }
-#else
-XSF_HOST_DEVICE inline double ceil(double x) { return ::ceil(x); }
-XSF_HOST_DEVICE inline double floor(double x) { return ::floor(x); }
-XSF_HOST_DEVICE inline double round(double x) { return ::round(x); }
-XSF_HOST_DEVICE inline double trunc(double x) { return ::trunc(x); }
-XSF_HOST_DEVICE inline double fma(double x, double y, double z) { return ::fma(x, y, z); }
-XSF_HOST_DEVICE inline double copysign(double x, double y) { return ::copysign(x, y); }
-XSF_HOST_DEVICE inline double modf(double value, double *iptr) { return ::modf(value, iptr); }
-XSF_HOST_DEVICE inline double fmax(double x, double y) { return ::fmax(x, y); }
-XSF_HOST_DEVICE inline double fmin(double x, double y) { return ::fmin(x, y); }
-XSF_HOST_DEVICE inline double log10(double num) { return ::log10(num); }
-XSF_HOST_DEVICE inline double log1p(double num) { return ::log1p(num); }
-XSF_HOST_DEVICE inline double frexp(double num, int *exp) { return ::frexp(num, exp); }
-XSF_HOST_DEVICE inline double ldexp(double num, int exp) { return ::ldexp(num, exp); }
-XSF_HOST_DEVICE inline double fmod(double x, double y) { return ::fmod(x, y); }
-XSF_HOST_DEVICE inline double nextafter(double from, double to) { return ::nextafter(from, to); }
-#endif
-
-template <typename T>
-XSF_HOST_DEVICE void swap(T &a, T &b) {
-    cuda::std::swap(a, b);
-}
-
-// Reimplement std::clamp until it's available in CuPy
-template <typename T>
-XSF_HOST_DEVICE constexpr T clamp(T &v, T &lo, T &hi) {
-    return v < lo ? lo : (v > hi ? lo : v);
-}
-
-template <typename T>
-using numeric_limits = cuda::std::numeric_limits<T>;
-
-// Must use thrust for complex types in order to support CuPy
-template <typename T>
-using complex = thrust::complex<T>;
-
-template <typename T>
-XSF_HOST_DEVICE T abs(const complex<T> &z) {
-    return thrust::abs(z);
-}
-
-template <typename T>
-XSF_HOST_DEVICE complex<T> exp(const complex<T> &z) {
-    return thrust::exp(z);
-}
-
-template <typename T>
-XSF_HOST_DEVICE complex<T> log(const complex<T> &z) {
-    return thrust::log(z);
-}
-
-template <typename T>
-XSF_HOST_DEVICE T norm(const complex<T> &z) {
-    return thrust::norm(z);
-}
-
-template <typename T>
-XSF_HOST_DEVICE complex<T> sqrt(const complex<T> &z) {
-    return thrust::sqrt(z);
-}
-
-template <typename T>
-XSF_HOST_DEVICE complex<T> conj(const complex<T> &z) {
-    return thrust::conj(z);
-}
-
-template <typename T>
-XSF_HOST_DEVICE complex<T> pow(const complex<T> &x, const complex<T> &y) {
-    return thrust::pow(x, y);
-}
-
-template <typename T>
-XSF_HOST_DEVICE complex<T> pow(const complex<T> &x, const T &y) {
-    return thrust::pow(x, y);
-}
-
-// Other types and utilities
-template <typename T>
-using is_floating_point = cuda::std::is_floating_point<T>;
-
-template <bool Cond, typename T = void>
-using enable_if = cuda::std::enable_if<Cond, T>;
-
-template <typename T>
-using decay = cuda::std::decay<T>;
-
-template <typename T>
-using invoke_result = cuda::std::invoke_result<T>;
-
-template <typename T1, typename T2>
-using pair = cuda::std::pair<T1, T2>;
-
-template <typename... Types>
-using tuple = cuda::std::tuple<Types...>;
-
-using cuda::std::ptrdiff_t;
-using cuda::std::size_t;
-using cuda::std::uint64_t;
-
-#define XSF_ASSERT(a)
-
-} // namespace std
-
-#else
-#define XSF_HOST_DEVICE
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <complex>
-#include <cstddef>
-#include <cstdint>
-#include <iterator>
-#include <limits>
-#include <math.h>
-#include <tuple>
-#include <type_traits>
-#include <utility>
-
-#ifdef DEBUG
-#define XSF_ASSERT(a) assert(a)
-#else
-#define XSF_ASSERT(a)
-#endif
-
-namespace xsf {
-
-// basic
-using std::abs;
-
-// exponential
-using std::exp;
-
-// power
-using std::sqrt;
-
-// trigonometric
-using std::cos;
-using std::sin;
-
-// floating-point manipulation
-using std::copysign;
-
-// classification and comparison
-using std::isfinite;
-using std::isinf;
-using std::isnan;
-using std::signbit;
-
-// complex
-using std::imag;
-using std::real;
-
-template <typename T>
-struct remove_complex {
-    using type = T;
-};
-
-template <typename T>
-struct remove_complex<std::complex<T>> {
-    using type = T;
-};
-
-template <typename T>
-using remove_complex_t = typename remove_complex<T>::type;
-
-template <typename T>
-struct complex_type {
-    using type = std::complex<T>;
-};
-
-template <typename T>
-using complex_type_t = typename complex_type<T>::type;
-
-template <typename T>
-using complex = complex_type_t<T>;
-
-} // namespace xsf
-
-#endif

scipy/special/xsf/digamma.h

@@ -1,205 +0,0 @@
-/* Translated from Cython into C++ by SciPy developers in 2024.
- * Original header comment appears below.
- */
-
-/* An implementation of the digamma function for complex arguments.
- *
- * Author: Josh Wilson
- *
- * Distributed under the same license as Scipy.
- *
- * Sources:
- * [1] "The Digital Library of Mathematical Functions", dlmf.nist.gov
- *
- * [2] mpmath (version 0.19), http://mpmath.org
- */
-
-#pragma once
-
-#include "cephes/psi.h"
-#include "cephes/zeta.h"
-#include "config.h"
-#include "error.h"
-#include "trig.h"
-
-namespace xsf {
-namespace detail {
-    // All of the following were computed with mpmath
-    // Location of the positive root
-    constexpr double digamma_posroot = 1.4616321449683623;
-    // Value of the positive root
-    constexpr double digamma_posrootval = -9.2412655217294275e-17;
-    // Location of the negative root
-    constexpr double digamma_negroot = -0.504083008264455409;
-    // Value of the negative root
-    constexpr double digamma_negrootval = 7.2897639029768949e-17;
-
-    template <typename T>
-    XSF_HOST_DEVICE T digamma_zeta_series(T z, double root, double rootval) {
-        T res = rootval;
-        T coeff = -1.0;
-
-        z = z - root;
-        T term;
-        for (int n = 1; n < 100; n++) {
-            coeff *= -z;
-            term = coeff * cephes::zeta(n + 1, root);
-            res += term;
-            if (std::abs(term) < std::numeric_limits<double>::epsilon() * std::abs(res)) {
-                break;
-            }
-        }
-        return res;
-    }
-
-    XSF_HOST_DEVICE inline std::complex<double>
-    digamma_forward_recurrence(std::complex<double> z, std::complex<double> psiz, int n) {
-        /* Compute digamma(z + n) using digamma(z) using the recurrence
-         * relation
-         *
-         * digamma(z + 1) = digamma(z) + 1/z.
-         *
-         * See https://dlmf.nist.gov/5.5#E2 */
-        std::complex<double> res = psiz;
-
-        for (int k = 0; k < n; k++) {
-            res += 1.0 / (z + static_cast<double>(k));
-        }
-        return res;
-    }
-
-    XSF_HOST_DEVICE inline std::complex<double>
-    digamma_backward_recurrence(std::complex<double> z, std::complex<double> psiz, int n) {
-        /* Compute digamma(z - n) using digamma(z) and a recurrence relation. */
-        std::complex<double> res = psiz;
-
-        for (int k = 1; k < n + 1; k++) {
-            res -= 1.0 / (z - static_cast<double>(k));
-        }
-        return res;
-    }
-
-    XSF_HOST_DEVICE inline std::complex<double> digamma_asymptotic_series(std::complex<double> z) {
-        /* Evaluate digamma using an asymptotic series. See
-         *
-         * https://dlmf.nist.gov/5.11#E2 */
-        double bernoulli2k[] = {0.166666666666666667,   -0.0333333333333333333, 0.0238095238095238095,
-                                -0.0333333333333333333, 0.0757575757575757576,  -0.253113553113553114,
-                                1.16666666666666667,    -7.09215686274509804,   54.9711779448621554,
-                                -529.124242424242424,   6192.12318840579710,    -86580.2531135531136,
-                                1425517.16666666667,    -27298231.0678160920,   601580873.900642368,
-                                -15116315767.0921569};
-        std::complex<double> rzz = 1.0 / z / z;
-        std::complex<double> zfac = 1.0;
-        std::complex<double> term;
-        std::complex<double> res;
-
-        if (!(std::isfinite(z.real()) && std::isfinite(z.imag()))) {
-            /* Check for infinity (or nan) and return early.
-             * Result of division by complex infinity is implementation dependent.
-             * and has been observed to vary between C++ stdlib and CUDA stdlib.
-             */
-            return std::log(z);
-        }
-
-        res = std::log(z) - 0.5 / z;
-
-        for (int k = 1; k < 17; k++) {
-            zfac *= rzz;
-            term = -bernoulli2k[k - 1] * zfac / (2 * static_cast<double>(k));
-            res += term;
-            if (std::abs(term) < std::numeric_limits<double>::epsilon() * std::abs(res)) {
-                break;
-            }
-        }
-        return res;
-    }
-
-} // namespace detail
-
-XSF_HOST_DEVICE inline double digamma(double z) {
-    /* Wrap Cephes' psi to take advantage of the series expansion around
-     * the smallest negative zero.
-     */
-    if (std::abs(z - detail::digamma_negroot) < 0.3) {
-        return detail::digamma_zeta_series(z, detail::digamma_negroot, detail::digamma_negrootval);
-    }
-    return cephes::psi(z);
-}
-
-XSF_HOST_DEVICE inline float digamma(float z) { return static_cast<float>(digamma(static_cast<double>(z))); }
-
-XSF_HOST_DEVICE inline std::complex<double> digamma(std::complex<double> z) {
-    /*
-     * Compute the digamma function for complex arguments. The strategy
-     * is:
-     *
-     * - Around the two zeros closest to the origin (posroot and negroot)
-     * use a Taylor series with precomputed zero order coefficient.
-     * - If close to the origin, use a recurrence relation to step away
-     * from the origin.
-     * - If close to the negative real axis, use the reflection formula
-     * to move to the right halfplane.
-     * - If |z| is large (> 16), use the asymptotic series.
-     * - If |z| is small, use a recurrence relation to make |z| large
-     * enough to use the asymptotic series.
-     */
-    double absz = std::abs(z);
-    std::complex<double> res = 0;
-    /* Use the asymptotic series for z away from the negative real axis
-     * with abs(z) > smallabsz. */
-    int smallabsz = 16;
-    /* Use the reflection principle for z with z.real < 0 that are within
-     * smallimag of the negative real axis.
-     * int smallimag = 6  # unused below except in a comment */
-
-    if (z.real() <= 0.0 && std::ceil(z.real()) == z) {
-        // Poles
-        set_error("digamma", SF_ERROR_SINGULAR, NULL);
-        return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
-    }
-    if (std::abs(z - detail::digamma_negroot) < 0.3) {
-        // First negative root.
-        return detail::digamma_zeta_series(z, detail::digamma_negroot, detail::digamma_negrootval);
-    }
-
-    if (z.real() < 0 and std::abs(z.imag()) < smallabsz) {
-        /* Reflection formula for digamma. See
-         *
-         *https://dlmf.nist.gov/5.5#E4
-         */
-        res = -M_PI * cospi(z) / sinpi(z);
-        z = 1.0 - z;
-        absz = std::abs(z);
-    }
-
-    if (absz < 0.5) {
-        /* Use one step of the recurrence relation to step away from
-         * the pole. */
-        res = -1.0 / z;
-        z += 1.0;
-        absz = std::abs(z);
-    }
-
-    if (std::abs(z - detail::digamma_posroot) < 0.5) {
-        res += detail::digamma_zeta_series(z, detail::digamma_posroot, detail::digamma_posrootval);
-    } else if (absz > smallabsz) {
-        res += detail::digamma_asymptotic_series(z);
-    } else if (z.real() >= 0.0) {
-        double n = std::trunc(smallabsz - absz) + 1;
-        std::complex<double> init = detail::digamma_asymptotic_series(z + n);
-        res += detail::digamma_backward_recurrence(z + n, init, n);
-    } else {
-        // z.real() < 0, absz < smallabsz, and z.imag() > smallimag
-        double n = std::trunc(smallabsz - absz) - 1;
-        std::complex<double> init = detail::digamma_asymptotic_series(z - n);
-        res += detail::digamma_forward_recurrence(z - n, init, n);
-    }
-    return res;
-}
-
-XSF_HOST_DEVICE inline std::complex<float> digamma(std::complex<float> z) {
-    return static_cast<std::complex<float>>(digamma(static_cast<std::complex<double>>(z)));
-}
-
-} // namespace xsf

scipy/special/xsf/error.h

@@ -1,57 +0,0 @@
-#pragma once
-
-typedef enum {
-    SF_ERROR_OK = 0,    /* no error */
-    SF_ERROR_SINGULAR,  /* singularity encountered */
-    SF_ERROR_UNDERFLOW, /* floating point underflow */
-    SF_ERROR_OVERFLOW,  /* floating point overflow */
-    SF_ERROR_SLOW,      /* too many iterations required */
-    SF_ERROR_LOSS,      /* loss of precision */
-    SF_ERROR_NO_RESULT, /* no result obtained */
-    SF_ERROR_DOMAIN,    /* out of domain */
-    SF_ERROR_ARG,       /* invalid input parameter */
-    SF_ERROR_OTHER,     /* unclassified error */
-    SF_ERROR_MEMORY,    /* memory allocation failed */
-    SF_ERROR__LAST
-} sf_error_t;
-
-#ifdef __cplusplus
-
-#include "config.h"
-
-namespace xsf {
-
-#ifndef SP_SPECFUN_ERROR
-XSF_HOST_DEVICE inline void set_error(const char *func_name, sf_error_t code, const char *fmt, ...) {
-    // nothing
-}
-#else
-void set_error(const char *func_name, sf_error_t code, const char *fmt, ...);
-#endif
-
-template <typename T>
-XSF_HOST_DEVICE void set_error_and_nan(const char *name, sf_error_t code, T &value) {
-    if (code != SF_ERROR_OK) {
-        set_error(name, code, nullptr);
-
-        if (code == SF_ERROR_DOMAIN || code == SF_ERROR_OVERFLOW || code == SF_ERROR_NO_RESULT) {
-            value = std::numeric_limits<T>::quiet_NaN();
-        }
-    }
-}
-
-template <typename T>
-XSF_HOST_DEVICE void set_error_and_nan(const char *name, sf_error_t code, std::complex<T> &value) {
-    if (code != SF_ERROR_OK) {
-        set_error(name, code, nullptr);
-
-        if (code == SF_ERROR_DOMAIN || code == SF_ERROR_OVERFLOW || code == SF_ERROR_NO_RESULT) {
-            value.real(std::numeric_limits<T>::quiet_NaN());
-            value.imag(std::numeric_limits<T>::quiet_NaN());
-        }
-    }
-}
-
-} // namespace xsf
-
-#endif

scipy/special/xsf/evalpoly.h

@@ -1,47 +0,0 @@
-/* Translated from Cython into C++ by SciPy developers in 2024.
- *
- * Original author: Josh Wilson, 2016.
- */
-
-/* Evaluate polynomials.
- *
- * All of the coefficients are stored in reverse order, i.e. if the
- * polynomial is
- *
- *     u_n x^n + u_{n - 1} x^{n - 1} + ... + u_0,
- *
- * then coeffs[0] = u_n, coeffs[1] = u_{n - 1}, ..., coeffs[n] = u_0.
- *
- * References
- * ----------
- * [1] Knuth, "The Art of Computer Programming, Volume II"
- */
-
-#pragma once
-
-#include "config.h"
-
-namespace xsf {
-
-XSF_HOST_DEVICE inline std::complex<double> cevalpoly(const double *coeffs, int degree, std::complex<double> z) {
-    /* Evaluate a polynomial with real coefficients at a complex point.
-     *
-     * Uses equation (3) in section 4.6.4 of [1]. Note that it is more
-     * efficient than Horner's method.
-     */
-    double a = coeffs[0];
-    double b = coeffs[1];
-    double r = 2 * z.real();
-    double s = std::norm(z);
-    double tmp;
-
-    for (int j = 2; j < degree + 1; j++) {
-        tmp = b;
-        b = std::fma(-s, a, coeffs[j]);
-        a = std::fma(r, a, tmp);
-    }
-
-    return z * a + b;
-}
-
-} // namespace xsf