scipy 1.15.3__cp313-cp313-musllinux_1_2_aarch64.whl → 1.16.0rc1__cp313-cp313-musllinux_1_2_aarch64.whl

scipy/special/xsf/iv_ratio.h

@@ -1,173 +0,0 @@
-// Numerically stable computation of iv(v+1, x) / iv(v, x)
-
-#pragma once
-
-#include "config.h"
-#include "tools.h"
-#include "error.h"
-#include "cephes/dd_real.h"
-
-namespace xsf {
-
-/* Generates the "tail" of Perron's continued fraction for iv(v,x)/iv(v-1,x).
- *
- * The Perron continued fraction is studied in [1].  It is given by
- *
- *         iv(v, x)      x    -(2v+1)x   -(2v+3)x   -(2v+5)x
- *   R := --------- = ------ ---------- ---------- ---------- ...
- *        iv(v-1,x)   x+2v + 2(v+x)+1 + 2(v+x)+2 + 2(v+x)+3 +
- *
- * Given a suitable constant c, the continued fraction may be rearranged
- * into the following form to avoid premature floating point overflow:
- *
- *        xc                -(2vc+c)(xc) -(2vc+3c)(xc) -(2vc+5c)(xc)
- *   R = -----,  fc = 2vc + ------------ ------------- ------------- ...
- *       xc+fc              2(vc+xc)+c + 2(vc+xc)+2c + 2(vc+xc)+3c +
- *
- * This class generates the fractions of fc after 2vc.
- *
- * [1] Gautschi, W. and Slavik, J. (1978). "On the computation of modified
- *     Bessel function ratios." Mathematics of Computation, 32(143):865-875.
- */
-template <class T>
-struct IvRatioCFTailGenerator {
-
-    XSF_HOST_DEVICE IvRatioCFTailGenerator(T vc, T xc, T c) noexcept {
-        a0_ = -(2*vc-c)*xc;
-        as_ = -2*c*xc;
-        b0_ = 2*(vc+xc);
-        bs_ = c;
-        k_ = 0;
-    }
-
-    XSF_HOST_DEVICE std::pair<T, T> operator()() noexcept {
-        using std::fma;
-        ++k_;
-        return {fma(static_cast<T>(k_), as_, a0_),
-                fma(static_cast<T>(k_), bs_, b0_)};
-    }
-
-private:
-    T a0_, as_;  // a[k] == a0 + as*k, k >= 1
-    T b0_, bs_;  // b[k] == b0 + bs*k, k >= 1
-    std::uint64_t k_; // current index
-};
-
-// Computes f(v, x) using Perron's continued fraction.
-//
-// T specifies the working type.  This allows the function to perform
-// calculations in a higher precision, such as double-double, even if
-// the return type is hardcoded to be double.
-template <class T>
-XSF_HOST_DEVICE inline std::pair<double, std::uint64_t>
-_iv_ratio_cf(double v, double x, bool complement) {
-
-    int e;
-    std::frexp(std::fmax(v, x), &e);
-    T c = T(std::ldexp(1, 2-e)); // rescaling multiplier
-    T vc = v * c;
-    T xc = x * c;
-
-    IvRatioCFTailGenerator<T> cf(vc, xc, c);
-    auto [fc, terms] = detail::series_eval_kahan(
-        detail::continued_fraction_series(cf),
-        T(std::numeric_limits<double>::epsilon()),
-        1000,
-        2*vc);
-
-    T ret = (complement ? fc : xc) / (xc + fc);
-    return {static_cast<double>(ret), terms};
-}
-
-XSF_HOST_DEVICE inline double iv_ratio(double v, double x) {
-
-    if (std::isnan(v) || std::isnan(x)) {
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    if (v < 0.5 || x < 0) {
-        set_error("iv_ratio", SF_ERROR_DOMAIN, NULL);
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    if (std::isinf(v) && std::isinf(x)) {
-        // There is not a unique limit as both v and x tends to infinity.
-        set_error("iv_ratio", SF_ERROR_DOMAIN, NULL);
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    if (x == 0.0) {
-        return x; // keep sign of x because iv_ratio is an odd function
-    }
-    if (std::isinf(v)) {
-        return 0.0;
-    }
-    if (std::isinf(x)) {
-        return 1.0;
-    }
-
-    auto [ret, terms] = _iv_ratio_cf<double>(v, x, false);
-    if (terms == 0) { // failed to converge; should not happen
-        set_error("iv_ratio", SF_ERROR_NO_RESULT, NULL);
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    return ret;
-}
-
-XSF_HOST_DEVICE inline float iv_ratio(float v, float x) {
-    return iv_ratio(static_cast<double>(v), static_cast<double>(x));
-}
-
-XSF_HOST_DEVICE inline double iv_ratio_c(double v, double x) {
-
-    if (std::isnan(v) || std::isnan(x)) {
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    if (v < 0.5 || x < 0) {
-        set_error("iv_ratio_c", SF_ERROR_DOMAIN, NULL);
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    if (std::isinf(v) && std::isinf(x)) {
-        // There is not a unique limit as both v and x tends to infinity.
-        set_error("iv_ratio_c", SF_ERROR_DOMAIN, NULL);
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    if (x == 0.0) {
-        return 1.0;
-    }
-    if (std::isinf(v)) {
-        return 1.0;
-    }
-    if (std::isinf(x)) {
-        return 0.0;
-    }
-
-    if (v >= 1) {
-        // Numerical experiments show that evaluating the Perron c.f.
-        // in double precision is sufficiently accurate if v >= 1.
-        auto [ret, terms] = _iv_ratio_cf<double>(v, x, true);
-        if (terms == 0) { // failed to converge; should not happen
-            set_error("iv_ratio_c", SF_ERROR_NO_RESULT, NULL);
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-        return ret;
-    } else if (v > 0.5) {
-        // double-double arithmetic is needed for 0.5 < v < 1 to
-        // achieve relative error on the scale of machine precision.
-        using cephes::detail::double_double;
-        auto [ret, terms] = _iv_ratio_cf<double_double>(v, x, true);
-        if (terms == 0) { // failed to converge; should not happen
-            set_error("iv_ratio_c", SF_ERROR_NO_RESULT, NULL);
-            return std::numeric_limits<double>::quiet_NaN();
-        }
-        return ret;
-    } else {
-        // The previous branch (v > 0.5) also works for v == 0.5, but
-        // the closed-form formula "1 - tanh(x)" is more efficient.
-        double t = std::exp(-2*x);
-        return (2 * t) / (1 + t);
-    }
-}
-
-XSF_HOST_DEVICE inline float iv_ratio_c(float v, float x) {
-    return iv_ratio_c(static_cast<double>(v), static_cast<double>(x));
-}
-
-} // namespace xsf

scipy/special/xsf/lambertw.h

@@ -1,150 +0,0 @@
-/* Translated from Cython into C++ by SciPy developers in 2023.
- * Original header with Copyright information appears below.
- */
-
-/* Implementation of the Lambert W function [1]. Based on MPMath
- *  Implementation [2], and documentation [3].
- *
- * Copyright: Yosef Meller, 2009
- * Author email: mellerf@netvision.net.il
- *
- * Distributed under the same license as SciPy
- *
- *
- * References:
- * [1] On the Lambert W function, Adv. Comp. Math. 5 (1996) 329-359,
- *     available online: https://web.archive.org/web/20230123211413/https://cs.uwaterloo.ca/research/tr/1993/03/W.pdf
- * [2] mpmath source code,
- https://github.com/mpmath/mpmath/blob/c5939823669e1bcce151d89261b802fe0d8978b4/mpmath/functions/functions.py#L435-L461
- * [3]
- https://web.archive.org/web/20230504171447/https://mpmath.org/doc/current/functions/powers.html#lambert-w-function
- *
-
- * TODO: use a series expansion when extremely close to the branch point
- * at `-1/e` and make sure that the proper branch is chosen there.
- */
-
-#pragma once
-
-#include "config.h"
-#include "error.h"
-#include "evalpoly.h"
-
-namespace xsf {
-constexpr double EXPN1 = 0.36787944117144232159553; // exp(-1)
-constexpr double OMEGA = 0.56714329040978387299997; // W(1, 0)
-
-namespace detail {
-    XSF_HOST_DEVICE inline std::complex<double> lambertw_branchpt(std::complex<double> z) {
-        // Series for W(z, 0) around the branch point; see 4.22 in [1].
-        double coeffs[] = {-1.0 / 3.0, 1.0, -1.0};
-        std::complex<double> p = std::sqrt(2.0 * (M_E * z + 1.0));
-
-        return cevalpoly(coeffs, 2, p);
-    }
-
-    XSF_HOST_DEVICE inline std::complex<double> lambertw_pade0(std::complex<double> z) {
-        // (3, 2) Pade approximation for W(z, 0) around 0.
-        double num[] = {12.85106382978723404255, 12.34042553191489361902, 1.0};
-        double denom[] = {32.53191489361702127660, 14.34042553191489361702, 1.0};
-
-        /* This only gets evaluated close to 0, so we don't need a more
-         * careful algorithm that avoids overflow in the numerator for
-         * large z. */
-        return z * cevalpoly(num, 2, z) / cevalpoly(denom, 2, z);
-    }
-
-    XSF_HOST_DEVICE inline std::complex<double> lambertw_asy(std::complex<double> z, long k) {
-        /* Compute the W function using the first two terms of the
-         * asymptotic series. See 4.20 in [1].
-         */
-        std::complex<double> w = std::log(z) + 2.0 * M_PI * k * std::complex<double>(0, 1);
-        return w - std::log(w);
-    }
-
-} // namespace detail
-
-XSF_HOST_DEVICE inline std::complex<double> lambertw(std::complex<double> z, long k, double tol) {
-    double absz;
-    std::complex<double> w;
-    std::complex<double> ew, wew, wewz, wn;
-
-    if (std::isnan(z.real()) || std::isnan(z.imag())) {
-        return z;
-    }
-    if (z.real() == std::numeric_limits<double>::infinity()) {
-        return z + 2.0 * M_PI * k * std::complex<double>(0, 1);
-    }
-    if (z.real() == -std::numeric_limits<double>::infinity()) {
-        return -z + (2.0 * M_PI * k + M_PI) * std::complex<double>(0, 1);
-    }
-    if (z == 0.0) {
-        if (k == 0) {
-            return z;
-        }
-        set_error("lambertw", SF_ERROR_SINGULAR, NULL);
-        return -std::numeric_limits<double>::infinity();
-    }
-    if (z == 1.0 && k == 0) {
-        // Split out this case because the asymptotic series blows up
-        return OMEGA;
-    }
-
-    absz = std::abs(z);
-    // Get an initial guess for Halley's method
-    if (k == 0) {
-        if (std::abs(z + EXPN1) < 0.3) {
-            w = detail::lambertw_branchpt(z);
-        } else if (-1.0 < z.real() && z.real() < 1.5 && std::abs(z.imag()) < 1.0 &&
-                   -2.5 * std::abs(z.imag()) - 0.2 < z.real()) {
-            /* Empirically determined decision boundary where the Pade
-             * approximation is more accurate. */
-            w = detail::lambertw_pade0(z);
-        } else {
-            w = detail::lambertw_asy(z, k);
-        }
-    } else if (k == -1) {
-        if (absz <= EXPN1 && z.imag() == 0.0 && z.real() < 0.0) {
-            w = std::log(-z.real());
-        } else {
-            w = detail::lambertw_asy(z, k);
-        }
-    } else {
-        w = detail::lambertw_asy(z, k);
-    }
-
-    // Halley's method; see 5.9 in [1]
-    if (w.real() >= 0) {
-        // Rearrange the formula to avoid overflow in exp
-        for (int i = 0; i < 100; i++) {
-            ew = std::exp(-w);
-            wewz = w - z * ew;
-            wn = w - wewz / (w + 1.0 - (w + 2.0) * wewz / (2.0 * w + 2.0));
-            if (std::abs(wn - w) <= tol * std::abs(wn)) {
-                return wn;
-            }
-            w = wn;
-        }
-    } else {
-        for (int i = 0; i < 100; i++) {
-            ew = std::exp(w);
-            wew = w * ew;
-            wewz = wew - z;
-            wn = w - wewz / (wew + ew - (w + 2.0) * wewz / (2.0 * w + 2.0));
-            if (std::abs(wn - w) <= tol * std::abs(wn)) {
-                return wn;
-            }
-            w = wn;
-        }
-    }
-
-    set_error("lambertw", SF_ERROR_SLOW, "iteration failed to converge: %g + %gj", z.real(), z.imag());
-    return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
-}
-
-XSF_HOST_DEVICE inline std::complex<float> lambertw(std::complex<float> z, long k, float tol) {
-    return static_cast<std::complex<float>>(
-        lambertw(static_cast<std::complex<double>>(z), k, static_cast<double>(tol)));
-}
-
-} // namespace xsf

scipy/special/xsf/loggamma.h

@@ -1,163 +0,0 @@
-/* Translated from Cython into C++ by SciPy developers in 2024.
- * Original header comment appears below.
- */
-
-/* An implementation of the principal branch of the logarithm of
- * Gamma. Also contains implementations of Gamma and 1/Gamma which are
- * easily computed from log-Gamma.
- *
- * Author: Josh Wilson
- *
- * Distributed under the same license as Scipy.
- *
- * References
- * ----------
- * [1] Hare, "Computing the Principal Branch of log-Gamma",
- *     Journal of Algorithms, 1997.
- *
- * [2] Julia,
- *     https://github.com/JuliaLang/julia/blob/master/base/special/gamma.jl
- */
-
-#pragma once
-
-#include "cephes/gamma.h"
-#include "cephes/rgamma.h"
-#include "config.h"
-#include "error.h"
-#include "evalpoly.h"
-#include "trig.h"
-#include "zlog1.h"
-
-namespace xsf {
-
-namespace detail {
-    constexpr double loggamma_SMALLX = 7;
-    constexpr double loggamma_SMALLY = 7;
-    constexpr double loggamma_HLOG2PI = 0.918938533204672742;      // log(2*pi)/2
-    constexpr double loggamma_LOGPI = 1.1447298858494001741434262; // log(pi)
-    constexpr double loggamma_TAYLOR_RADIUS = 0.2;
-
-    XSF_HOST_DEVICE std::complex<double> loggamma_stirling(std::complex<double> z) {
-        /* Stirling series for log-Gamma
-         *
-         * The coefficients are B[2*n]/(2*n*(2*n - 1)) where B[2*n] is the
-         * (2*n)th Bernoulli number. See (1.1) in [1].
-         */
-        double coeffs[] = {-2.955065359477124183E-2,  6.4102564102564102564E-3, -1.9175269175269175269E-3,
-                           8.4175084175084175084E-4,  -5.952380952380952381E-4, 7.9365079365079365079E-4,
-                           -2.7777777777777777778E-3, 8.3333333333333333333E-2};
-        std::complex<double> rz = 1.0 / z;
-        std::complex<double> rzz = rz / z;
-
-        return (z - 0.5) * std::log(z) - z + loggamma_HLOG2PI + rz * cevalpoly(coeffs, 7, rzz);
-    }
-
-    XSF_HOST_DEVICE std::complex<double> loggamma_recurrence(std::complex<double> z) {
-        /* Backward recurrence relation.
-         *
-         * See Proposition 2.2 in [1] and the Julia implementation [2].
-         *
-         */
-        int signflips = 0;
-        int sb = 0;
-        std::complex<double> shiftprod = z;
-
-        z += 1.0;
-        int nsb;
-        while (z.real() <= loggamma_SMALLX) {
-            shiftprod *= z;
-            nsb = std::signbit(shiftprod.imag());
-            signflips += nsb != 0 && sb == 0 ? 1 : 0;
-            sb = nsb;
-            z += 1.0;
-        }
-        return loggamma_stirling(z) - std::log(shiftprod) - signflips * 2 * M_PI * std::complex<double>(0, 1);
-    }
-
-    XSF_HOST_DEVICE std::complex<double> loggamma_taylor(std::complex<double> z) {
-        /* Taylor series for log-Gamma around z = 1.
-         *
-         * It is
-         *
-         * loggamma(z + 1) = -gamma*z + zeta(2)*z**2/2 - zeta(3)*z**3/3 ...
-         *
-         * where gamma is the Euler-Mascheroni constant.
-         */
-
-        double coeffs[] = {
-            -4.3478266053040259361E-2, 4.5454556293204669442E-2, -4.7619070330142227991E-2, 5.000004769810169364E-2,
-            -5.2631679379616660734E-2, 5.5555767627403611102E-2, -5.8823978658684582339E-2, 6.2500955141213040742E-2,
-            -6.6668705882420468033E-2, 7.1432946295361336059E-2, -7.6932516411352191473E-2, 8.3353840546109004025E-2,
-            -9.0954017145829042233E-2, 1.0009945751278180853E-1, -1.1133426586956469049E-1, 1.2550966952474304242E-1,
-            -1.4404989676884611812E-1, 1.6955717699740818995E-1, -2.0738555102867398527E-1, 2.7058080842778454788E-1,
-            -4.0068563438653142847E-1, 8.2246703342411321824E-1, -5.7721566490153286061E-1};
-
-        z -= 1.0;
-        return z * cevalpoly(coeffs, 22, z);
-    }
-} // namespace detail
-
-XSF_HOST_DEVICE inline double loggamma(double x) {
-    if (x < 0.0) {
-        return std::numeric_limits<double>::quiet_NaN();
-    }
-    return cephes::lgam(x);
-}
-
-XSF_HOST_DEVICE inline float loggamma(float x) { return loggamma(static_cast<double>(x)); }
-
-XSF_HOST_DEVICE inline std::complex<double> loggamma(std::complex<double> z) {
-    // Compute the principal branch of log-Gamma
-
-    if (std::isnan(z.real()) || std::isnan(z.imag())) {
-        return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
-    }
-    if (z.real() <= 0 and z == std::floor(z.real())) {
-        set_error("loggamma", SF_ERROR_SINGULAR, NULL);
-        return {std::numeric_limits<double>::quiet_NaN(), std::numeric_limits<double>::quiet_NaN()};
-    }
-    if (z.real() > detail::loggamma_SMALLX || std::abs(z.imag()) > detail::loggamma_SMALLY) {
-        return detail::loggamma_stirling(z);
-    }
-    if (std::abs(z - 1.0) < detail::loggamma_TAYLOR_RADIUS) {
-        return detail::loggamma_taylor(z);
-    }
-    if (std::abs(z - 2.0) < detail::loggamma_TAYLOR_RADIUS) {
-        // Recurrence relation and the Taylor series around 1.
-        return detail::zlog1(z - 1.0) + detail::loggamma_taylor(z - 1.0);
-    }
-    if (z.real() < 0.1) {
-        // Reflection formula; see Proposition 3.1 in [1]
-        double tmp = std::copysign(2 * M_PI, z.imag()) * std::floor(0.5 * z.real() + 0.25);
-        return std::complex<double>(detail::loggamma_LOGPI, tmp) - std::log(sinpi(z)) - loggamma(1.0 - z);
-    }
-    if (std::signbit(z.imag()) == 0) {
-        // z.imag() >= 0 but is not -0.0
-        return detail::loggamma_recurrence(z);
-    }
-    return std::conj(detail::loggamma_recurrence(std::conj(z)));
-}
-
-XSF_HOST_DEVICE inline std::complex<float> loggamma(std::complex<float> z) {
-    return static_cast<std::complex<float>>(loggamma(static_cast<std::complex<double>>(z)));
-}
-
-XSF_HOST_DEVICE inline double rgamma(double z) { return cephes::rgamma(z); }
-
-XSF_HOST_DEVICE inline float rgamma(float z) { return rgamma(static_cast<double>(z)); }
-
-XSF_HOST_DEVICE inline std::complex<double> rgamma(std::complex<double> z) {
-    // Compute 1/Gamma(z) using loggamma.
-    if (z.real() <= 0 && z == std::floor(z.real())) {
-        // Zeros at 0, -1, -2, ...
-        return 0.0;
-    }
-    return std::exp(-loggamma(z));
-}
-
-XSF_HOST_DEVICE inline std::complex<float> rgamma(std::complex<float> z) {
-    return static_cast<std::complex<float>>(rgamma(static_cast<std::complex<double>>(z)));
-}
-
-} // namespace xsf

scipy/special/xsf/sici.h

@@ -1,200 +0,0 @@
-/* Translated from Cython into C++ by SciPy developers in 2024.
- * Original header with Copyright information appears below.
- */
-
-/* Implementation of sin/cos/sinh/cosh integrals for complex arguments
- *
- * Sources
- * [1] Fredrik Johansson and others. mpmath: a Python library for
- *     arbitrary-precision floating-point arithmetic (version 0.19),
- *     December 2013. http://mpmath.org/.
- * [2] NIST, "Digital Library of Mathematical Functions",
- *     https://dlmf.nist.gov/
- */
-
-#pragma once
-
-#include "config.h"
-#include "error.h"
-
-#include "expint.h"
-#include "cephes/const.h"
-#include "cephes/sici.h"
-#include "cephes/shichi.h"
-
-namespace xsf {
-namespace detail {
-    
-    XSF_HOST_DEVICE inline void sici_power_series(int sgn, std::complex<double> z,
-						       std::complex<double> *s, std::complex<double> *c) {
-	/* DLMF 6.6.5 and 6.6.6. If sgn = -1 computes si/ci, and if sgn = 1
-	 * computes shi/chi.
-	 */        
-	std::complex<double> fac = z;
-	*s = fac;
-	*c = 0;
-	std::complex<double> term1, term2;
-	for (int n = 1; n < 100; n++) {
-	    fac *= static_cast<double>(sgn)*z/(2.0*n);
-	    term2 = fac/(2.0*n);
-	    *c += term2;
-	    fac *= z/(2.0*n + 1.0);
-	    term1 = fac/(2.0*n + 1.0);
-	    *s += term1;
-	    constexpr double tol = std::numeric_limits<double>::epsilon();
-	    if (std::abs(term1) < tol*std::abs(*s) && std::abs(term2) < tol*std::abs(*c)) {
-		break;
-	    }
-	}
-    }
-
-}
-
-    
-XSF_HOST_DEVICE inline int sici(std::complex<double> z,
-				    std::complex<double> *si, std::complex<double> *ci) {
-    /* Compute sin/cos integrals at complex arguments. The algorithm
-     * largely follows that of [1].
-     */
-
-    constexpr double EULER = xsf::cephes::detail::SCIPY_EULER;
-
-    if (z == std::numeric_limits<double>::infinity()) {
-        *si = M_PI_2;
-        *ci = 0;
-        return 0;
-    }
-    if (z == -std::numeric_limits<double>::infinity()) {
-	*si = -M_PI_2;
-        *ci = {0.0, M_PI};
-        return 0;
-    }
-
-    if (std::abs(z) < 0.8) {
-        // Use the series to avoid cancellation in si
-	detail::sici_power_series(-1, z, si, ci);
-
-        if (z == 0.0) {
-            set_error("sici", SF_ERROR_DOMAIN, NULL);
-            *ci = {-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()};
-        } else {
-            *ci += EULER + std::log(z);
-	}
-        return 0;
-    }
-    
-    // DLMF 6.5.5/6.5.6 plus DLMF 6.4.4/6.4.6/6.4.7
-    std::complex<double> jz = std::complex<double>(0.0, 1.0) * z;
-    std::complex<double> term1 = expi(jz);
-    std::complex<double> term2 = expi(-jz);
-    *si = std::complex<double>(0.0, -0.5)*(term1 - term2);
-    *ci = 0.5*(term1 + term2);
-    if (z.real() == 0) {
-        if (z.imag() > 0) {
-            *ci += std::complex<double>(0.0, M_PI_2);
-	} else if (z.imag() < 0) {
-            *ci -= std::complex<double>(0.0, M_PI_2);
-	}
-    } else if (z.real() > 0) {
-        *si -= M_PI_2;
-    } else {
-        *si += M_PI_2;
-        if (z.imag() >= 0) {
-            *ci += std::complex<double>(0.0, M_PI);
-        } else {
-            *ci -= std::complex<double>(0.0, M_PI);
-	}
-    }
-    return 0;
-}
-
-XSF_HOST_DEVICE inline int sici(std::complex<float> z,
-				    std::complex<float> *si_f, std::complex<float> *ci_f) {
-    std::complex<double> si;
-    std::complex<double> ci;
-    int res = sici(z, &si, &ci);
-    *si_f = si;
-    *ci_f = ci;
-    return res;
-}
-
-XSF_HOST_DEVICE inline int shichi(std::complex<double> z,
-				       std::complex<double> *shi, std::complex<double> *chi) {
-    /* Compute sinh/cosh integrals at complex arguments. The algorithm
-     * largely follows that of [1].
-     */
-    constexpr double EULER = xsf::cephes::detail::SCIPY_EULER;
-    if (z == std::numeric_limits<double>::infinity()) {
-        *shi = std::numeric_limits<double>::infinity();
-        *chi = std::numeric_limits<double>::infinity();
-        return 0;
-    }
-    if (z == -std::numeric_limits<double>::infinity()) {
-        *shi = -std::numeric_limits<double>::infinity();
-        *chi = std::numeric_limits<double>::infinity();
-        return 0;
-    }
-    if (std::abs(z) < 0.8) {
-        // Use the series to avoid cancellation in shi
-	detail::sici_power_series(1, z, shi, chi);
-        if (z == 0.0) {
-            set_error("shichi", SF_ERROR_DOMAIN, NULL);
-            *chi = {-std::numeric_limits<double>::infinity(), std::numeric_limits<double>::quiet_NaN()};
-        } else {
-            *chi += EULER + std::log(z);
-	}
-	return 0;
-    }
-
-    std::complex<double> term1 = expi(z);
-    std::complex<double> term2 = expi(-z);
-    *shi = 0.5*(term1 - term2);
-    *chi = 0.5*(term1 + term2);
-    if (z.imag() > 0) {
-        *shi -= std::complex<double>(0.0, 0.5*M_PI);
-        *chi += std::complex<double>(0.0, 0.5*M_PI);
-    } else if (z.imag() < 0) {
-        *shi += std::complex<double>(0.0, 0.5*M_PI);
-        *chi -= std::complex<double>(0.0, 0.5*M_PI);
-    } else if (z.real() < 0) {
-        *chi += std::complex<double>(0.0, M_PI);
-    }
-    return 0;
-}
-
-XSF_HOST_DEVICE inline int shichi(std::complex<float> z,
-				    std::complex<float> *shi_f, std::complex<float> *chi_f) {
-    std::complex<double> shi;
-    std::complex<double> chi;
-    int res = shichi(z, &shi, &chi);
-    *shi_f = shi;
-    *chi_f = chi;
-    return res;
-}
-
-XSF_HOST_DEVICE inline int sici(double x, double *si, double *ci) {
-    return cephes::sici(x, si, ci);
-}
-
-XSF_HOST_DEVICE inline int shichi(double x, double *shi, double *chi) {
-    return cephes::shichi(x, shi, chi);
-}
-
-XSF_HOST_DEVICE inline int sici(float x, float *si_f, float *ci_f) {
-    double si;
-    double ci;
-    int res = cephes::sici(x, &si, &ci);
-    *si_f = si;
-    *ci_f = ci;
-    return res;
-}
-
-XSF_HOST_DEVICE inline int shichi(float x, float *shi_f, float *chi_f) {
-    double shi;
-    double chi;
-    int res = cephes::shichi(x, &shi, &chi);
-    *shi_f = shi;
-    *chi_f = chi;
-    return res;
-}
-}