Add files using upload-large-folder tool

.gitattributes

@@ -1582,3 +1582,5 @@ vllm/lib/python3.10/site-packages/virtualenv/seed/wheels/embed/setuptools-75.8.0
 vllm/lib/python3.10/site-packages/pydantic_core/__pycache__/core_schema.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/virtualenv/seed/wheels/embed/pip-24.3.1-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
 vllm/lib/python3.10/site-packages/virtualenv/seed/wheels/embed/setuptools-75.3.0-py3-none-any.whl filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/scipy/signal/_peak_finding_utils.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/scipy/interpolate/_dfitpack.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

parrot/lib/python3.10/site-packages/scipy/interpolate/_dfitpack.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5073ae2a918ead9c332ed5f334e8b9ac1c2552cb2c36a961a27270819b0883a4
+size 346369

parrot/lib/python3.10/site-packages/scipy/signal/_peak_finding_utils.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf1aa7a2910bf166794c476bcdccb503d06ad6542b66d6128d1a23c04ebf7c14
+size 301392

parrot/lib/python3.10/site-packages/scipy/special/special/binom.h

@@ -0,0 +1,89 @@
+/* Translated from Cython into C++ by SciPy developers in 2024.
+ *
+ * Original authors: Pauli Virtanen, Eric Moore
+ */
+
+// Binomial coefficient
+
+#pragma once
+
+#include "config.h"
+
+#include "cephes/beta.h"
+#include "cephes/gamma.h"
+
+namespace special {
+
+SPECFUN_HOST_DEVICE inline double binom(double n, double k) {
+    double kx, nx, num, den, dk, sgn;
+
+    if (n < 0) {
+        nx = std::floor(n);
+        if (n == nx) {
+            // Undefined
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+    }
+
+    kx = std::floor(k);
+    if (k == kx && (std::abs(n) > 1E-8 || n == 0)) {
+        /* Integer case: use multiplication formula for less rounding
+         * error for cases where the result is an integer.
+         *
+         * This cannot be used for small nonzero n due to loss of
+         * precision. */
+        nx = std::floor(n);
+        if (nx == n && kx > nx / 2 && nx > 0) {
+            // Reduce kx by symmetry
+            kx = nx - kx;
+        }
+
+        if (kx >= 0 && kx < 20) {
+            num = 1.0;
+            den = 1.0;
+            for (int i = 1; i < 1 + static_cast<int>(kx); i++) {
+                num *= i + n - kx;
+                den *= i;
+                if (std::abs(num) > 1E50) {
+                    num /= den;
+                    den = 1.0;
+                }
+            }
+            return num / den;
+        }
+    }
+
+    // general case
+    if (n >= 1E10 * k and k > 0) {
+        // avoid under/overflows intermediate results
+        return std::exp(-cephes::lbeta(1 + n - k, 1 + k) - std::log(n + 1));
+    }
+    if (k > 1E8 * std::abs(n)) {
+        // avoid loss of precision
+        num = cephes::Gamma(1 + n) / std::abs(k) + cephes::Gamma(1 + n) * n / (2 * k * k); // + ...
+        num /= M_PI * std::pow(std::abs(k), n);
+        if (k > 0) {
+            kx = std::floor(k);
+            if (static_cast<int>(kx) == kx) {
+                dk = k - kx;
+                sgn = (static_cast<int>(kx) % 2 == 0) ? 1 : -1;
+            } else {
+                dk = k;
+                sgn = 1;
+            }
+            return num * std::sin((dk - n) * M_PI) * sgn;
+        }
+        kx = std::floor(k);
+        if (static_cast<int>(kx) == kx) {
+            return 0;
+        }
+        return num * std::sin(k * M_PI);
+    }
+    return 1 / (n + 1) / cephes::beta(1 + n - k, 1 + k);
+}
+
+SPECFUN_HOST_DEVICE inline float binom(float n, float k) {
+    return binom(static_cast<double>(n), static_cast<double>(k));
+}
+
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/cephes/besselpoly.h

@@ -0,0 +1,51 @@
+/* Translated into C++ by SciPy developers in 2024.
+ *
+ * This was not part of the original cephes library.
+ */
+#pragma once
+
+#include "../config.h"
+#include "gamma.h"
+
+namespace special {
+namespace cephes {
+    namespace detail {
+
+        constexpr double besselpoly_EPS = 1.0e-17;
+    }
+
+    SPECFUN_HOST_DEVICE inline double besselpoly(double a, double lambda, double nu) {
+
+        int m, factor = 0;
+        double Sm, relerr, Sol;
+        double sum = 0.0;
+
+        /* Special handling for a = 0.0 */
+        if (a == 0.0) {
+            if (nu == 0.0) {
+                return 1.0 / (lambda + 1);
+            } else {
+                return 0.0;
+            }
+        }
+        /* Special handling for negative and integer nu */
+        if ((nu < 0) && (std::floor(nu) == nu)) {
+            nu = -nu;
+            factor = static_cast<int>(nu) % 2;
+        }
+        Sm = std::exp(nu * std::log(a)) / (Gamma(nu + 1) * (lambda + nu + 1));
+        m = 0;
+        do {
+            sum += Sm;
+            Sol = Sm;
+            Sm *= -a * a * (lambda + nu + 1 + 2 * m) / ((nu + m + 1) * (m + 1) * (lambda + nu + 1 + 2 * m + 2));
+            m++;
+            relerr = std::abs((Sm - Sol) / Sm);
+        } while (relerr > detail::besselpoly_EPS && m < 1000);
+        if (!factor)
+            return sum;
+        else
+            return -sum;
+    }
+} // namespace cephes
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/cephes/igami.h

@@ -0,0 +1,313 @@
+/* Translated into C++ by SciPy developers in 2024.
+ * Original header with Copyright information appears below.
+ */
+
+/*
+ * (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 "gamma.h"
+#include "igam.h"
+#include "polevl.h"
+
+namespace special {
+namespace cephes {
+
+    namespace detail {
+
+        SPECFUN_HOST_DEVICE double find_inverse_s(double p, double q) {
+            /*
+             * Computation of the Incomplete Gamma Function Ratios and their Inverse
+             * ARMIDO R. DIDONATO and ALFRED H. MORRIS, JR.
+             * ACM Transactions on Mathematical Software, Vol. 12, No. 4,
+             * December 1986, Pages 377-393.
+             *
+             * See equation 32.
+             */
+            double s, t;
+            constexpr double a[4] = {0.213623493715853, 4.28342155967104, 11.6616720288968, 3.31125922108741};
+            constexpr double b[5] = {0.3611708101884203e-1, 1.27364489782223, 6.40691597760039, 6.61053765625462, 1};
+
+            if (p < 0.5) {
+                t = std::sqrt(-2 * std::log(p));
+            } else {
+                t = std::sqrt(-2 * std::log(q));
+            }
+            s = t - polevl(t, a, 3) / polevl(t, b, 4);
+            if (p < 0.5)
+                s = -s;
+            return s;
+        }
+
+        SPECFUN_HOST_DEVICE inline double didonato_SN(double a, double x, unsigned N, double tolerance) {
+            /*
+             * Computation of the Incomplete Gamma Function Ratios and their Inverse
+             * ARMIDO R. DIDONATO and ALFRED H. MORRIS, JR.
+             * ACM Transactions on Mathematical Software, Vol. 12, No. 4,
+             * December 1986, Pages 377-393.
+             *
+             * See equation 34.
+             */
+            double sum = 1.0;
+
+            if (N >= 1) {
+                unsigned i;
+                double partial = x / (a + 1);
+
+                sum += partial;
+                for (i = 2; i <= N; ++i) {
+                    partial *= x / (a + i);
+                    sum += partial;
+                    if (partial < tolerance) {
+                        break;
+                    }
+                }
+            }
+            return sum;
+        }
+
+        SPECFUN_HOST_DEVICE inline double find_inverse_gamma(double a, double p, double q) {
+            /*
+             * In order to understand what's going on here, you will
+             * need to refer to:
+             *
+             * Computation of the Incomplete Gamma Function Ratios and their Inverse
+             * ARMIDO R. DIDONATO and ALFRED H. MORRIS, JR.
+             * ACM Transactions on Mathematical Software, Vol. 12, No. 4,
+             * December 1986, Pages 377-393.
+             */
+            double result;
+
+            if (a == 1) {
+                if (q > 0.9) {
+                    result = -std::log1p(-p);
+                } else {
+                    result = -std::log(q);
+                }
+            } else if (a < 1) {
+                double g = special::cephes::Gamma(a);
+                double b = q * g;
+
+                if ((b > 0.6) || ((b >= 0.45) && (a >= 0.3))) {
+                    /* DiDonato & Morris Eq 21:
+                     *
+                     * There is a slight variation from DiDonato and Morris here:
+                     * the first form given here is unstable when p is close to 1,
+                     * making it impossible to compute the inverse of Q(a,x) for small
+                     * q. Fortunately the second form works perfectly well in this case.
+                     */
+                    double u;
+                    if ((b * q > 1e-8) && (q > 1e-5)) {
+                        u = std::pow(p * g * a, 1 / a);
+                    } else {
+                        u = std::exp((-q / a) - SCIPY_EULER);
+                    }
+                    result = u / (1 - (u / (a + 1)));
+                } else if ((a < 0.3) && (b >= 0.35)) {
+                    /* DiDonato & Morris Eq 22: */
+                    double t = std::exp(-SCIPY_EULER - b);
+                    double u = t * std::exp(t);
+                    result = t * std::exp(u);
+                } else if ((b > 0.15) || (a >= 0.3)) {
+                    /* DiDonato & Morris Eq 23: */
+                    double y = -std::log(b);
+                    double u = y - (1 - a) * std::log(y);
+                    result = y - (1 - a) * std::log(u) - std::log(1 + (1 - a) / (1 + u));
+                } else if (b > 0.1) {
+                    /* DiDonato & Morris Eq 24: */
+                    double y = -std::log(b);
+                    double u = y - (1 - a) * std::log(y);
+                    result = y - (1 - a) * std::log(u) -
+                             std::log((u * u + 2 * (3 - a) * u + (2 - a) * (3 - a)) / (u * u + (5 - a) * u + 2));
+                } else {
+                    /* DiDonato & Morris Eq 25: */
+                    double y = -std::log(b);
+                    double c1 = (a - 1) * std::log(y);
+                    double c1_2 = c1 * c1;
+                    double c1_3 = c1_2 * c1;
+                    double c1_4 = c1_2 * c1_2;
+                    double a_2 = a * a;
+                    double a_3 = a_2 * a;
+
+                    double c2 = (a - 1) * (1 + c1);
+                    double c3 = (a - 1) * (-(c1_2 / 2) + (a - 2) * c1 + (3 * a - 5) / 2);
+                    double c4 = (a - 1) * ((c1_3 / 3) - (3 * a - 5) * c1_2 / 2 + (a_2 - 6 * a + 7) * c1 +
+                                           (11 * a_2 - 46 * a + 47) / 6);
+                    double c5 = (a - 1) * (-(c1_4 / 4) + (11 * a - 17) * c1_3 / 6 + (-3 * a_2 + 13 * a - 13) * c1_2 +
+                                           (2 * a_3 - 25 * a_2 + 72 * a - 61) * c1 / 2 +
+                                           (25 * a_3 - 195 * a_2 + 477 * a - 379) / 12);
+
+                    double y_2 = y * y;
+                    double y_3 = y_2 * y;
+                    double y_4 = y_2 * y_2;
+                    result = y + c1 + (c2 / y) + (c3 / y_2) + (c4 / y_3) + (c5 / y_4);
+                }
+            } else {
+                /* DiDonato and Morris Eq 31: */
+                double s = find_inverse_s(p, q);
+
+                double s_2 = s * s;
+                double s_3 = s_2 * s;
+                double s_4 = s_2 * s_2;
+                double s_5 = s_4 * s;
+                double ra = std::sqrt(a);
+
+                double w = a + s * ra + (s_2 - 1) / 3;
+                w += (s_3 - 7 * s) / (36 * ra);
+                w -= (3 * s_4 + 7 * s_2 - 16) / (810 * a);
+                w += (9 * s_5 + 256 * s_3 - 433 * s) / (38880 * a * ra);
+
+                if ((a >= 500) && (std::abs(1 - w / a) < 1e-6)) {
+                    result = w;
+                } else if (p > 0.5) {
+                    if (w < 3 * a) {
+                        result = w;
+                    } else {
+                        double D = std::fmax(2, a * (a - 1));
+                        double lg = special::cephes::lgam(a);
+                        double lb = std::log(q) + lg;
+                        if (lb < -D * 2.3) {
+                            /* DiDonato and Morris Eq 25: */
+                            double y = -lb;
+                            double c1 = (a - 1) * std::log(y);
+                            double c1_2 = c1 * c1;
+                            double c1_3 = c1_2 * c1;
+                            double c1_4 = c1_2 * c1_2;
+                            double a_2 = a * a;
+                            double a_3 = a_2 * a;
+
+                            double c2 = (a - 1) * (1 + c1);
+                            double c3 = (a - 1) * (-(c1_2 / 2) + (a - 2) * c1 + (3 * a - 5) / 2);
+                            double c4 = (a - 1) * ((c1_3 / 3) - (3 * a - 5) * c1_2 / 2 + (a_2 - 6 * a + 7) * c1 +
+                                                   (11 * a_2 - 46 * a + 47) / 6);
+                            double c5 =
+                                (a - 1) * (-(c1_4 / 4) + (11 * a - 17) * c1_3 / 6 + (-3 * a_2 + 13 * a - 13) * c1_2 +
+                                           (2 * a_3 - 25 * a_2 + 72 * a - 61) * c1 / 2 +
+                                           (25 * a_3 - 195 * a_2 + 477 * a - 379) / 12);
+
+                            double y_2 = y * y;
+                            double y_3 = y_2 * y;
+                            double y_4 = y_2 * y_2;
+                            result = y + c1 + (c2 / y) + (c3 / y_2) + (c4 / y_3) + (c5 / y_4);
+                        } else {
+                            /* DiDonato and Morris Eq 33: */
+                            double u = -lb + (a - 1) * std::log(w) - std::log(1 + (1 - a) / (1 + w));
+                            result = -lb + (a - 1) * std::log(u) - std::log(1 + (1 - a) / (1 + u));
+                        }
+                    }
+                } else {
+                    double z = w;
+                    double ap1 = a + 1;
+                    double ap2 = a + 2;
+                    if (w < 0.15 * ap1) {
+                        /* DiDonato and Morris Eq 35: */
+                        double v = std::log(p) + special::cephes::lgam(ap1);
+                        z = std::exp((v + w) / a);
+                        s = std::log1p(z / ap1 * (1 + z / ap2));
+                        z = std::exp((v + z - s) / a);
+                        s = std::log1p(z / ap1 * (1 + z / ap2));
+                        z = std::exp((v + z - s) / a);
+                        s = std::log1p(z / ap1 * (1 + z / ap2 * (1 + z / (a + 3))));
+                        z = std::exp((v + z - s) / a);
+                    }
+
+                    if ((z <= 0.01 * ap1) || (z > 0.7 * ap1)) {
+                        result = z;
+                    } else {
+                        /* DiDonato and Morris Eq 36: */
+                        double ls = std::log(didonato_SN(a, z, 100, 1e-4));
+                        double v = std::log(p) + special::cephes::lgam(ap1);
+                        z = std::exp((v + z - ls) / a);
+                        result = z * (1 - (a * std::log(z) - z - v + ls) / (a - z));
+                    }
+                }
+            }
+            return result;
+        }
+
+    } // namespace detail
+
+    SPECFUN_HOST_DEVICE inline double igamci(double a, double q);
+
+    SPECFUN_HOST_DEVICE inline double igami(double a, double p) {
+        int i;
+        double x, fac, f_fp, fpp_fp;
+
+        if (std::isnan(a) || std::isnan(p)) {
+            return std::numeric_limits<double>::quiet_NaN();
+            ;
+        } else if ((a < 0) || (p < 0) || (p > 1)) {
+            set_error("gammaincinv", SF_ERROR_DOMAIN, NULL);
+        } else if (p == 0.0) {
+            return 0.0;
+        } else if (p == 1.0) {
+            return std::numeric_limits<double>::infinity();
+        } else if (p > 0.9) {
+            return igamci(a, 1 - p);
+        }
+
+        x = detail::find_inverse_gamma(a, p, 1 - p);
+        /* Halley's method */
+        for (i = 0; i < 3; i++) {
+            fac = detail::igam_fac(a, x);
+            if (fac == 0.0) {
+                return x;
+            }
+            f_fp = (igam(a, x) - p) * x / fac;
+            /* The ratio of the first and second derivatives simplifies */
+            fpp_fp = -1.0 + (a - 1) / x;
+            if (std::isinf(fpp_fp)) {
+                /* Resort to Newton's method in the case of overflow */
+                x = x - f_fp;
+            } else {
+                x = x - f_fp / (1.0 - 0.5 * f_fp * fpp_fp);
+            }
+        }
+
+        return x;
+    }
+
+    SPECFUN_HOST_DEVICE inline double igamci(double a, double q) {
+        int i;
+        double x, fac, f_fp, fpp_fp;
+
+        if (std::isnan(a) || std::isnan(q)) {
+            return std::numeric_limits<double>::quiet_NaN();
+        } else if ((a < 0.0) || (q < 0.0) || (q > 1.0)) {
+            set_error("gammainccinv", SF_ERROR_DOMAIN, NULL);
+        } else if (q == 0.0) {
+            return std::numeric_limits<double>::infinity();
+        } else if (q == 1.0) {
+            return 0.0;
+        } else if (q > 0.9) {
+            return igami(a, 1 - q);
+        }
+
+        x = detail::find_inverse_gamma(a, 1 - q, q);
+        for (i = 0; i < 3; i++) {
+            fac = detail::igam_fac(a, x);
+            if (fac == 0.0) {
+                return x;
+            }
+            f_fp = (igamc(a, x) - q) * x / (-fac);
+            fpp_fp = -1.0 + (a - 1) / x;
+            if (std::isinf(fpp_fp)) {
+                x = x - f_fp;
+            } else {
+                x = x - f_fp / (1.0 - 0.5 * f_fp * fpp_fp);
+            }
+        }
+
+        return x;
+    }
+
+} // namespace cephes
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/config.h

@@ -0,0 +1,226 @@
+#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 SPECFUN_HOST_DEVICE __host__ __device__
+
+#include <cuda/std/algorithm>
+#include <cuda/std/cmath>
+#include <cuda/std/cstdint>
+#include <cuda/std/limits>
+#include <cuda/std/type_traits>
+
+// Fallback to global namespace for functions unsupported on NVRTC Jit
+#ifdef _LIBCUDACXX_COMPILER_NVRTC
+#include <cuda_runtime.h>
+#endif
+
+namespace std {
+
+SPECFUN_HOST_DEVICE inline double abs(double num) { return cuda::std::abs(num); }
+
+SPECFUN_HOST_DEVICE inline double exp(double num) { return cuda::std::exp(num); }
+
+SPECFUN_HOST_DEVICE inline double log(double num) { return cuda::std::log(num); }
+
+SPECFUN_HOST_DEVICE inline double sqrt(double num) { return cuda::std::sqrt(num); }
+
+SPECFUN_HOST_DEVICE inline bool isinf(double num) { return cuda::std::isinf(num); }
+
+SPECFUN_HOST_DEVICE inline bool isnan(double num) { return cuda::std::isnan(num); }
+
+SPECFUN_HOST_DEVICE inline bool isfinite(double num) { return cuda::std::isfinite(num); }
+
+SPECFUN_HOST_DEVICE inline double pow(double x, double y) { return cuda::std::pow(x, y); }
+
+SPECFUN_HOST_DEVICE inline double sin(double x) { return cuda::std::sin(x); }
+
+SPECFUN_HOST_DEVICE inline double cos(double x) { return cuda::std::cos(x); }
+
+SPECFUN_HOST_DEVICE inline double tan(double x) { return cuda::std::tan(x); }
+
+SPECFUN_HOST_DEVICE inline double atan(double x) { return cuda::std::atan(x); }
+
+SPECFUN_HOSt_DEVICE inline double acos(double x) { return cuda::std::acos(x); }
+
+SPECFUN_HOST_DEVICE inline double sinh(double x) { return cuda::std::sinh(x); }
+
+SPECFUN_HOST_DEVICE inline double cosh(double x) { return cuda::std::cosh(x); }
+
+SPECFUN_HOST_DEVICE inline double asinh(double x) { return cuda::std::asinh(x); }
+
+SPECFUN_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
+SPECFUN_HOST_DEVICE inline double ceil(double x) { return cuda::std::ceil(x); }
+SPECFUN_HOST_DEVICE inline double floor(double x) { return cuda::std::floor(x); }
+SPECFUN_HOST_DEVICE inline double round(double x) { return cuda::std::round(x); }
+SPECFUN_HOST_DEVICE inline double trunc(double x) { return cuda::std::trunc(x); }
+SPECFUN_HOST_DEVICE inline double fma(double x, double y, double z) { return cuda::std::fma(x, y, z); }
+SPECFUN_HOST_DEVICE inline double copysign(double x, double y) { return cuda::std::copysign(x, y); }
+SPECFUN_HOST_DEVICE inline double modf(double value, double *iptr) { return cuda::std::modf(value, iptr); }
+SPECFUN_HOST_DEVICE inline double fmax(double x, double y) { return cuda::std::fmax(x, y); }
+SPECFUN_HOST_DEVICE inline double fmin(double x, double y) { return cuda::std::fmin(x, y); }
+SPECFUN_HOST_DEVICE inline double log10(double num) { return cuda::std::log10(num); }
+SPECFUN_HOST_DEVICE inline double log1p(double num) { return cuda::std::log1p(num); }
+SPECFUN_HOST_DEVICE inline double frexp(double num, int *exp) { return cuda::std::frexp(num); }
+SPECFUN_HOST_DEVICE inline double ldexp(double num, int *exp) { return cuda::std::ldexp(num); }
+SPECFUN_HOST_DEVICE inline double fmod(double x, double y) { return cuda::std::fmod(x, y); }
+#else
+SPECFUN_HOST_DEVICE inline double ceil(double x) { return ::ceil(x); }
+SPECFUN_HOST_DEVICE inline double floor(double x) { return ::floor(x); }
+SPECFUN_HOST_DEVICE inline double round(double x) { return ::round(x); }
+SPECFUN_HOST_DEVICE inline double trunc(double x) { return ::trunc(x); }
+SPECFUN_HOST_DEVICE inline double fma(double x, double y, double z) { return ::fma(x, y, z); }
+SPECFUN_HOST_DEVICE inline double copysign(double x, double y) { return ::copysign(x, y); }
+SPECFUN_HOST_DEVICE inline double modf(double value, double *iptr) { return ::modf(value, iptr); }
+SPECFUN_HOST_DEVICE inline double fmax(double x, double y) { return ::fmax(x, y); }
+SPECFUN_HOST_DEVICE inline double fmin(double x, double y) { return ::fmin(x, y); }
+SPECFUN_HOST_DEVICE inline double log10(double num) { return ::log10(num); }
+SPECFUN_HOST_DEVICE inline double log1p(double num) { return ::log1p(num); }
+SPECFUN_HOST_DEVICE inline double frexp(double num, int *exp) { return ::frexp(num); }
+SPECFUN_HOST_DEVICE inline double ldexp(double num, int *exp) { return ::ldexp(num); }
+SPECFUN_HOST_DEVICE inline double fmod(double x, double y) { return ::fmod(x, y); }
+#endif
+
+template <typename T>
+SPECFUN_HOST_DEVICE void swap(T &a, T &b) {
+    cuda::std::swap(a, b);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE const T &clamp(const T &v, const T &lo, const T &hi) {
+    return cuda::std::clamp(v, lo, hi);
+}
+
+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>
+SPECFUN_HOST_DEVICE T abs(const complex<T> &z) {
+    return thrust::abs(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> exp(const complex<T> &z) {
+    return thrust::exp(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> log(const complex<T> &z) {
+    return thrust::log(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE T norm(const complex<T> &z) {
+    return thrust::norm(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> sqrt(const complex<T> &z) {
+    return thrust::sqrt(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> conj(const complex<T> &z) {
+    return thrust::conj(z);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> pow(const complex<T> &x, const complex<T> &y) {
+    return thrust::pow(x, y);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE complex<T> pow(const complex<T> &x, const T &y) {
+    return thrust::pow(x, y);
+}
+
+// Other types and utilities
+using cuda::std::is_floating_point;
+using cuda::std::pair;
+using cuda::std::uint64_t;
+
+#define SPECFUN_ASSERT(a)
+
+} // namespace std
+
+#else
+#define SPECFUN_HOST_DEVICE
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <complex>
+#include <cstdint>
+#include <cstddef>
+#include <iterator>
+#include <limits>
+#include <math.h>
+#include <type_traits>
+#include <utility>
+
+#ifdef DEBUG
+#define SPECFUN_ASSERT(a) assert(a)
+#else
+#define SPECFUN_ASSERT(a)
+#endif
+
+#endif

parrot/lib/python3.10/site-packages/scipy/special/special/digamma.h

@@ -0,0 +1,204 @@
+/* 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 special {
+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>
+    SPECFUN_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;
+    }
+
+    SPECFUN_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;
+    }
+
+    SPECFUN_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;
+    }
+
+    SPECFUN_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
+
+SPECFUN_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);
+}
+
+SPECFUN_HOST_DEVICE inline float digamma(float z) { return static_cast<float>(digamma(static_cast<double>(z))); }
+
+SPECFUN_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;
+}
+
+SPECFUN_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 special

parrot/lib/python3.10/site-packages/scipy/special/special/error.h

@@ -0,0 +1,64 @@
+#pragma once
+
+// should be included from config.h, but that won't work until we've cleanly separated out the C and C++ parts of the
+// code
+#ifdef __CUDACC__
+#define SPECFUN_HOST_DEVICE __host__ __device__
+#else
+#define SPECFUN_HOST_DEVICE
+#endif
+
+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__LAST
+} sf_error_t;
+
+#ifdef __cplusplus
+
+#include <complex>
+
+namespace special {
+
+#ifndef SP_SPECFUN_ERROR
+SPECFUN_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>
+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>
+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 special
+
+#endif

parrot/lib/python3.10/site-packages/scipy/special/special/evalpoly.h

@@ -0,0 +1,47 @@
+/* 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 special {
+
+SPECFUN_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 special

parrot/lib/python3.10/site-packages/scipy/special/special/hyp2f1.h

@@ -0,0 +1,694 @@
+/* Implementation of Gauss's hypergeometric function for complex values.
+ *
+ * This implementation is based on the Fortran implementation by Shanjie Zhang and
+ * Jianming Jin included in specfun.f [1]_.  Computation of Gauss's hypergeometric
+ * function involves handling a patchwork of special cases. By default the Zhang and
+ * Jin implementation has been followed as closely as possible except for situations where
+ * an improvement was obvious. We've attempted to document the reasons behind decisions
+ * made by Zhang and Jin and to document the reasons for deviating from their implementation
+ * when this has been done. References to the NIST Digital Library of Mathematical
+ * Functions [2]_ have been added where they are appropriate. The review paper by
+ * Pearson et al [3]_ is an excellent resource for best practices for numerical
+ * computation of hypergeometric functions. We have followed this review paper
+ * when making improvements to and correcting defects in Zhang and Jin's
+ * implementation. When Pearson et al propose several competing alternatives for a
+ * given case, we've used our best judgment to decide on the method to use.
+ *
+ * Author: Albert Steppi
+ *
+ * Distributed under the same license as Scipy.
+ *
+ * References
+ * ----------
+ * .. [1] S. Zhang and J.M. Jin, "Computation of Special Functions", Wiley 1996
+ * .. [2] NIST Digital Library of Mathematical Functions. http://dlmf.nist.gov/,
+ *        Release 1.1.1 of 2021-03-15. F. W. J. Olver, A. B. Olde Daalhuis,
+ *        D. W. Lozier, B. I. Schneider, R. F. Boisvert, C. W. Clark, B. R. Miller,
+ *        B. V. Saunders, H. S. Cohl, and M. A. McClain, eds.
+ * .. [3] Pearson, J.W., Olver, S. & Porter, M.A.
+ *        "Numerical methods for the computation of the confluent and Gauss
+ *        hypergeometric functions."
+ *        Numer Algor 74, 821-866 (2017). https://doi.org/10.1007/s11075-016-0173-0
+ * .. [4] Raimundas Vidunas, "Degenerate Gauss Hypergeometric Functions",
+ *        Kyushu Journal of Mathematics, 2007, Volume 61, Issue 1, Pages 109-135,
+ * .. [5] López, J.L., Temme, N.M. New series expansions of the Gauss hypergeometric
+ *        function. Adv Comput Math 39, 349-365 (2013).
+ *        https://doi.org/10.1007/s10444-012-9283-y
+ * """
+ */
+
+#pragma once
+
+#include "config.h"
+#include "error.h"
+#include "tools.h"
+
+#include "binom.h"
+#include "cephes/gamma.h"
+#include "cephes/lanczos.h"
+#include "cephes/poch.h"
+#include "cephes/hyp2f1.h"
+#include "digamma.h"
+
+namespace special {
+namespace detail {
+    constexpr double hyp2f1_EPS = 1e-15;
+    /* The original implementation in SciPy from Zhang and Jin used 1500 for the
+     * maximum number of series iterations in some cases and 500 in others.
+     * Through the empirical results on the test cases in
+     * scipy/special/_precompute/hyp2f1_data.py, it was determined that these values
+     * can lead to early termination of series which would have eventually converged
+     * at a reasonable level of accuracy. We've bumped the iteration limit to 3000,
+     * and may adjust it again based on further analysis. */
+    constexpr std::uint64_t hyp2f1_MAXITER = 3000;
+
+    SPECFUN_HOST_DEVICE inline double four_gammas_lanczos(double u, double v, double w, double x) {
+        /* Compute ratio of gamma functions using lanczos approximation.
+         *
+         * Computes gamma(u)*gamma(v)/(gamma(w)*gamma(x))
+         *
+         * It is assumed that x = u + v - w, but it is left to the user to
+         * ensure this.
+         *
+         * The lanczos approximation takes the form
+         *
+         * gamma(x) = factor(x) * lanczos_sum_expg_scaled(x)
+         *
+         * where factor(x) = ((x + lanczos_g - 0.5)/e)**(x - 0.5).
+         *
+         * The formula above is only valid for x >= 0.5, but can be extended to
+         * x < 0.5 with the reflection principle.
+         *
+         * Using the lanczos approximation when computing this ratio of gamma functions
+         * allows factors to be combined analytically to avoid underflow and overflow
+         * and produce a more accurate result. The condition x = u + v - w makes it
+         * possible to cancel the factors in the expression
+         *
+         * factor(u) * factor(v) / (factor(w) * factor(x))
+         *
+         * by taking one factor and absorbing it into the others. Currently, this
+         * implementation takes the factor corresponding to the argument with largest
+         * absolute value and absorbs it into the others.
+         *
+         * Since this is only called internally by four_gammas. It is assumed that
+         * |u| >= |v| and |w| >= |x|.
+         */
+
+        /* The below implementation may incorrectly return finite results
+         * at poles of the gamma function. Handle these cases explicitly. */
+        if ((u == std::trunc(u) && u <= 0) || (v == std::trunc(v) && v <= 0)) {
+            /* Return nan if numerator has pole. Diverges to +- infinity
+             * depending on direction so value is undefined. */
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+        if ((w == std::trunc(w) && w <= 0) || (x == std::trunc(x) && x <= 0)) {
+            // Return 0 if denominator has pole but not numerator.
+            return 0.0;
+        }
+
+        double result = 1.0;
+        double ugh, vgh, wgh, xgh, u_prime, v_prime, w_prime, x_prime;
+
+        if (u >= 0.5) {
+            result *= cephes::lanczos_sum_expg_scaled(u);
+            ugh = u + cephes::lanczos_g - 0.5;
+            u_prime = u;
+        } else {
+            result /= cephes::lanczos_sum_expg_scaled(1 - u) * std::sin(M_PI * u) * M_1_PI;
+            ugh = 0.5 - u + cephes::lanczos_g;
+            u_prime = 1 - u;
+        }
+
+        if (v >= 0.5) {
+            result *= cephes::lanczos_sum_expg_scaled(v);
+            vgh = v + cephes::lanczos_g - 0.5;
+            v_prime = v;
+        } else {
+            result /= cephes::lanczos_sum_expg_scaled(1 - v) * std::sin(M_PI * v) * M_1_PI;
+            vgh = 0.5 - v + cephes::lanczos_g;
+            v_prime = 1 - v;
+        }
+
+        if (w >= 0.5) {
+            result /= cephes::lanczos_sum_expg_scaled(w);
+            wgh = w + cephes::lanczos_g - 0.5;
+            w_prime = w;
+        } else {
+            result *= cephes::lanczos_sum_expg_scaled(1 - w) * std::sin(M_PI * w) * M_1_PI;
+            wgh = 0.5 - w + cephes::lanczos_g;
+            w_prime = 1 - w;
+        }
+
+        if (x >= 0.5) {
+            result /= cephes::lanczos_sum_expg_scaled(x);
+            xgh = x + cephes::lanczos_g - 0.5;
+            x_prime = x;
+        } else {
+            result *= cephes::lanczos_sum_expg_scaled(1 - x) * std::sin(M_PI * x) * M_1_PI;
+            xgh = 0.5 - x + cephes::lanczos_g;
+            x_prime = 1 - x;
+        }
+
+        if (std::abs(u) >= std::abs(w)) {
+            // u has greatest absolute value. Absorb ugh into the others.
+            if (std::abs((v_prime - u_prime) * (v - 0.5)) < 100 * ugh and v > 100) {
+                /* Special case where base is close to 1. Condition taken from
+                 * Boost's beta function implementation. */
+                result *= std::exp((v - 0.5) * std::log1p((v_prime - u_prime) / ugh));
+            } else {
+                result *= std::pow(vgh / ugh, v - 0.5);
+            }
+
+            if (std::abs((u_prime - w_prime) * (w - 0.5)) < 100 * wgh and u > 100) {
+                result *= std::exp((w - 0.5) * std::log1p((u_prime - w_prime) / wgh));
+            } else {
+                result *= std::pow(ugh / wgh, w - 0.5);
+            }
+
+            if (std::abs((u_prime - x_prime) * (x - 0.5)) < 100 * xgh and u > 100) {
+                result *= std::exp((x - 0.5) * std::log1p((u_prime - x_prime) / xgh));
+            } else {
+                result *= std::pow(ugh / xgh, x - 0.5);
+            }
+        } else {
+            // w has greatest absolute value. Absorb wgh into the others.
+            if (std::abs((u_prime - w_prime) * (u - 0.5)) < 100 * wgh and u > 100) {
+                result *= std::exp((u - 0.5) * std::log1p((u_prime - w_prime) / wgh));
+            } else {
+                result *= pow(ugh / wgh, u - 0.5);
+            }
+            if (std::abs((v_prime - w_prime) * (v - 0.5)) < 100 * wgh and v > 100) {
+                result *= std::exp((v - 0.5) * std::log1p((v_prime - w_prime) / wgh));
+            } else {
+                result *= std::pow(vgh / wgh, v - 0.5);
+            }
+            if (std::abs((w_prime - x_prime) * (x - 0.5)) < 100 * xgh and x > 100) {
+                result *= std::exp((x - 0.5) * std::log1p((w_prime - x_prime) / xgh));
+            } else {
+                result *= std::pow(wgh / xgh, x - 0.5);
+            }
+        }
+        // This exhausts all cases because we assume |u| >= |v| and |w| >= |x|.
+
+        return result;
+    }
+
+    SPECFUN_HOST_DEVICE inline double four_gammas(double u, double v, double w, double x) {
+        double result;
+
+        // Without loss of generality, assume |u| >= |v| and |w| >= |x|.
+        if (std::abs(u) > std::abs(v)) {
+            std::swap(u, v);
+        }
+        if (std::abs(x) > std::abs(w)) {
+            std::swap(x, w);
+        }
+        /* Direct ratio tends to be more accurate for arguments in this range. Range
+         * chosen empirically based on the relevant benchmarks in
+         * scipy/special/_precompute/hyp2f1_data.py */
+        if (std::abs(u) <= 100 && std::abs(v) <= 100 && std::abs(w) <= 100 && std::abs(x) <= 100) {
+            result = cephes::Gamma(u) * cephes::Gamma(v) / (cephes::Gamma(w) * cephes::Gamma(x));
+            if (std::isfinite(result) && result != 0.0) {
+                return result;
+            }
+        }
+        result = four_gammas_lanczos(u, v, w, x);
+        if (std::isfinite(result) && result != 0.0) {
+            return result;
+        }
+        // If overflow or underflow, try again with logs.
+        result = std::exp(cephes::lgam(v) - cephes::lgam(x) + cephes::lgam(u) - cephes::lgam(w));
+        result *= cephes::gammasgn(u) * cephes::gammasgn(w) * cephes::gammasgn(v) * cephes::gammasgn(x);
+        return result;
+    }
+
+    class HypergeometricSeriesGenerator {
+        /* Maclaurin series for hyp2f1.
+         *
+         * Series is convergent for |z| < 1 but is only practical for numerical
+         * computation when |z| < 0.9.
+         */
+      public:
+        SPECFUN_HOST_DEVICE HypergeometricSeriesGenerator(double a, double b, double c, std::complex<double> z)
+            : a_(a), b_(b), c_(c), z_(z), term_(1.0), k_(0) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            std::complex<double> output = term_;
+            term_ = term_ * (a_ + k_) * (b_ + k_) / ((k_ + 1) * (c_ + k_)) * z_;
+            ++k_;
+            return output;
+        }
+
+      private:
+        double a_, b_, c_;
+        std::complex<double> z_, term_;
+        std::uint64_t k_;
+    };
+
+    class Hyp2f1Transform1Generator {
+        /* 1 -z transformation of standard series.*/
+      public:
+        SPECFUN_HOST_DEVICE Hyp2f1Transform1Generator(double a, double b, double c, std::complex<double> z)
+            : factor1_(four_gammas(c, c - a - b, c - a, c - b)),
+              factor2_(four_gammas(c, a + b - c, a, b) * std::pow(1.0 - z, c - a - b)),
+              generator1_(HypergeometricSeriesGenerator(a, b, a + b - c + 1, 1.0 - z)),
+              generator2_(HypergeometricSeriesGenerator(c - a, c - b, c - a - b + 1, 1.0 - z)) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            return factor1_ * generator1_() + factor2_ * generator2_();
+        }
+
+      private:
+        std::complex<double> factor1_, factor2_;
+        HypergeometricSeriesGenerator generator1_, generator2_;
+    };
+
+    class Hyp2f1Transform1LimitSeriesGenerator {
+        /* 1 - z transform in limit as c - a - b approaches an integer m. */
+      public:
+        SPECFUN_HOST_DEVICE Hyp2f1Transform1LimitSeriesGenerator(double a, double b, double m, std::complex<double> z)
+            : d1_(special::digamma(a)), d2_(special::digamma(b)), d3_(special::digamma(1 + m)),
+              d4_(special::digamma(1.0)), a_(a), b_(b), m_(m), z_(z), log_1_z_(std::log(1.0 - z)),
+              factor_(1.0 / cephes::Gamma(m + 1)), k_(0) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            std::complex<double> term_ = (d1_ + d2_ - d3_ - d4_ + log_1_z_) * factor_;
+            // Use digamma(x + 1) = digamma(x) + 1/x
+            d1_ += 1 / (a_ + k_);       // d1 = digamma(a + k)
+            d2_ += 1 / (b_ + k_);       // d2 = digamma(b + k)
+            d3_ += 1 / (1.0 + m_ + k_); // d3 = digamma(1 + m + k)
+            d4_ += 1 / (1.0 + k_);      // d4 = digamma(1 + k)
+            factor_ *= (a_ + k_) * (b_ + k_) / ((k_ + 1.0) * (m_ + k_ + 1)) * (1.0 - z_);
+            ++k_;
+            return term_;
+        }
+
+      private:
+        double d1_, d2_, d3_, d4_, a_, b_, m_;
+        std::complex<double> z_, log_1_z_, factor_;
+        int k_;
+    };
+
+    class Hyp2f1Transform2Generator {
+        /* 1/z transformation of standard series.*/
+      public:
+        SPECFUN_HOST_DEVICE Hyp2f1Transform2Generator(double a, double b, double c, std::complex<double> z)
+            : factor1_(four_gammas(c, b - a, b, c - a) * std::pow(-z, -a)),
+              factor2_(four_gammas(c, a - b, a, c - b) * std::pow(-z, -b)),
+              generator1_(HypergeometricSeriesGenerator(a, a - c + 1, a - b + 1, 1.0 / z)),
+              generator2_(HypergeometricSeriesGenerator(b, b - c + 1, b - a + 1, 1.0 / z)) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            return factor1_ * generator1_() + factor2_ * generator2_();
+        }
+
+      private:
+        std::complex<double> factor1_, factor2_;
+        HypergeometricSeriesGenerator generator1_, generator2_;
+    };
+
+    class Hyp2f1Transform2LimitSeriesGenerator {
+        /* 1/z transform in limit as a - b approaches a non-negative integer m. (Can swap a and b to
+         * handle the m a negative integer case. */
+      public:
+        SPECFUN_HOST_DEVICE Hyp2f1Transform2LimitSeriesGenerator(double a, double b, double c, double m,
+                                                                 std::complex<double> z)
+            : d1_(special::digamma(1.0)), d2_(special::digamma(1 + m)), d3_(special::digamma(a)),
+              d4_(special::digamma(c - a)), a_(a), b_(b), c_(c), m_(m), z_(z), log_neg_z_(std::log(-z)),
+              factor_(special::cephes::poch(b, m) * special::cephes::poch(1 - c + b, m) /
+                      special::cephes::Gamma(m + 1)),
+              k_(0) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            std::complex<double> term = (d1_ + d2_ - d3_ - d4_ + log_neg_z_) * factor_;
+            // Use digamma(x + 1) = digamma(x) + 1/x
+            d1_ += 1 / (1.0 + k_);         // d1 = digamma(1 + k)
+            d2_ += 1 / (1.0 + m_ + k_);    // d2 = digamma(1 + m + k)
+            d3_ += 1 / (a_ + k_);          // d3 = digamma(a + k)
+            d4_ -= 1 / (c_ - a_ - k_ - 1); // d4 = digamma(c - a - k)
+            factor_ *= (b_ + m_ + k_) * (1 - c_ + b_ + m_ + k_) / ((k_ + 1) * (m_ + k_ + 1)) / z_;
+            ++k_;
+            return term;
+        }
+
+      private:
+        double d1_, d2_, d3_, d4_, a_, b_, c_, m_;
+        std::complex<double> z_, log_neg_z_, factor_;
+        std::uint64_t k_;
+    };
+
+    class Hyp2f1Transform2LimitSeriesCminusAIntGenerator {
+        /* 1/z transform in limit as a - b approaches a non-negative integer m, and c - a approaches
+         * a positive integer n. */
+      public:
+        SPECFUN_HOST_DEVICE Hyp2f1Transform2LimitSeriesCminusAIntGenerator(double a, double b, double c, double m,
+                                                                           double n, std::complex<double> z)
+            : d1_(special::digamma(1.0)), d2_(special::digamma(1 + m)), d3_(special::digamma(a)),
+              d4_(special::digamma(n)), a_(a), b_(b), c_(c), m_(m), n_(n), z_(z), log_neg_z_(std::log(-z)),
+              factor_(special::cephes::poch(b, m) * special::cephes::poch(1 - c + b, m) /
+                      special::cephes::Gamma(m + 1)),
+              k_(0) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            std::complex<double> term;
+            if (k_ < n_) {
+                term = (d1_ + d2_ - d3_ - d4_ + log_neg_z_) * factor_;
+                // Use digamma(x + 1) = digamma(x) + 1/x
+                d1_ += 1 / (1.0 + k_);    // d1 = digamma(1 + k)
+                d2_ += 1 / (1 + m_ + k_); // d2 = digamma(1 + m + k)
+                d3_ += 1 / (a_ + k_);     // d3 = digamma(a + k)
+                d4_ -= 1 / (n_ - k_ - 1); // d4 = digamma(c - a - k)
+                factor_ *= (b_ + m_ + k_) * (1 - c_ + b_ + m_ + k_) / ((k_ + 1) * (m_ + k_ + 1)) / z_;
+                ++k_;
+                return term;
+            }
+            if (k_ == n_) {
+                /* When c - a approaches a positive integer and k_ >= c - a = n then
+                 * poch(1 - c + b + m + k) = poch(1 - c + a + k) = approaches zero and
+                 * digamma(c - a - k) approaches a pole. However we can use the limit
+                 * digamma(-n + epsilon) / gamma(-n + epsilon) -> (-1)**(n + 1) * (n+1)! as epsilon -> 0
+                 * to continue the series.
+                 *
+                 * poch(1 - c + b, m + k) = gamma(1 - c + b + m + k)/gamma(1 - c + b)
+                 *
+                 * If a - b is an integer and c - a is an integer, then a and b must both be integers, so assume
+                 * a and b are integers and take the limit as c approaches an integer.
+                 *
+                 * gamma(1 - c + epsilon + a + k)/gamma(1 - c - epsilon + b) =
+                 * (gamma(c + epsilon - b) / gamma(c + epsilon - a - k)) *
+                 * (sin(pi * (c + epsilon - b)) / sin(pi * (c + epsilon - a - k))) (reflection principle)
+                 *
+                 * In the limit as epsilon goes to zero, the ratio of sines will approach
+                 * (-1)**(a - b + k) = (-1)**(m + k)
+                 *
+                 * We may then replace
+                 *
+                 * poch(1 - c - epsilon + b, m + k)*digamma(c + epsilon - a - k)
+                 *
+                 * with
+                 *
+                 * (-1)**(a - b + k)*gamma(c + epsilon - b) * digamma(c + epsilon - a - k) / gamma(c + epsilon - a - k)
+                 *
+                 * and taking the limit epsilon -> 0 gives
+                 *
+                 * (-1)**(a - b + k) * gamma(c - b) * (-1)**(k + a - c + 1)(k + a - c)!
+                 * = (-1)**(c - b - 1)*Gamma(k + a - c + 1)
+                 */
+                factor_ = std::pow(-1, m_ + n_) * special::binom(c_ - 1, b_ - 1) *
+                          special::cephes::poch(c_ - a_ + 1, m_ - 1) / std::pow(z_, static_cast<double>(k_));
+            }
+            term = factor_;
+            factor_ *= (b_ + m_ + k_) * (k_ + a_ - c_ + 1) / ((k_ + 1) * (m_ + k_ + 1)) / z_;
+            ++k_;
+            return term;
+        }
+
+      private:
+        double d1_, d2_, d3_, d4_, a_, b_, c_, m_, n_;
+        std::complex<double> z_, log_neg_z_, factor_;
+        std::uint64_t k_;
+    };
+
+    class Hyp2f1Transform2LimitFinitePartGenerator {
+        /* Initial finite sum in limit as a - b approaches a non-negative integer m. The limiting series
+         * for the 1 - z transform also has an initial finite sum, but it is a standard hypergeometric
+         * series. */
+      public:
+        SPECFUN_HOST_DEVICE Hyp2f1Transform2LimitFinitePartGenerator(double b, double c, double m,
+                                                                     std::complex<double> z)
+            : b_(b), c_(c), m_(m), z_(z), term_(cephes::Gamma(m) / cephes::Gamma(c - b)), k_(0) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            std::complex<double> output = term_;
+            term_ = term_ * (b_ + k_) * (c_ - b_ - k_ - 1) / ((k_ + 1) * (m_ - k_ - 1)) / z_;
+            ++k_;
+            return output;
+        }
+
+      private:
+        double b_, c_, m_;
+        std::complex<double> z_, term_;
+        std::uint64_t k_;
+    };
+
+    class LopezTemmeSeriesGenerator {
+        /* Lopez-Temme Series for Gaussian hypergeometric function [4].
+         *
+         * Converges for all z with real(z) < 1, including in the regions surrounding
+         * the points exp(+- i*pi/3) that are not covered by any of the standard
+         * transformations.
+         */
+      public:
+        SPECFUN_HOST_DEVICE LopezTemmeSeriesGenerator(double a, double b, double c, std::complex<double> z)
+            : n_(0), a_(a), b_(b), c_(c), phi_previous_(1.0), phi_(1 - 2 * b / c), z_(z), Z_(a * z / (z - 2.0)) {}
+
+        SPECFUN_HOST_DEVICE std::complex<double> operator()() {
+            if (n_ == 0) {
+                ++n_;
+                return 1.0;
+            }
+            if (n_ > 1) { // Update phi and Z for n>=2
+                double new_phi = ((n_ - 1) * phi_previous_ - (2.0 * b_ - c_) * phi_) / (c_ + (n_ - 1));
+                phi_previous_ = phi_;
+                phi_ = new_phi;
+                Z_ = Z_ * z_ / (z_ - 2.0) * ((a_ + (n_ - 1)) / n_);
+            }
+            ++n_;
+            return Z_ * phi_;
+        }
+
+      private:
+        std::uint64_t n_;
+        double a_, b_, c_, phi_previous_, phi_;
+        std::complex<double> z_, Z_;
+    };
+
+    SPECFUN_HOST_DEVICE std::complex<double> hyp2f1_transform1_limiting_case(double a, double b, double c, double m,
+                                                                             std::complex<double> z) {
+        /* 1 - z transform in limiting case where c - a - b approaches an integer m. */
+        std::complex<double> result = 0.0;
+        if (m >= 0) {
+            if (m != 0) {
+                auto series_generator = HypergeometricSeriesGenerator(a, b, 1 - m, 1.0 - z);
+                result += four_gammas(m, c, a + m, b + m) * series_eval_fixed_length(series_generator,
+                                                                                     std::complex<double>{0.0, 0.0},
+                                                                                     static_cast<std::uint64_t>(m));
+            }
+            std::complex<double> prefactor = std::pow(-1.0, m + 1) * special::cephes::Gamma(c) /
+                                             (special::cephes::Gamma(a) * special::cephes::Gamma(b)) *
+                                             std::pow(1.0 - z, m);
+            auto series_generator = Hyp2f1Transform1LimitSeriesGenerator(a + m, b + m, m, z);
+            result += prefactor * series_eval(series_generator, std::complex<double>{0.0, 0.0}, hyp2f1_EPS,
+                                              hyp2f1_MAXITER, "hyp2f1");
+            return result;
+        } else {
+            result = four_gammas(-m, c, a, b) * std::pow(1.0 - z, m);
+            auto series_generator1 = HypergeometricSeriesGenerator(a + m, b + m, 1 + m, 1.0 - z);
+            result *= series_eval_fixed_length(series_generator1, std::complex<double>{0.0, 0.0},
+                                               static_cast<std::uint64_t>(-m));
+            double prefactor = std::pow(-1.0, m + 1) * special::cephes::Gamma(c) /
+                               (special::cephes::Gamma(a + m) * special::cephes::Gamma(b + m));
+            auto series_generator2 = Hyp2f1Transform1LimitSeriesGenerator(a, b, -m, z);
+            result += prefactor * series_eval(series_generator2, std::complex<double>{0.0, 0.0}, hyp2f1_EPS,
+                                              hyp2f1_MAXITER, "hyp2f1");
+            return result;
+        }
+    }
+
+    SPECFUN_HOST_DEVICE std::complex<double> hyp2f1_transform2_limiting_case(double a, double b, double c, double m,
+                                                                             std::complex<double> z) {
+        /* 1 / z transform in limiting case where a - b approaches a non-negative integer m. Negative integer case
+         * can be handled by swapping a and b. */
+        auto series_generator1 = Hyp2f1Transform2LimitFinitePartGenerator(b, c, m, z);
+        std::complex<double> result = cephes::Gamma(c) / cephes::Gamma(a) * std::pow(-z, -b);
+        result *=
+            series_eval_fixed_length(series_generator1, std::complex<double>{0.0, 0.0}, static_cast<std::uint64_t>(m));
+        std::complex<double> prefactor = cephes::Gamma(c) / (cephes::Gamma(a) * cephes::Gamma(c - b) * std::pow(-z, a));
+        double n = c - a;
+        if (abs(n - std::round(n)) < hyp2f1_EPS) {
+            auto series_generator2 = Hyp2f1Transform2LimitSeriesCminusAIntGenerator(a, b, c, m, n, z);
+            result += prefactor * series_eval(series_generator2, std::complex<double>{0.0, 0.0}, hyp2f1_EPS,
+                                              hyp2f1_MAXITER, "hyp2f1");
+            return result;
+        }
+        auto series_generator2 = Hyp2f1Transform2LimitSeriesGenerator(a, b, c, m, z);
+        result += prefactor *
+                  series_eval(series_generator2, std::complex<double>{0.0, 0.0}, hyp2f1_EPS, hyp2f1_MAXITER, "hyp2f1");
+        return result;
+    }
+
+} // namespace detail
+
+SPECFUN_HOST_DEVICE inline std::complex<double> hyp2f1(double a, double b, double c, std::complex<double> z) {
+    /* Special Cases
+     * -----------------------------------------------------------------------
+     * Takes constant value 1 when a = 0 or b = 0, even if c is a non-positive
+     * integer. This follows mpmath. */
+    if (a == 0 || b == 0) {
+        return 1.0;
+    }
+    double z_abs = std::abs(z);
+    // Equals 1 when z i 0, unless c is 0.
+    if (z_abs == 0) {
+        if (c != 0) {
+            return 1.0;
+        } else {
+            // Returning real part NAN and imaginary part 0 follows mpmath.
+            return std::complex<double>{std::numeric_limits<double>::quiet_NaN(), 0};
+        }
+    }
+    bool a_neg_int = a == std::trunc(a) && a < 0;
+    bool b_neg_int = b == std::trunc(b) && b < 0;
+    bool c_non_pos_int = c == std::trunc(c) and c <= 0;
+    /* Diverges when c is a non-positive integer unless a is an integer with
+     * c <= a <= 0 or b is an integer with c <= b <= 0, (or z equals 0 with
+     * c != 0) Cases z = 0, a = 0, or b = 0 have already been handled. We follow
+     * mpmath in handling the degenerate cases where any of a, b, c are
+     * non-positive integers. See [3] for a treatment of degenerate cases. */
+    if (c_non_pos_int && !((a_neg_int && c <= a && a < 0) || (b_neg_int && c <= b && b < 0))) {
+        return std::complex<double>{std::numeric_limits<double>::infinity(), 0};
+    }
+    /* Reduces to a polynomial when a or b is a negative integer.
+     * If a and b are both negative integers, we take care to terminate
+     * the series at a or b of smaller magnitude. This is to ensure proper
+     * handling of situations like a < c < b <= 0, a, b, c all non-positive
+     * integers, where terminating at a would lead to a term of the form 0 / 0. */
+    std::uint64_t max_degree;
+    if (a_neg_int || b_neg_int) {
+        if (a_neg_int && b_neg_int) {
+            max_degree = a > b ? std::abs(a) : std::abs(b);
+        } else if (a_neg_int) {
+            max_degree = std::abs(a);
+        } else {
+            max_degree = std::abs(b);
+        }
+        if (max_degree <= UINT64_MAX) {
+            auto series_generator = detail::HypergeometricSeriesGenerator(a, b, c, z);
+            return detail::series_eval_fixed_length(series_generator, std::complex<double>{0.0, 0.0}, max_degree + 1);
+        } else {
+            set_error("hyp2f1", SF_ERROR_NO_RESULT, NULL);
+            return std::complex<double>{std::numeric_limits<double>::quiet_NaN(),
+                                        std::numeric_limits<double>::quiet_NaN()};
+        }
+    }
+    // Kummer's Theorem for z = -1; c = 1 + a - b (DLMF 15.4.26)
+    if (std::abs(z + 1.0) < detail::hyp2f1_EPS && std::abs(1 + a - b - c) < detail::hyp2f1_EPS && !c_non_pos_int) {
+        return detail::four_gammas(a - b + 1, 0.5 * a + 1, a + 1, 0.5 * a - b + 1);
+    }
+    std::complex<double> result;
+    bool c_minus_a_neg_int = c - a == std::trunc(c - a) && c - a < 0;
+    bool c_minus_b_neg_int = c - b == std::trunc(c - b) && c - b < 0;
+    /* If one of c - a or c - b is a negative integer, reduces to evaluating
+     * a polynomial through an Euler hypergeometric transformation.
+     * (DLMF 15.8.1) */
+    if (c_minus_a_neg_int || c_minus_b_neg_int) {
+        max_degree = c_minus_b_neg_int ? std::abs(c - b) : std::abs(c - a);
+        if (max_degree <= UINT64_MAX) {
+            result = std::pow(1.0 - z, c - a - b);
+            auto series_generator = detail::HypergeometricSeriesGenerator(c - a, c - b, c, z);
+            result *=
+                detail::series_eval_fixed_length(series_generator, std::complex<double>{0.0, 0.0}, max_degree + 2);
+            return result;
+        } else {
+            set_error("hyp2f1", SF_ERROR_NO_RESULT, NULL);
+            return std::complex<double>{std::numeric_limits<double>::quiet_NaN(),
+                                        std::numeric_limits<double>::quiet_NaN()};
+        }
+    }
+    /* Diverges as real(z) -> 1 when c <= a + b.
+     * Todo: Actually check for overflow instead of using a fixed tolerance for
+     * all parameter combinations like in the Fortran original. */
+    if (std::abs(1 - z.real()) < detail::hyp2f1_EPS && z.imag() == 0 && c - a - b <= 0 && !c_non_pos_int) {
+        return std::complex<double>{std::numeric_limits<double>::infinity(), 0};
+    }
+    // Gauss's Summation Theorem for z = 1; c - a - b > 0 (DLMF 15.4.20).
+    if (z == 1.0 && c - a - b > 0 && !c_non_pos_int) {
+        return detail::four_gammas(c, c - a - b, c - a, c - b);
+    }
+    /* |z| < 0, z.real() >= 0. Use the Maclaurin Series.
+     * -----------------------------------------------------------------------
+     * Apply Euler Hypergeometric Transformation (DLMF 15.8.1) to reduce
+     * size of a and b if possible. We follow Zhang and Jin's
+     * implementation [1] although there is very likely a better heuristic
+     * to determine when this transformation should be applied. As it
+     * stands, this hurts precision in some cases. */
+    if (z_abs < 0.9 && z.real() >= 0) {
+        if (c - a < a && c - b < b) {
+            result = std::pow(1.0 - z, c - a - b);
+            auto series_generator = detail::HypergeometricSeriesGenerator(c - a, c - b, c, z);
+            result *= detail::series_eval(series_generator, std::complex<double>{0.0, 0.0}, detail::hyp2f1_EPS,
+                                          detail::hyp2f1_MAXITER, "hyp2f1");
+            return result;
+        }
+        auto series_generator = detail::HypergeometricSeriesGenerator(a, b, c, z);
+        return detail::series_eval(series_generator, std::complex<double>{0.0, 0.0}, detail::hyp2f1_EPS,
+                                   detail::hyp2f1_MAXITER, "hyp2f1");
+    }
+    /* Points near exp(iπ/3), exp(-iπ/3) not handled by any of the standard
+     * transformations. Use series of López and Temme [5]. These regions
+     * were not correctly handled by Zhang and Jin's implementation.
+     * -------------------------------------------------------------------------*/
+    if (0.9 <= z_abs && z_abs < 1.1 && std::abs(1.0 - z) >= 0.9 && z.real() >= 0) {
+        /* This condition for applying Euler Transformation (DLMF 15.8.1)
+         * was determined empirically to work better for this case than that
+         * used in Zhang and Jin's implementation for |z| < 0.9,
+         *  real(z) >= 0. */
+        if ((c - a <= a && c - b < b) || (c - a < a && c - b <= b)) {
+            auto series_generator = detail::LopezTemmeSeriesGenerator(c - a, c - b, c, z);
+            result = std::pow(1.0 - 0.5 * z, a - c); // Lopez-Temme prefactor
+            result *= detail::series_eval(series_generator, std::complex<double>{0.0, 0.0}, detail::hyp2f1_EPS,
+                                          detail::hyp2f1_MAXITER, "hyp2f1");
+            return std::pow(1.0 - z, c - a - b) * result; // Euler transform prefactor.
+        }
+        auto series_generator = detail::LopezTemmeSeriesGenerator(a, b, c, z);
+        result = detail::series_eval(series_generator, std::complex<double>{0.0, 0.0}, detail::hyp2f1_EPS,
+                                     detail::hyp2f1_MAXITER, "hyp2f1");
+        return std::pow(1.0 - 0.5 * z, -a) * result; // Lopez-Temme prefactor.
+    }
+    /* z/(z - 1) transformation (DLMF 15.8.1). Avoids cancellation issues that
+     * occur with Maclaurin series for real(z) < 0.
+     * -------------------------------------------------------------------------*/
+    if (z_abs < 1.1 && z.real() < 0) {
+        if (0 < b && b < a && a < c) {
+            std::swap(a, b);
+        }
+        auto series_generator = detail::HypergeometricSeriesGenerator(a, c - b, c, z / (z - 1.0));
+        return std::pow(1.0 - z, -a) * detail::series_eval(series_generator, std::complex<double>{0.0, 0.0},
+                                                           detail::hyp2f1_EPS, detail::hyp2f1_MAXITER, "hyp2f1");
+    }
+    /* 1 - z transformation (DLMF 15.8.4). */
+    if (0.9 <= z_abs && z_abs < 1.1) {
+        if (std::abs(c - a - b - std::round(c - a - b)) < detail::hyp2f1_EPS) {
+            // Removable singularity when c - a - b is an integer. Need to use limiting formula.
+            double m = std::round(c - a - b);
+            return detail::hyp2f1_transform1_limiting_case(a, b, c, m, z);
+        }
+        auto series_generator = detail::Hyp2f1Transform1Generator(a, b, c, z);
+        return detail::series_eval(series_generator, std::complex<double>{0.0, 0.0}, detail::hyp2f1_EPS,
+                                   detail::hyp2f1_MAXITER, "hyp2f1");
+    }
+    /* 1/z transformation (DLMF 15.8.2). */
+    if (std::abs(a - b - std::round(a - b)) < detail::hyp2f1_EPS) {
+        if (b > a) {
+            std::swap(a, b);
+        }
+        double m = std::round(a - b);
+        return detail::hyp2f1_transform2_limiting_case(a, b, c, m, z);
+    }
+    auto series_generator = detail::Hyp2f1Transform2Generator(a, b, c, z);
+    return detail::series_eval(series_generator, std::complex<double>{0.0, 0.0}, detail::hyp2f1_EPS,
+                               detail::hyp2f1_MAXITER, "hyp2f1");
+}
+
+inline std::complex<float> hyp2f1(float a, float b, float c, std::complex<float> x) {
+    return static_cast<std::complex<float>>(hyp2f1(static_cast<double>(a), static_cast<double>(b),
+                                                   static_cast<double>(c), static_cast<std::complex<double>>(x)));
+}
+
+inline double hyp2f1(double a, double b, double c, double x) { return cephes::hyp2f1(a, b, c, x); }
+
+inline float hyp2f1(float a, float b, float c, float x) {
+    return hyp2f1(static_cast<double>(a), static_cast<double>(b), static_cast<double>(c), static_cast<double>(x));
+}
+
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/lambertw.h

@@ -0,0 +1,150 @@
+/* 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 special {
+constexpr double EXPN1 = 0.36787944117144232159553; // exp(-1)
+constexpr double OMEGA = 0.56714329040978387299997; // W(1, 0)
+
+namespace detail {
+    SPECFUN_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);
+    }
+
+    SPECFUN_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);
+    }
+
+    SPECFUN_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
+
+SPECFUN_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()};
+}
+
+SPECFUN_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 special

parrot/lib/python3.10/site-packages/scipy/special/special/loggamma.h

@@ -0,0 +1,163 @@
+/* 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 special {
+
+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;
+
+    SPECFUN_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);
+    }
+
+    SPECFUN_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);
+    }
+
+    SPECFUN_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
+
+SPECFUN_HOST_DEVICE inline double loggamma(double x) {
+    if (x < 0.0) {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    return cephes::lgam(x);
+}
+
+SPECFUN_HOST_DEVICE inline float loggamma(float x) { return loggamma(static_cast<double>(x)); }
+
+SPECFUN_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)));
+}
+
+SPECFUN_HOST_DEVICE inline std::complex<float> loggamma(std::complex<float> z) {
+    return static_cast<std::complex<float>>(loggamma(static_cast<std::complex<double>>(z)));
+}
+
+SPECFUN_HOST_DEVICE inline double rgamma(double z) { return cephes::rgamma(z); }
+
+SPECFUN_HOST_DEVICE inline float rgamma(float z) { return rgamma(static_cast<double>(z)); }
+
+SPECFUN_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));
+}
+
+SPECFUN_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 special

parrot/lib/python3.10/site-packages/scipy/special/special/tools.h

@@ -0,0 +1,269 @@
+/* Building blocks for implementing special functions */
+
+#pragma once
+
+#include "config.h"
+#include "error.h"
+
+namespace special {
+namespace detail {
+
+    /* Result type of a "generator", a callable object that produces a value
+     * each time it is called.
+     */
+    template <typename Generator>
+    using generator_result_t = std::decay_t<std::invoke_result_t<Generator>>;
+
+    /* Used to deduce the type of the numerator/denominator of a fraction. */
+    template <typename Pair>
+    struct pair_traits;
+
+    template <typename T>
+    struct pair_traits<std::pair<T, T>> {
+        using value_type = T;
+    };
+
+    template <typename Pair>
+    using pair_value_t = typename pair_traits<Pair>::value_type;
+
+    /* Used to extract the "value type" of a complex type. */
+    template <typename T>
+    struct real_type {
+        using type = T;
+    };
+
+    template <typename T>
+    struct real_type<std::complex<T>> {
+        using type = T;
+    };
+
+    template <typename T>
+    using real_type_t = typename real_type<T>::type;
+
+    // Return NaN, handling both real and complex types.
+    template <typename T>
+    SPECFUN_HOST_DEVICE inline std::enable_if_t<std::is_floating_point_v<T>, T> maybe_complex_NaN() {
+        return std::numeric_limits<T>::quiet_NaN();
+    }
+
+    template <typename T>
+    SPECFUN_HOST_DEVICE inline std::enable_if_t<!std::is_floating_point_v<T>, T> maybe_complex_NaN() {
+        using V = typename T::value_type;
+        return {std::numeric_limits<V>::quiet_NaN(), std::numeric_limits<V>::quiet_NaN()};
+    }
+
+    // Series evaluators.
+    template <typename Generator, typename T = generator_result_t<Generator>>
+    SPECFUN_HOST_DEVICE T series_eval(Generator &g, T init_val, real_type_t<T> tol, std::uint64_t max_terms,
+                                      const char *func_name) {
+        /* Sum an infinite series to a given precision.
+         *
+         * g : a generator of terms for the series.
+         *
+         * init_val : A starting value that terms are added to. This argument determines the
+         *     type of the result.
+         *
+         * tol : relative tolerance for stopping criterion.
+         *
+         * max_terms : The maximum number of terms to add before giving up and declaring
+         *     non-convergence.
+         *
+         * func_name : The name of the function within SciPy where this call to series_eval
+         *     will ultimately be used. This is needed to pass to set_error in case
+         *     of non-convergence.
+         */
+        T result = init_val;
+        T term;
+        for (std::uint64_t i = 0; i < max_terms; ++i) {
+            term = g();
+            result += term;
+            if (std::abs(term) < std::abs(result) * tol) {
+                return result;
+            }
+        }
+        // Exceeded max terms without converging. Return NaN.
+        set_error(func_name, SF_ERROR_NO_RESULT, NULL);
+        return maybe_complex_NaN<T>();
+    }
+
+    template <typename Generator, typename T = generator_result_t<Generator>>
+    SPECFUN_HOST_DEVICE T series_eval_fixed_length(Generator &g, T init_val, std::uint64_t num_terms) {
+        /* Sum a fixed number of terms from a series.
+         *
+         * g : a generator of terms for the series.
+         *
+         * init_val : A starting value that terms are added to. This argument determines the
+         *     type of the result.
+         *
+         * max_terms : The number of terms from the series to sum.
+         *
+         */
+        T result = init_val;
+        for (std::uint64_t i = 0; i < num_terms; ++i) {
+            result += g();
+        }
+        return result;
+    }
+
+    /* Performs one step of Kahan summation. */
+    template <typename T>
+    SPECFUN_HOST_DEVICE void kahan_step(T& sum, T& comp, T x) {
+        T y = x - comp;
+        T t = sum + y;
+        comp = (t - sum) - y;
+        sum = t;
+    }
+
+    /* Evaluates an infinite series using Kahan summation.
+     *
+     * Denote the series by
+     *
+     *   S = a[0] + a[1] + a[2] + ...
+     *
+     * And for n = 0, 1, 2, ..., denote its n-th partial sum by
+     *
+     *   S[n] = a[0] + a[1] + ... + a[n]
+     *
+     * This function computes S[0], S[1], ... until a[n] is sufficiently
+     * small or if the maximum number of terms have been evaluated.
+     *
+     * Parameters
+     * ----------
+     *   g
+     *       Reference to generator that yields the sequence of values a[1],
+     *       a[2], a[3], ...
+     *
+     *   tol
+     *       Relative tolerance for convergence.  Specifically, stop iteration
+     *       as soon as `abs(a[n]) <= tol * abs(S[n])` for some n >= 1.
+     *
+     *   max_terms
+     *       Maximum number of terms after a[0] to evaluate.  It should be set
+     *       large enough such that the convergence criterion is guaranteed
+     *       to have been satisfied within that many terms if there is no
+     *       rounding error.
+     *
+     *   init_val
+     *       a[0].  Default is zero.  The type of this parameter (T) is used
+     *       for intermediary computations as well as the result.
+     *
+     * Return Value
+     * ------------
+     * If the convergence criterion is satisfied by some `n <= max_terms`,
+     * returns `(S[n], n)`.  Otherwise, returns `(S[max_terms], 0)`.
+     */
+    template <typename Generator, typename T = generator_result_t<Generator>>
+    SPECFUN_HOST_DEVICE std::pair<T, std::uint64_t> series_eval_kahan(
+        Generator &&g, real_type_t<T> tol, std::uint64_t max_terms, T init_val = T(0)) {
+
+        T sum = init_val;
+        T comp = 0;
+        for (std::uint64_t i = 0; i < max_terms; ++i) {
+            T term = g();
+            kahan_step(sum, comp, term);
+            if (std::abs(term) <= tol * std::abs(sum)) {
+                return {sum, i + 1};
+            }
+        }
+        return {sum, 0};
+    }
+
+    /* Generator that yields the difference of successive convergents of a
+     * continued fraction.
+     *
+     * Let f[n] denote the n-th convergent of a continued fraction:
+     *
+     *                 a[1]   a[2]       a[n]
+     *   f[n] = b[0] + ------ ------ ... ----
+     *                 b[1] + b[2] +     b[n]
+     *
+     * with f[0] = b[0].  This generator yields the sequence of values
+     * f[1]-f[0], f[2]-f[1], f[3]-f[2], ...
+     *
+     * Constructor Arguments
+     * ---------------------
+     *   cf
+     *       Reference to generator that yields the terms of the continued
+     *       fraction as (numerator, denominator) pairs, starting from
+     *       (a[1], b[1]).
+     *
+     *       `cf` must outlive the ContinuedFractionSeriesGenerator object.
+     *
+     *       The constructed object always eagerly retrieves the next term
+     *       of the continued fraction.  Specifically, (a[1], b[1]) is
+     *       retrieved upon construction, and (a[n], b[n]) is retrieved after
+     *       (n-1) calls of `()`.
+     *
+     * Type Arguments
+     * --------------
+     *   T
+     *       Type in which computations are performed and results are turned.
+     *
+     * Remarks
+     * -------
+     * The series is computed using the recurrence relation described in [1].
+     *
+     * No error checking is performed.  The caller must ensure that all terms
+     * are finite and that intermediary computations do not trigger floating
+     * point exceptions such as overflow.
+     *
+     * The numerical stability of this method depends on the characteristics
+     * of the continued fraction being evaluated.
+     *
+     * Reference
+     * ---------
+     * [1] Gautschi, W. (1967). “Computational Aspects of Three-Term
+     *     Recurrence Relations.” SIAM Review, 9(1):24-82.
+     */
+    template <typename Generator, typename T = pair_value_t<generator_result_t<Generator>>>
+    class ContinuedFractionSeriesGenerator {
+
+    public:
+        explicit ContinuedFractionSeriesGenerator(Generator &cf) : cf_(cf) {
+            init();
+        }
+
+        double operator()() {
+            double v = v_;
+            advance();
+            return v;
+        }
+
+    private:
+        void init() {
+            auto [num, denom] = cf_();
+            T a = num;
+            T b = denom;
+            u_ = T(1);
+            v_ = a / b;
+            b_ = b;
+        }
+
+        void advance() {
+            auto [num, denom] = cf_();
+            T a = num;
+            T b = denom;
+            u_ = T(1) / (T(1) + (a * u_) / (b * b_));
+            v_ *= (u_ - T(1));
+            b_ = b;
+        }
+
+        Generator& cf_; // reference to continued fraction generator
+        T v_;           // v[n] == f[n] - f[n-1], n >= 1
+        T u_;           // u[1] = 1, u[n] = v[n]/v[n-1], n >= 2
+        T b_;           // last denominator, i.e. b[n-1]
+    };
+
+    /* Converts a continued fraction into a series whose terms are the
+     * difference of its successive convergents.
+     *
+     * See ContinuedFractionSeriesGenerator for details.
+     */
+    template <typename Generator, typename T = pair_value_t<generator_result_t<Generator>>>
+    SPECFUN_HOST_DEVICE ContinuedFractionSeriesGenerator<Generator, T>
+    continued_fraction_series(Generator &cf) {
+        return ContinuedFractionSeriesGenerator<Generator, T>(cf);
+    }
+
+} // namespace detail
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/trig.h

@@ -0,0 +1,111 @@
+/* Translated from Cython into C++ by SciPy developers in 2023.
+ *
+ * Original author: Josh Wilson, 2016.
+ */
+
+/* Implement sin(pi*z) and cos(pi*z) for complex z. Since the periods
+ * of these functions are integral (and thus better representable in
+ * floating point), it's possible to compute them with greater accuracy
+ * than sin(z), cos(z).
+ */
+
+#pragma once
+
+#include "cephes/trig.h"
+#include "config.h"
+#include "evalpoly.h"
+
+namespace special {
+
+template <typename T>
+SPECFUN_HOST_DEVICE T sinpi(T x) {
+    return cephes::sinpi(x);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE std::complex<T> sinpi(std::complex<T> z) {
+    T x = z.real();
+    T piy = M_PI * z.imag();
+    T abspiy = std::abs(piy);
+    T sinpix = cephes::sinpi(x);
+    T cospix = cephes::cospi(x);
+
+    if (abspiy < 700) {
+        return {sinpix * std::cosh(piy), cospix * std::sinh(piy)};
+    }
+
+    /* Have to be careful--sinh/cosh could overflow while cos/sin are small.
+     * At this large of values
+     *
+     * cosh(y) ~ exp(y)/2
+     * sinh(y) ~ sgn(y)*exp(y)/2
+     *
+     * so we can compute exp(y/2), scale by the right factor of sin/cos
+     * and then multiply by exp(y/2) to avoid overflow. */
+    T exphpiy = std::exp(abspiy / 2);
+    T coshfac;
+    T sinhfac;
+    if (exphpiy == std::numeric_limits<T>::infinity()) {
+        if (sinpix == 0.0) {
+            // Preserve the sign of zero.
+            coshfac = std::copysign(0.0, sinpix);
+        } else {
+            coshfac = std::copysign(std::numeric_limits<T>::infinity(), sinpix);
+        }
+        if (cospix == 0.0) {
+            // Preserve the sign of zero.
+            sinhfac = std::copysign(0.0, cospix);
+        } else {
+            sinhfac = std::copysign(std::numeric_limits<T>::infinity(), cospix);
+        }
+        return {coshfac, sinhfac};
+    }
+
+    coshfac = 0.5 * sinpix * exphpiy;
+    sinhfac = 0.5 * cospix * exphpiy;
+    return {coshfac * exphpiy, sinhfac * exphpiy};
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE T cospi(T x) {
+    return cephes::cospi(x);
+}
+
+template <typename T>
+SPECFUN_HOST_DEVICE std::complex<T> cospi(std::complex<T> z) {
+    T x = z.real();
+    T piy = M_PI * z.imag();
+    T abspiy = std::abs(piy);
+    T sinpix = cephes::sinpi(x);
+    T cospix = cephes::cospi(x);
+
+    if (abspiy < 700) {
+        return {cospix * std::cosh(piy), -sinpix * std::sinh(piy)};
+    }
+
+    // See csinpi(z) for an idea of what's going on here.
+    T exphpiy = std::exp(abspiy / 2);
+    T coshfac;
+    T sinhfac;
+    if (exphpiy == std::numeric_limits<T>::infinity()) {
+        if (sinpix == 0.0) {
+            // Preserve the sign of zero.
+            coshfac = std::copysign(0.0, cospix);
+        } else {
+            coshfac = std::copysign(std::numeric_limits<T>::infinity(), cospix);
+        }
+        if (cospix == 0.0) {
+            // Preserve the sign of zero.
+            sinhfac = std::copysign(0.0, sinpix);
+        } else {
+            sinhfac = std::copysign(std::numeric_limits<T>::infinity(), sinpix);
+        }
+        return {coshfac, sinhfac};
+    }
+
+    coshfac = 0.5 * cospix * exphpiy;
+    sinhfac = 0.5 * sinpix * exphpiy;
+    return {coshfac * exphpiy, sinhfac * exphpiy};
+}
+
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/wright_bessel.h

@@ -0,0 +1,841 @@
+/* Translated from Cython into C++ by SciPy developers in 2023.
+ * Original header with Copyright information appears below.
+ */
+
+/* Implementation of Wright's generalized Bessel function Phi, see
+ * https://dlmf.nist.gov/10.46.E1
+ *
+ * Copyright: Christian Lorentzen
+ *
+ * Distributed under the same license as SciPy
+ *
+ *
+ * Implementation Overview:
+ *
+ * First, different functions are implemented valid for certain domains of the
+ * three arguments.
+ * Finally they are put together in wright_bessel. See the docstring of
+ * that function for more details.
+ */
+
+#pragma once
+
+#include "cephes/lanczos.h"
+#include "cephes/polevl.h"
+#include "cephes/rgamma.h"
+#include "config.h"
+#include "digamma.h"
+#include "error.h"
+
+namespace special {
+
+namespace detail {
+    // rgamma_zero: smallest value x for which rgamma(x) == 0 as x gets large
+    constexpr double rgamma_zero = 178.47241115886637;
+
+    SPECFUN_HOST_DEVICE inline double exp_rgamma(double x, double y) {
+        /* Compute exp(x) / gamma(y) = exp(x) * rgamma(y).
+         *
+         * This helper function avoids overflow by using the lanczos
+         * approximation of the gamma function.
+         */
+        return std::exp(x + (1 - std::log(y + cephes::lanczos_g - 0.5)) * (y - 0.5)) /
+               cephes::lanczos_sum_expg_scaled(y);
+    }
+
+    SPECFUN_HOST_DEVICE inline double wb_series(double a, double b, double x, unsigned int nstart, unsigned int nstop) {
+        /* 1. Taylor series expansion in x=0 for x <= 1.
+         *
+         * Phi(a, b, x) = sum_k x^k / k! / Gamma(a*k + b)
+         *
+         * Note that every term, and therefore also Phi(a, b, x) is
+         * monotone decreasing with increasing a or b.
+         */
+        double xk_k = std::pow(x, nstart) * cephes::rgamma(nstart + 1); // x^k/k!
+        double res = xk_k * cephes::rgamma(nstart * a + b);
+        // term k=nstart+1, +2, +3, ...
+        if (nstop > nstart) {
+            // series expansion until term k such that a*k+b <= rgamma_zero
+            unsigned int k_max = std::floor((rgamma_zero - b) / a);
+            if (nstop > k_max) {
+                nstop = k_max;
+            }
+            for (unsigned int k = nstart + 1; k < nstop; k++) {
+                xk_k *= x / k;
+                res += xk_k * cephes::rgamma(a * k + b);
+            }
+        }
+        return res;
+    }
+
+    template<bool log_wb>
+    SPECFUN_HOST_DEVICE inline double wb_large_a(double a, double b, double x, int n) {
+        /* 2. Taylor series expansion in x=0, for large a.
+         *
+         * Phi(a, b, x) = sum_k x^k / k! / Gamma(a*k + b)
+         *
+         * Use Stirling's formula to find k=k_max, the maximum term.
+         * Then use n terms of Taylor series around k_max.
+         */
+        int k_max = static_cast<int>(std::pow(std::pow(a, -a) * x, 1.0 / (1 + a)));
+
+        int nstart = k_max - n / 2;
+        if (nstart < 0) {
+            nstart = 0;
+        }
+
+        double res = 0;
+        double lnx = std::log(x);
+        // For numerical stability, we factor out the maximum term exp(..) with k=k_max
+        // but only if it is larger than 0.
+        double max_exponent = std::fmax(0, k_max * lnx - cephes::lgam(k_max + 1) - cephes::lgam(a * k_max + b));
+        for (int k = nstart; k < nstart + n; k++) {
+            res += std::exp(k * lnx - cephes::lgam(k + 1) - cephes::lgam(a * k + b) - max_exponent);
+        }
+
+        if (!log_wb) {
+            res *= std::exp(max_exponent);
+        } else {
+            // logarithm of Wright's function
+            res = max_exponent + std::log(res);
+        }
+        return res;
+    }
+
+    template<bool log_wb>
+    SPECFUN_HOST_DEVICE inline double wb_small_a(double a, double b, double x, int order) {
+        /* 3. Taylor series in a=0 up to order 5, for tiny a and not too large x
+         *
+         * Phi(a, b, x) = exp(x)/Gamma(b)
+                          * (1 - a*x * Psi(b) + a^2/2*x*(1+x) * (Psi(b)^2 - Psi'(b)
+                             + ... )
+                          + O(a^6))
+         *
+         * where Psi is the digamma function.
+         *
+         * Parameter order takes effect only when b > 1e-3 and 2 <= order <= 5,
+         * otherwise it defaults to 2, or if b <= 1e-3, to 5. The lower order is,
+         * the fewer polygamma functions have to be computed.
+         *
+         * Call: python _precompute/wright_bessel.py 1
+         *
+         * For small b, i.e. b <= 1e-3, cancellation of poles of digamma(b)/Gamma(b)
+         * and polygamma needs to be carried out => series expansion in a=0 to order 5
+         * and in b=0 to order 4.
+         * Call: python _precompute/wright_bessel.py 2
+         */
+        double A[6]; // coefficients of a^k  (1, -x * Psi(b), ...)
+        double B[6]; // powers of b^k/k! or terms in polygamma functions
+        constexpr double C[5] = {  // coefficients of a^k1 * b^k2
+            1.0000000000000000,   // C[0]
+            1.1544313298030657,   // C[1]
+            -3.9352684291215233,  // C[2]
+            -1.0080632408182857,  // C[3]
+            19.984633365874979,   // C[4]
+        };
+        double X[6] = {  // polynomials in x;
+            1,  // X[0]
+            x,  // X[1]
+            x * (x + 1),  // X[2]
+            x * (x * (x + 3) + 1),  // X[3]
+            x * (x * (x * (x + 6) + 7) + 1),  // X[4]
+            x * (x * (x * (x * (x + 10) + 25) + 15) + 1),  // X[5]
+        };
+        double res;
+
+        if (b <= 1E-3) {
+            /* Series expansion of both a and b up to order 5:
+             * M_PI = pi
+             * M_EG = Euler Gamma aka Euler Mascheroni constant
+             * M_Z3 = zeta(3)
+             * C[0] = 1
+             * C[1] = 2*M_EG
+             * C[2] = 3*M_EG^2 - M_PI^2/2
+             * C[3] = 4*M_EG^3 - 2*M_EG*M_PI^2 + 8*M_Z3
+             * C[4] = 5*M_EG^4 - 5*M_EG^2*M_PI^2 + 40*M_EG*M_Z3 + M_PI^4/12
+             */
+            B[0] = 1.;
+            for (int k = 1; k < 5; k++) {
+                B[k] = b / k * B[k - 1];
+            }
+            // Note that polevl assumes inverse ordering => A[5] = 0th term
+            A[5] = cephes::rgamma(b);
+            A[4] = X[1]        * (C[0] + C[1] * b + C[2] * B[2] + C[3] * B[3] + C[4] * B[4]);
+            A[3] = X[2] / 2.   * (C[1] + C[2] * b + C[3] * B[2] + C[4] * B[3]);
+            A[2] = X[3] / 6.   * (C[2] + C[3] * b + C[4] * B[2]);
+            A[1] = X[4] / 24.  * (C[3] + C[4] * b);
+            A[0] = X[5] / 120. * C[4];
+            // res = exp(x) * (A[5] + A[4] * a + A[3] * a^2 + A[2] * a^3 + ...)
+            if (!log_wb) {
+                res = exp(x) * cephes::polevl(a, A, 5);
+            } else {
+                // logarithm of Wright's function
+                res = x + std::log(cephes::polevl(a, A, 5));
+            }
+        } else {
+            /* Phi(a, b, x) = exp(x)/gamma(b) * sum(A[i] * X[i] * B[i], i=0..5)
+             * A[n] = a^n/n!
+             * But here, we repurpose A[n] = X[n] * B[n] / n!
+             * Note that polevl assumes inverse ordering => A[order] = 0th term */
+            double dg = digamma(b);
+            // pg1 = polygamma(1, b)
+            double pg1 = cephes::zeta(2, b);
+            if (order <= 2) {
+                res = 1 + a * x * (-dg + 0.5 * a * (1 + x) * (dg * dg - pg1));
+            } else {
+                if (order > 5) {
+                    order = 5;
+                }
+                // pg2 = polygamma(2, b)
+                double pg2 = -2 * cephes::zeta(3, b);
+                B[0] = 1;
+                B[1] = -dg;
+                B[2] = dg * dg - pg1;
+                B[3] = (-dg * dg + 3 * pg1) * dg - pg2;
+                A[order] = 1;
+                A[order - 1] = X[1] * B[1];
+                A[order - 2] = X[2] * B[2] / 2.;
+                A[order - 3] = X[3] * B[3] / 6.;
+                if (order >= 4) {
+                    // double pg3 = polygamma(3, b)
+                    double pg3 = 6 * cephes::zeta(4, b);
+                    B[4] = ((dg * dg - 6 * pg1) * dg + 4 * pg2) * dg + 3 * pg1 * pg1 - pg3;
+                    A[order - 4] = X[4] * B[4] / 24.;
+                    if (order >= 5) {
+                        // pg4 = polygamma(4, b)
+                        double pg4 = -24 * cephes::zeta(5, b);
+                        B[5] =
+                            ((((-dg * dg + 10 * pg1) * dg - 10 * pg2) * dg - 15 * pg1 * pg1 + 5 * pg3) * dg +
+                             10 * pg1 * pg2 - pg4);
+                        A[order - 5] = X[5] * B[5] / 120.;
+                    }
+                }
+                res = cephes::polevl(a, A, order);
+            }
+            // res *= exp(x) * rgamma(b)
+            if (!log_wb) {
+                res *= exp_rgamma(x, b);
+            } else {
+                // logarithm of Wright's function
+                res = x - cephes::lgam(b) + std::log(res);
+            }
+        }
+        return res;
+    }
+
+    template<bool log_wb>
+    SPECFUN_HOST_DEVICE inline double wb_asymptotic(double a, double b, double x) {
+        /* 4. Asymptotic expansion for large x up to order 8
+         *
+         * Phi(a, b, x) ~ Z^(1/2-b) * exp((1+a)/a * Z) * sum_k (-1)^k * C_k / Z^k
+         *
+         * with Z = (a*x)^(1/(1+a)).
+         * Call: python _precompute/wright_bessel.py 3
+         */
+        double A[15];  // powers of a
+        double B[17];  // powers of b
+        double Ap1[9]; // powers of (1+a)
+        double C[9];   // coefficients of asymptotic series a_k
+
+        A[0] = 1.;
+        B[0] = 1.;
+        Ap1[0] = 1.;
+        for (int k = 1; k < 15; k++) {
+            A[k] = A[k - 1] * a;
+        }
+        for (int k = 1; k < 17; k++) {
+            B[k] = B[k - 1] * b;
+        }
+        for (int k = 1; k < 9; k++) {
+            Ap1[k] = Ap1[k - 1] * (1 + a);
+        }
+
+        C[0] = 1. / std::sqrt(2. * M_PI * Ap1[1]);
+
+        C[1] = C[0] / (24 * Ap1[1]);
+        C[1] *= (2 * a + 1) * (2 + a) - 12 * b * (1 + a - b);
+
+        C[2] = C[0] / (1152 * Ap1[2]);
+        C[2] *=
+            (144 * B[4] - 96 * B[3] * (5 * a + 1) + 24 * B[2] * (20 * A[2] + 5 * a - 4) -
+             24 * b * Ap1[1] * (6 * A[2] - 7 * a - 2) + (a + 2) * (2 * a + 1) * (2 * A[2] - 19 * a + 2));
+
+        C[3] = C[0] / (414720 * Ap1[3]);
+        C[3] *=
+            (8640 * B[6] - 8640 * B[5] * (7 * a - 1) + 10800 * B[4] * (14 * A[2] - 7 * a - 2) -
+             1440 * B[3] * (112 * A[3] - 147 * A[2] - 63 * a + 8) +
+             180 * B[2] * (364 * A[4] - 1288 * A[3] - 567 * A[2] + 392 * a + 76) -
+             180 * b * Ap1[1] * (20 * A[4] - 516 * A[3] + 417 * A[2] + 172 * a - 12) -
+             (a + 2) * (2 * a + 1) * (556 * A[4] + 1628 * A[3] - 9093 * A[2] + 1628 * a + 556));
+
+        C[4] = C[0] / (39813120 * Ap1[4]);
+        C[4] *=
+            (103680 * B[8] - 414720 * B[7] * (3 * a - 1) + 725760 * B[6] * a * (8 * a - 7) -
+             48384 * B[5] * (274 * A[3] - 489 * A[2] + 39 * a + 26) +
+             30240 * B[4] * (500 * A[4] - 1740 * A[3] + 495 * A[2] + 340 * a - 12) -
+             2880 * B[3] * (2588 * A[5] - 19780 * A[4] + 14453 * A[3] + 9697 * A[2] - 1892 * a - 404) +
+             48 * B[2] *
+                 (11488 * A[6] - 547836 * A[5] + 1007484 * A[4] + 593353 * A[3] - 411276 * A[2] - 114396 * a + 4288) +
+             48 * b * Ap1[1] *
+                 (7784 * A[6] + 48180 * A[5] - 491202 * A[4] + 336347 * A[3] + 163734 * A[2] - 28908 * a - 5560) -
+             (a + 2) * (2 * a + 1) *
+                 (4568 * A[6] - 226668 * A[5] - 465702 * A[4] + 2013479 * A[3] - 465702 * A[2] - 226668 * a + 4568));
+
+        C[5] = C[0] / (6688604160. * Ap1[5]);
+        C[5] *=
+            (1741824 * B[10] - 2903040 * B[9] * (11 * a - 5) + 2177280 * B[8] * (110 * A[2] - 121 * a + 14) -
+             580608 * B[7] * (1628 * A[3] - 3333 * A[2] + 1023 * a + 52) +
+             169344 * B[6] * (12364 * A[4] - 43648 * A[3] + 26763 * A[2] + 1232 * a - 788) -
+             24192 * B[5] * (104852 * A[5] - 646624 * A[4] + 721391 * A[3] - 16841 * A[2] - 74096 * a + 148) +
+             2016 * B[4] *
+                 (710248 * A[6] - 8878716 * A[5] + 17928834 * A[4] - 3333407 * A[3] - 4339566 * A[2] + 287364 * a +
+                  89128) -
+             1344 * B[3] *
+                 (87824 * A[7] - 7150220 * A[6] + 29202756 * A[5] - 15113527 * A[4] - 14223011 * A[3] + 3462492 * A[2] +
+                  1137092 * a - 18896) -
+             84 * B[2] *
+                 (1690480 * A[8] + 14139136 * A[7] - 232575464 * A[6] + 296712592 * A[5] + 215856619 * A[4] -
+                  152181392 * A[3] - 47718440 * A[2] + 5813632 * a + 943216) +
+             84 * b * Ap1[1] *
+                 (82224 * A[8] - 5628896 * A[7] - 26466520 * A[6] + 168779208 * A[5] - 104808005 * A[4] -
+                  56259736 * A[3] + 15879912 * A[2] + 4020640 * a - 63952) +
+             (a + 2) * (2 * a + 1) *
+                 (2622064 * A[8] + 12598624 * A[7] - 167685080 * A[6] - 302008904 * A[5] + 1115235367. * A[4] -
+                  302008904 * A[3] - 167685080 * A[2] + 12598624 * a + 2622064));
+
+        C[6] = C[0] / (4815794995200. * Ap1[6]);
+        C[6] *=
+            (104509440 * B[12] - 209018880 * B[11] * (13 * a - 7) + 574801920 * B[10] * (52 * A[2] - 65 * a + 12) -
+             63866880 * B[9] * (2834 * A[3] - 6279 * A[2] + 2769 * a - 134) +
+             23950080 * B[8] * (27404 * A[4] - 98228 * A[3] + 78663 * A[2] - 10868 * a - 1012) -
+             13685760 * B[7] * (105612 * A[5] - 599196 * A[4] + 791843 * A[3] - 224913 * A[2] - 27612 * a + 4540) +
+             2661120 * B[6] *
+                 (693680 * A[6] - 6473532 * A[5] + 13736424 * A[4] - 7047469 * A[3] - 723840 * A[2] + 471588 * a + 7376
+                 ) -
+             2661120 * B[5] *
+                 (432536 * A[7] - 7850804 * A[6] + 27531114 * A[5] - 24234457 * A[4] - 703001 * A[3] + 3633474 * A[2] -
+                  36244 * a - 45128) +
+             166320 * B[4] *
+                 (548912 * A[8] - 75660832 * A[7] + 502902712 * A[6] - 764807992 * A[5] + 91248287 * A[4] +
+                  217811464 * A[3] - 20365384 * A[2] - 9776416 * a + 37936) +
+             10080 * B[3] *
+                 (18759728 * A[9] + 165932208 * A[8] - 4710418440. * A[7] + 13686052536. * A[6] - 5456818809. * A[5] -
+                  6834514245. * A[4] + 1919299512. * A[3] + 752176152 * A[2] - 45661200 * a - 8616848) -
+             360 * B[2] *
+                 (32743360 * A[10] - 3381871792. * A[9] - 21488827776. * A[8] + 200389923864. * A[7] -
+                  198708005340. * A[6] - 171633799779. * A[5] + 123124874028. * A[4] + 40072774872. * A[3] -
+                  9137993280. * A[2] - 1895843248. * a + 18929728) -
+             360 * b * Ap1[1] *
+                 (57685408 * A[10] + 406929456 * A[9] - 6125375760. * A[8] - 27094918920. * A[7] +
+                  128752249410. * A[6] - 74866710561. * A[5] - 42917416470. * A[4] + 16256951352. * A[3] +
+                  4375268400. * A[2] - 316500688 * a - 47197152) +
+             (a + 2) * (2 * a + 1) *
+                 (167898208 * A[10] - 22774946512. * A[9] - 88280004528. * A[8] + 611863976472. * A[7] +
+                  1041430242126. * A[6] - 3446851131657. * A[5] + 1041430242126. * A[4] + 611863976472. * A[3] -
+                  88280004528. * A[2] - 22774946512. * a + 167898208));
+
+        C[7] = C[0] / (115579079884800. * Ap1[7]);
+        C[7] *=
+            (179159040 * B[14] - 1254113280. * B[13] * (5 * a - 3) + 1358622720. * B[12] * (70 * A[2] - 95 * a + 22) -
+             905748480 * B[11] * (904 * A[3] - 2109 * A[2] + 1119 * a - 112) +
+             1245404160. * B[10] * (3532 * A[4] - 12824 * A[3] + 11829 * A[2] - 2824 * a + 44) -
+             59304960 * B[9] * (256820 * A[5] - 1397680 * A[4] + 2025545 * A[3] - 869495 * A[2] + 52000 * a + 8788) +
+             14826240 * B[8] *
+                 (2274536 * A[6] - 18601572 * A[5] + 40698318 * A[4] - 28230079 * A[3] + 3916398 * A[2] + 832668 * a -
+                  65176) -
+             59304960 * B[7] *
+                 (760224 * A[7] - 9849164 * A[6] + 32495784 * A[5] - 34813869 * A[4] + 9175207 * A[3] + 1898688 * A[2] -
+                  469788 * a - 13184) +
+             25945920 * B[6] *
+                 (1167504 * A[8] - 28779840 * A[7] + 149752856 * A[6] - 246026112 * A[5] + 111944073 * A[4] +
+                  18341600 * A[3] - 12131496 * A[2] - 274368 * a + 102800) -
+             157248 * B[5] *
+                 (12341872 * A[9] - 3122991216. * A[8] + 29900054232. * A[7] - 78024816720. * A[6] +
+                  58914656739. * A[5] + 4637150811. * A[4] - 11523402480. * A[3] + 236218968 * A[2] + 337923216 * a +
+                  1592048) -
+             28080 * B[4] *
+                 (265154912 * A[10] + 2276098704. * A[9] - 105569461008. * A[8] + 496560666360. * A[7] -
+                  627891462858. * A[6] + 41935358025. * A[5] + 203913875814. * A[4] - 23984801544. * A[3] -
+                  13869306000. * A[2] + 372786832 * a + 103532640) +
+             1440 * B[3] *
+                 (310292864 * A[11] - 55169117872. * A[10] - 358957020112. * A[9] + 5714152556088. * A[8] -
+                  13241597459352. * A[7] + 4220720097141. * A[6] + 6845418090249. * A[5] - 2129559215808. * A[4] -
+                  909225098472. * A[3] + 107518582576. * A[2] + 25619444368. * a - 113832704) +
+             12 * B[2] *
+                 (135319651136. * A[12] + 1119107842176. * A[11] - 22193518174320. * A[10] - 133421793595520. * A[9] +
+                  860103051087996. * A[8] - 703353374803080. * A[7] - 704240127687381. * A[6] +
+                  513111704637960. * A[5] + 166909061348316. * A[4] - 57671564069120. * A[3] - 12453426246000. * A[2] +
+                  695901207936. * a + 93786157376.) -
+             12 * b * Ap1[1] *
+                 (4365353408. * A[12] - 720248637504. * A[11] - 4222331152560. * A[10] + 29413934270560. * A[9] +
+                  132123980710980. * A[8] - 511247376962820. * A[7] + 283403639131779. * A[6] +
+                  170415792320940. * A[5] - 79274388426588. * A[4] - 21009953050400. * A[3] + 3284035340880. * A[2] +
+                  589294339776. * a - 3693760576.) -
+             (a + 2) * (2 * a + 1) *
+                 (34221025984. * A[12] + 226022948160. * A[11] - 5067505612464. * A[10] - 18868361443936. * A[9] +
+                  86215425028308. * A[8] + 143500920544692. * A[7] - 437682618704613. * A[6] + 143500920544692. * A[5] +
+                  86215425028308. * A[4] - 18868361443936. * A[3] - 5067505612464. * A[2] + 226022948160. * a +
+                  34221025984.));
+
+        C[8] = C[0] / (22191183337881600. * Ap1[8]);
+        C[8] *=
+            (2149908480. * B[16] - 5733089280. * B[15] * (17 * a - 11) +
+             7166361600. * B[14] * (272 * A[2] - 391 * a + 104) -
+             3344302080. * B[13] * (6766 * A[3] - 16371 * A[2] + 9741 * a - 1306) +
+             1811496960. * B[12] * (93092 * A[4] - 341564 * A[3] + 344199 * A[2] - 104924 * a + 6308) -
+             517570560 * B[11] *
+                 (1626220 * A[5] - 8641508 * A[4] + 13274773 * A[3] - 6952303 * A[2] + 1007420 * a + 5564) +
+             284663808 * B[10] *
+                 (9979136 * A[6] - 75766892 * A[5] + 169256148 * A[4] - 136824959 * A[3] + 35714348 * A[2] -
+                  463692 * a - 293664) -
+             1423319040. * B[9] *
+                 (4466648 * A[7] - 49231116 * A[6] + 157507414 * A[5] - 187114257 * A[4] + 78372295 * A[3] -
+                  4470082 * A[2] - 1913996 * a + 82424) +
+             266872320 * B[8] *
+                 (33133136 * A[8] - 564264544 * A[7] + 2618606424. * A[6] - 4491310104. * A[5] + 2853943765. * A[4] -
+                  374694552 * A[3] - 135365288 * A[2] + 17623968 * a + 696912) -
+             2156544 * B[7] *
+                 (2914256144. * A[9] - 93491712432. * A[8] + 664876176984. * A[7] - 1661362937880. * A[6] +
+                  1563719627313. * A[5] - 382840842843. * A[4] - 115399415640. * A[3] + 34565562936. * A[2] +
+                  1609337232. * a - 217321904) +
+             179712 * B[6] *
+                 (1266018560. * A[10] - 789261834512. * A[9] + 10186841596896. * A[8] - 38877799073352. * A[7] +
+                  54334425968952. * A[6] - 22529574889533. * A[5] - 5132942328000. * A[4] + 3438377465592. * A[3] +
+                  84287641248. * A[2] - 72493479440. * a - 807415936) +
+             13824 * B[5] *
+                 (156356794976. * A[11] + 1180898077328. * A[10] - 90615270907936. * A[9] + 609258947056248. * A[8] -
+                  1312655191366722. * A[7] + 885900509321745. * A[6] + 112162151855265. * A[5] -
+                  212803071513258. * A[4] + 6805217831352. * A[3] + 10051742651296. * A[2] - 55035924848. * a -
+                  52946379296.) -
+             576 * B[4] *
+                 (143943926464. * A[12] - 60115486481856. * A[11] - 376366989757200. * A[10] +
+                  9534223075576160. * A[9] - 35603777465262396. * A[8] + 39375990156664980. * A[7] -
+                  868175004137259. * A[6] - 14279180718355020. * A[5] + 1985747535239364. * A[4] +
+                  1264001337603680. * A[3] - 75972792514320. * A[2] - 23855850572736. * a - 4996648256.) -
+             384 * B[3] *
+                 (2038525473856. * A[13] + 16057322146112. * A[12] - 502133360559024. * A[11] -
+                  2985686417468080. * A[10] + 32418922182093292. * A[9] - 63665380623022452. * A[8] +
+                  16481208821092575. * A[7] + 34161547357596099. * A[6] - 11490298497454932. * A[5] -
+                  5117272758337156. * A[4] + 933703210750480. * A[3] + 234855186762000. * A[2] - 7860524600000. * a -
+                  1226607567040.) +
+             96 * B[2] *
+                 (324439754752. * A[14] - 77231415197120. * A[13] - 539102931841856. * A[12] +
+                  4618258299956336. * A[11] + 28588485529469792. * A[10] - 141383982651179428. * A[9] +
+                  98783147840417772. * A[8] + 112831723492305801. * A[7] - 83329761150975036. * A[6] -
+                  26553582937192900. * A[5] + 12469117738765952. * A[4] + 2587165396642160. * A[3] -
+                  340406368038080. * A[2] - 53659641606080. * a + 219671272960.) +
+             96 * b * Ap1[1] *
+                 (1026630779520. * A[14] + 8781958472768. * A[13] - 210659786204384. * A[12] -
+                  1222283505284208. * A[11] + 5064251967491416. * A[10] + 24013052207628140. * A[9] -
+                  79710880160087370. * A[8] + 42596558293213227. * A[7] + 26570293386695790. * A[6] -
+                  14407831324576884. * A[5] - 3617322833922440. * A[4] + 950664948554384. * A[3] +
+                  172358006894496. * A[2] - 7430887938496. * a - 889746675584.) -
+             (a + 2) * (2 * a + 1) *
+                 (573840801152. * A[14] - 156998277198784. * A[13] - 898376974770592. * A[12] +
+                  8622589006459984. * A[11] + 32874204024803560. * A[10] - 111492707520083828. * A[9] -
+                  184768503480287646. * A[8] + 528612016938984183. * A[7] - 184768503480287646. * A[6] -
+                  111492707520083828. * A[5] + 32874204024803560. * A[4] + 8622589006459984. * A[3] -
+                  898376974770592. * A[2] - 156998277198784. * a + 573840801152.));
+
+        double Z = std::pow(a * x, 1 / Ap1[1]);
+        double Zp = 1.;
+        double res = C[0];
+        for (int k = 1; k < 9; k++) {
+            Zp /= Z;
+            res += (k % 2 == 0 ? 1 : -1) * C[k] * Zp;
+        }
+        if (!log_wb) {
+            res *= std::pow(Z, 0.5 - b) * std::exp(Ap1[1] / a * Z);
+        } else {
+            // logarithm of Wright's function
+            res = std::log(Z) * (0.5 - b) + Ap1[1] / a * Z + std::log(res);
+        }
+        return res;
+    }
+
+    SPECFUN_HOST_DEVICE inline double wb_Kmod(double exp_term, double eps, double a, double b, double x, double r) {
+        /* Compute integrand Kmod(eps, a, b, x, r) for Gauss-Laguerre quadrature.
+         *
+         * K(a, b, x, r+eps) = exp(-r-eps) * Kmod(eps, a, b, x, r)
+         * 
+         * Kmod(eps, a, b, x, r) = exp(x * (r+eps)^(-a) * cos(pi*a)) * (r+eps)^(-b)
+         *                       * sin(x * (r+eps)^(-a) * sin(pi*a) + pi * b)
+         * 
+         * Note that we additionally factor out exp(exp_term) which helps with large
+         * terms in the exponent of exp(...)
+         */
+        double x_r_a = x * std::pow(r + eps, -a);
+        return std::exp(x_r_a * cephes::cospi(a) + exp_term) * std::pow(r + eps, -b) *
+               std::sin(x_r_a * cephes::sinpi(a) + M_PI * b);
+    }
+
+    SPECFUN_HOST_DEVICE inline double wb_P(double exp_term, double eps, double a, double b, double x, double phi) {
+        /* Compute integrand P for Gauss-Legendre quadrature.
+         *
+         * P(eps, a, b, x, phi) = exp(eps * cos(phi) + x * eps^(-a) * cos(a*phi))
+         *                      * cos(eps * sin(phi) - x * eps^(-a) * sin(a*phi)
+         *                            + (1-b)*phi)
+         * 
+         * Note that we additionally factor out exp(exp_term) which helps with large
+         * terms in the exponent of exp(...)
+         */
+        double x_eps_a = x * std::pow(eps, -a);
+        return std::exp(eps * std::cos(phi) + x_eps_a * std::cos(a * phi) + exp_term) *
+               std::cos(eps * std::sin(phi) - x_eps_a * std::sin(a * phi) + (1 - b) * phi);
+    }
+
+    /* roots of laguerre polynomial of order 50
+     * scipy.special.roots_laguerre(50)[0] or
+     * sympy.integrals.quadrature.import gauss_laguerre(50, 16)[0] */
+    constexpr double wb_x_laguerre[] = {
+        0.02863051833937908, 0.1508829356769337, 0.3709487815348964, 0.6890906998810479, 1.105625023539913,
+        1.620961751102501,   2.23561037591518,   2.950183366641835,  3.765399774405782,  4.682089387559285,
+        5.70119757478489,    6.823790909794551,  8.051063669390792,  9.384345308258407,  10.82510903154915,
+        12.37498160875746,   14.03575459982991,  15.80939719784467,  17.69807093335025,  19.70414653546156,
+        21.83022330657825,   24.0791514444115,   26.45405784125298,  28.95837601193738,  31.59588095662286,
+        34.37072996309045,   37.28751061055049,  40.35129757358607,  43.56772026999502,  46.94304399160304,
+        50.48426796312992,   54.19924488016862,  58.09682801724853,  62.18705417568891,  66.48137387844482,
+        70.99294482661949,   75.73701154772731,  80.73140480247769,  85.99721113646323,  91.55969041253388,
+        97.44956561485056,   103.7048912366923,  110.3738588076403,  117.5191982031112,  125.2254701334734,
+        133.6120279227287,   142.8583254892541,  153.2603719726036,  165.3856433166825,  180.6983437092145
+    };
+    /* weights for laguerre polynomial of order 50
+     * sympy.integrals.quadrature.import gauss_laguerre(50, 16)[1] */
+    constexpr double wb_w_laguerre[] = {
+        0.07140472613518988,   0.1471486069645884,    0.1856716275748313,    0.1843853825273539,
+        0.1542011686063556,    0.1116853699022688,    0.07105288549019586,   0.04002027691150833,
+        0.02005062308007171,   0.008960851203646281,  0.00357811241531566,   0.00127761715678905,
+        0.0004080302449837189, 0.0001165288322309724, 2.974170493694165e-5,  6.777842526542028e-6,
+        1.37747950317136e-6,   2.492886181720092e-7,  4.010354350427827e-8,  5.723331748141425e-9,
+        7.229434249182665e-10, 8.061710142281779e-11, 7.913393099943723e-12, 6.81573661767678e-13,
+        5.13242671658949e-14,  3.365624762437814e-15, 1.913476326965035e-16, 9.385589781827253e-18,
+        3.950069964503411e-19, 1.417749517827512e-20, 4.309970276292175e-22, 1.101257519845548e-23,
+        2.344617755608987e-25, 4.11854415463823e-27,  5.902246763596448e-29, 6.812008916553065e-31,
+        6.237449498812102e-33, 4.452440579683377e-35, 2.426862352250487e-37, 9.852971481049686e-40,
+        2.891078872318428e-42, 5.906162708112361e-45, 8.01287459750397e-48,  6.789575424396417e-51,
+        3.308173010849252e-54, 8.250964876440456e-58, 8.848728128298018e-62, 3.064894889844417e-66,
+        1.988708229330752e-71, 6.049567152238783e-78
+    };
+    /* roots of legendre polynomial of order 50
+     * sympy.integrals.quadrature.import gauss_legendre(50, 16)[0] */
+    constexpr double wb_x_legendre[] = {
+        -0.998866404420071,  -0.9940319694320907, -0.9853540840480059, -0.9728643851066921,  -0.9566109552428079,
+        -0.9366566189448779, -0.9130785566557919, -0.885967979523613,  -0.8554297694299461,  -0.8215820708593359,
+        -0.7845558329003993, -0.7444943022260685, -0.7015524687068223, -0.6558964656854394,  -0.6077029271849502,
+        -0.5571583045146501, -0.5044581449074642, -0.4498063349740388, -0.3934143118975651,  -0.3355002454194374,
+        -0.276288193779532,  -0.2160072368760418, -0.1548905899981459, -0.09317470156008614, -0.03109833832718888,
+        0.03109833832718888, 0.09317470156008614, 0.1548905899981459,  0.2160072368760418,   0.276288193779532,
+        0.3355002454194374,  0.3934143118975651,  0.4498063349740388,  0.5044581449074642,   0.5571583045146501,
+        0.6077029271849502,  0.6558964656854394,  0.7015524687068223,  0.7444943022260685,   0.7845558329003993,
+        0.8215820708593359,  0.8554297694299461,  0.885967979523613,   0.9130785566557919,   0.9366566189448779,
+        0.9566109552428079,  0.9728643851066921,  0.9853540840480059,  0.9940319694320907,   0.998866404420071
+    };
+    /* weights for legendre polynomial of order 50
+     * sympy.integrals.quadrature.import gauss_legendre(50, 16)[1] */
+    constexpr double wb_w_legendre[] = {
+        0.002908622553155141, 0.006759799195745401, 0.01059054838365097, 0.01438082276148557,  0.01811556071348939,
+        0.02178024317012479,  0.02536067357001239,  0.0288429935805352,  0.03221372822357802,  0.03545983561514615,
+        0.03856875661258768,  0.0415284630901477,   0.04432750433880328, 0.04695505130394843,  0.04940093844946632,
+        0.05165570306958114,  0.05371062188899625,  0.05555774480621252, 0.05718992564772838,  0.05860084981322245,
+        0.05978505870426546,  0.06073797084177022,  0.06145589959031666, 0.06193606742068324,  0.06217661665534726,
+        0.06217661665534726,  0.06193606742068324,  0.06145589959031666, 0.06073797084177022,  0.05978505870426546,
+        0.05860084981322245,  0.05718992564772838,  0.05555774480621252, 0.05371062188899625,  0.05165570306958114,
+        0.04940093844946632,  0.04695505130394843,  0.04432750433880328, 0.0415284630901477,   0.03856875661258768,
+        0.03545983561514615,  0.03221372822357802,  0.0288429935805352,  0.02536067357001239,  0.02178024317012479,
+        0.01811556071348939,  0.01438082276148557,  0.01059054838365097, 0.006759799195745401, 0.002908622553155141
+    };
+    /* Fitted parameters for optimal choice of eps
+     * Call: python _precompute/wright_bessel.py 4 */
+    constexpr double wb_A[] = {0.41037, 0.30833, 6.9952, 18.382, -2.8566, 2.1122};
+
+    template<bool log_wb>
+    SPECFUN_HOST_DEVICE inline double wright_bessel_integral(double a, double b, double x) {
+        /* 5. Integral representation
+         *
+         * K(a, b, x, r) = exp(-r + x * r^(-a) * cos(pi*a)) * r^(-b)
+         *               * sin(x * r^(-a) * sin(pi*a) + pi * b)
+         * P(eps, a, b, x, phi) = exp(eps * cos(phi) + x * eps^(-a) * cos(a*phi))
+         *                      * cos(eps * sin(phi) - x * eps^(-a) * sin(a*phi)
+         *                        + (1-b)*phi)
+         *
+         * Phi(a, b, x) = 1/pi * int_eps^inf K(a, b, x, r) * dr
+         *              + eps^(1-b)/pi * int_0^pi P(eps, a, b, x, phi) * dphi
+         *
+         * for any eps > 0.
+         *
+         * Note that P has a misprint in Luchko (2008) Eq. 9, the cos(phi(beta-1)) at
+         * the end of the first line should be removed and the −sin(phi(beta−1)) at
+         * the end of the second line should read +(1-b)*phi.
+         * This integral representation introduced the free parameter eps (from the
+         * radius of complex contour integration). We try to choose eps such that
+         * the integrand behaves smoothly. Note that this is quite diffrent from how
+         * Luchko (2008) deals with eps: he is either looking for the limit eps -> 0
+         * or he sets (silently) eps=1. But having the freedom to set eps is much more
+         * powerful for numerical evaluation.
+         *
+         * As K has a leading exp(-r), we factor this out and apply Gauss-Laguerre
+         * quadrature rule:
+         *
+         * int_0^inf K(a, b, x, r+eps) dr = exp(-eps) int_0^inf exp(-r) Kmod(.., r) dr
+         *
+         * Note the shift r -> r+eps to have integation from 0 to infinity.
+         * The integral over P is done via a Gauss-Legendre quadrature rule.
+         *
+         * Note: Hardest argument range is large z, large b and small eps.
+         */
+
+        /* We use the free choice of eps to make the integral better behaved.
+         * 1. Concern is oscillatory behaviour of P. Therefore, we'd like to
+         *    make the change in the argument of cosine small, i.e. make arc length
+         *    int_0^phi sqrt(1 + f'(phi)^2) dphi small, with
+         *    f(phi) = eps * sin(phi) - x * eps^(-a) * sin(a*phi) + (1-b)*phi
+         *    Proxy, make |f'(phi)| small.
+         * 2. Concern is int_0 K ~ int_0 (r+eps)^(-b) .. dr
+         *    This is difficult as r -> 0  for large b. It behaves better for larger
+         *    values of eps.
+         */
+
+        // Minimize oscillatory behavoir of P
+        double eps =
+            (wb_A[0] * b * std::exp(-0.5 * a) +
+             std::exp(
+                 wb_A[1] + 1 / (1 + a) * std::log(x) - wb_A[2] * std::exp(-wb_A[3] * a) +
+                 wb_A[4] / (1 + std::exp(wb_A[5] * a))
+             ));
+
+        if (a >= 4 && x >= 100) {
+            eps += 1; // This part is hard to fit
+        }
+
+        // Large b
+        if (b >= 8) {
+            /* Make P small compared to K by setting eps large enough.
+             * int K ~ exp(-eps) and int P ~ eps^(1-b) */
+            eps = std::fmax(eps, std::pow(b, -b / (1. - b)) + 0.1 * b);
+        }
+
+        // safeguard, higher better for larger a, lower better for tiny a.
+        eps = std::fmin(eps, 150.);
+        eps = std::fmax(eps, 3.); // 3 seems to be a pretty good choice in general.
+
+        // We factor out exp(-exp_term) from wb_Kmod and wb_P to avoid overflow of
+        // exp(..).
+        double exp_term = 0;
+        // From the exponent of K:
+        double r = wb_x_laguerre[50-1];  // largest value of x used in wb_Kmod
+        double x_r_a = x * std::pow(r + eps, -a);
+        exp_term = std::fmax(exp_term, x_r_a * cephes::cospi(a));
+        // From the exponent of P:
+        double x_eps_a = x * std::pow(eps, -a);
+        // phi = 0  =>  cos(phi) = cos(a * phi) = 1
+        exp_term = std::fmax(exp_term, eps + x_eps_a);
+        // phi = pi  => cos(phi) = -1
+        exp_term = std::fmax(exp_term, -eps + x_eps_a * cephes::cospi(a));
+
+        double res1 = 0;
+        double res2 = 0;
+
+        double y;
+        for (int k = 0; k < 50; k++) {
+            res1 += wb_w_laguerre[k] * wb_Kmod(-exp_term, eps, a, b, x, wb_x_laguerre[k]);
+            // y = (b-a)*(x+1)/2.0 + a  for integration from a=0 to b=pi
+            y = M_PI * (wb_x_legendre[k] + 1) / 2.0;
+            res2 += wb_w_legendre[k] * wb_P(-exp_term, eps, a, b, x, y);
+        }
+        res1 *= std::exp(-eps);
+        // (b-a)/2.0 * np.sum(w*func(y, *args), axis=-1)
+        res2 *= M_PI / 2.0;
+        res2 *= std::pow(eps, 1 - b);
+
+        if (!log_wb) {
+            // Remember the factored out exp_term from wb_Kmod and wb_P
+            return std::exp(exp_term) / M_PI * (res1 + res2);
+        } else {
+            // logarithm of Wright's function
+            return exp_term + std::log((res1 + res2) / M_PI);
+        }
+    }
+} // namespace detail
+
+template<bool log_wb>
+SPECFUN_HOST_DEVICE inline double wright_bessel_t(double a, double b, double x) {
+    /* Compute Wright's generalized Bessel function for scalar arguments.
+     *
+     * According to [1], it is an entire function defined as
+     *
+     * .. math:: \Phi(a, b; x) = \sum_{k=0}^\infty \frac{x^k}{k! \Gamma(a k + b)}
+     *
+     * So far, only non-negative values of rho=a, beta=b and z=x are implemented.
+     * There are 5 different approaches depending on the ranges of the arguments:
+     *
+     * 1. Taylor series expansion in x=0 [1], for x <= 1.
+     *    Involves gamma funtions in each term.
+     * 2. Taylor series expansion in x=0 [2], for large a.
+     * 3. Taylor series in a=0, for tiny a and not too large x.
+     * 4. Asymptotic expansion for large x [3, 4].
+     *    Suitable for large x while still small a and b.
+     * 5. Integral representation [5], in principle for all arguments.
+     *
+     * References
+     * ----------
+     * [1] https://dlmf.nist.gov/10.46.E1
+     * [2] P. K. Dunn, G. K. Smyth (2005), Series evaluation of Tweedie exponential
+     *     dispersion model densities. Statistics and Computing 15 (2005): 267-280.
+     * [3] E. M. Wright (1935), The asymptotic expansion of the generalized Bessel
+     *     function. Proc. London Math. Soc. (2) 38, pp. 257-270.
+     *     https://doi.org/10.1112/plms/s2-38.1.257
+     * [4] R. B. Paris (2017), The asymptotics of the generalised Bessel function,
+     *     Mathematica Aeterna, Vol. 7, 2017, no. 4, 381 - 406,
+     *     https://arxiv.org/abs/1711.03006
+     * [5] Y. F. Luchko (2008), Algorithms for Evaluation of the Wright Function for
+     *     the Real Arguments' Values, Fractional Calculus and Applied Analysis 11(1)
+     *     http://sci-gems.math.bas.bg/jspui/bitstream/10525/1298/1/fcaa-vol11-num1-2008-57p-75p.pdf
+     */
+    if (std::isnan(a) || std::isnan(b) || std::isnan(x)) {
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    if (a < 0 || b < 0 || x < 0) {
+        set_error("wright_bessel", SF_ERROR_DOMAIN, NULL);
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    if (std::isinf(x)) {
+        if (std::isinf(a) || std::isinf(b)) {
+            return std::numeric_limits<double>::quiet_NaN();
+        }
+        return std::numeric_limits<double>::infinity();
+    }
+    if (std::isinf(a) || std::isinf(b)) {
+        return std::numeric_limits<double>::quiet_NaN(); // or 0
+    }
+    if (a >= detail::rgamma_zero || b >= detail::rgamma_zero) {
+        set_error("wright_bessel", SF_ERROR_OVERFLOW, NULL);
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    if (x == 0) {
+        // return rgamma(b)
+        if (!log_wb) {
+            return cephes::rgamma(b);
+        } else {
+            // logarithm of Wright's function
+            return -cephes::lgam(b);
+        }
+    }
+    if (a == 0) {
+        // return exp(x) * rgamma(b)
+        if (!log_wb) {
+            return detail::exp_rgamma(x, b);
+        } else {
+            // logarithm of Wright's function
+            return x - cephes::lgam(b);
+        }
+    }
+
+    constexpr double exp_inf = 709.78271289338403;
+    int order;
+    if ((a <= 1e-3 && b <= 50 && x <= 9) || (a <= 1e-4 && b <= 70 && x <= 100) ||
+        (a <= 1e-5 && b <= 170 && (x < exp_inf || (log_wb && x <= 1e3)))) {
+        /* Taylor Series expansion in a=0 to order=order => precision <= 1e-11
+         * If beta is also small => precision <= 1e-11.
+         * max order = 5 */
+        if (a <= 1e-5) {
+            if (x <= 1) {
+                order = 2;
+            } else if (x <= 10) {
+                order = 3;
+            } else if (x <= 100) {
+                order = 4;
+            } else { // x < exp_inf
+                order = 5;
+            }
+        } else if (a <= 1e-4) {
+            if (x <= 1e-2) {
+                order = 2;
+            } else if (x <= 1) {
+                order = 3;
+            } else if (x <= 10) {
+                order = 4;
+            } else { // x <= 100
+                order = 5;
+            }
+        } else { // a <= 1e-3
+            if (x <= 1e-5) {
+                order = 2;
+            } else if (x <= 1e-1) {
+                order = 3;
+            } else if (x <= 1) {
+                order = 4;
+            } else { // x <= 9
+                order = 5;
+            }
+        }
+
+        return detail::wb_small_a<log_wb>(a, b, x, order);
+    }
+
+    if (x <= 1) {
+        // 18 term Taylor Series => error mostly smaller 5e-14
+        double res = detail::wb_series(a, b, x, 0, 18);
+        if (log_wb) res = std::log(res);
+        return res;
+    }
+    if (x <= 2) {
+        // 20 term Taylor Series => error mostly smaller 1e-12 to 1e-13
+        return detail::wb_series(a, b, x, 0, 20);
+    }
+    if (a >= 5) {
+        /* Taylor series around the approximate maximum term.
+         * Set number of terms=order. */
+        if (a >= 10) {
+            if (x <= 1e11) {
+                order = 6;
+            } else {
+                order = static_cast<int>(std::fmin(std::log10(x) - 5 + b / 10, 30));
+            }
+        } else {
+            if (x <= 1e4) {
+                order = 6;
+            } else if (x <= 1e8) {
+                order = static_cast<int>(2 * std::log10(x));
+            } else if (x <= 1e10) {
+                order = static_cast<int>(4 * std::log10(x) - 16);
+            } else {
+                order = static_cast<int>(std::fmin(6 * std::log10(x) - 36, 100));
+            }
+        }
+        return detail::wb_large_a<log_wb>(a, b, x, order);
+    }
+    if (std::pow(a * x, 1 / (1. + a)) >= 14 + b * b / (2 * (1 + a))) {
+        /* Asymptotic expansion in Z = (a*x)^(1/(1+a)) up to 8th term 1/Z^8.
+         * For 1/Z^k, the highest term in b is b^(2*k) * a0 / (2^k k! (1+a)^k).
+         * As a0 is a common factor to all orders, this explains a bit the
+         * domain of good convergence set above.
+         * => precision ~ 1e-11 but can go down to ~1e-8 or 1e-7
+         * Note: We ensured a <= 5 as this is a bad approximation for large a. */
+        return detail::wb_asymptotic<log_wb>(a, b, x);
+    }
+    if (0.5 <= a && a <= 1.8 && 100 <= b && 1e5 <= x) {
+        // This is a very hard domain. This condition is placed after wb_asymptotic.
+        // TODO: Explore ways to cover this domain.
+        return std::numeric_limits<double>::quiet_NaN();
+    }
+    return detail::wright_bessel_integral<log_wb>(a, b, x);
+}
+
+
+SPECFUN_HOST_DEVICE inline double wright_bessel(double a, double b, double x) {
+    return wright_bessel_t<false>(a, b, x);
+}
+
+SPECFUN_HOST_DEVICE inline float wright_bessel(float a, float b, float x) {
+    return wright_bessel(static_cast<double>(a), static_cast<double>(b), static_cast<double>(x));
+}
+
+SPECFUN_HOST_DEVICE inline double log_wright_bessel(double a, double b, double x) {
+    return wright_bessel_t<true>(a, b, x);
+}
+
+SPECFUN_HOST_DEVICE inline float log_wright_bessel(float a, float b, float x) {
+    return log_wright_bessel(static_cast<double>(a), static_cast<double>(b), static_cast<double>(x));
+}
+
+} // namespace special

parrot/lib/python3.10/site-packages/scipy/special/special/zlog1.h

@@ -0,0 +1,35 @@
+/* Translated from Cython into C++ by SciPy developers in 2023.
+ *
+ * Original author: Josh Wilson, 2016.
+ */
+
+#pragma once
+
+#include "config.h"
+
+namespace special {
+namespace detail {
+
+    SPECFUN_HOST_DEVICE inline std::complex<double> zlog1(std::complex<double> z) {
+        /* Compute log, paying special attention to accuracy around 1. We
+         * implement this ourselves because some systems (most notably the
+         * Travis CI machines) are weak in this regime. */
+        std::complex<double> coeff = -1.0;
+        std::complex<double> res = 0.0;
+
+        if (std::abs(z - 1.0) > 0.1) {
+            return std::log(z);
+        }
+
+        z -= 1.0;
+        for (int n = 1; n < 17; n++) {
+            coeff *= -z;
+            res += coeff / static_cast<double>(n);
+            if (std::abs(res / coeff) < std::numeric_limits<double>::epsilon()) {
+                break;
+            }
+        }
+        return res;
+    }
+} // namespace detail
+} // namespace special

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_cdist_backward_cpu_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor _cdist_backward(const at::Tensor & grad, const at::Tensor & x1, const at::Tensor & x2, double p, const at::Tensor & cdist);
+
+} // namespace cpu
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_validate_sparse_csc_tensor_args.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_validate_sparse_csc_tensor_args_ops.h>
+
+namespace at {
+
+
+// aten::_validate_sparse_csc_tensor_args(Tensor ccol_indices, Tensor row_indices, Tensor values, int[] size) -> ()
+inline void _validate_sparse_csc_tensor_args(const at::Tensor & ccol_indices, const at::Tensor & row_indices, const at::Tensor & values, at::IntArrayRef size) {
+    return at::_ops::_validate_sparse_csc_tensor_args::call(ccol_indices, row_indices, values, size);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/_weight_norm_interface.h

@@ -0,0 +1,39 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/_weight_norm_interface_ops.h>
+
+namespace at {
+
+
+// aten::_weight_norm_interface(Tensor v, Tensor g, int dim=0) -> (Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor> _weight_norm_interface(const at::Tensor & v, const at::Tensor & g, int64_t dim=0) {
+    return at::_ops::_weight_norm_interface::call(v, g, dim);
+}
+
+// aten::_weight_norm_interface.out(Tensor v, Tensor g, int dim=0, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
+inline ::std::tuple<at::Tensor &,at::Tensor &> _weight_norm_interface_out(at::Tensor & out0, at::Tensor & out1, const at::Tensor & v, const at::Tensor & g, int64_t dim=0) {
+    return at::_ops::_weight_norm_interface_out::call(v, g, dim, out0, out1);
+}
+// aten::_weight_norm_interface.out(Tensor v, Tensor g, int dim=0, *, Tensor(a!) out0, Tensor(b!) out1) -> (Tensor(a!), Tensor(b!))
+inline ::std::tuple<at::Tensor &,at::Tensor &> _weight_norm_interface_outf(const at::Tensor & v, const at::Tensor & g, int64_t dim, at::Tensor & out0, at::Tensor & out1) {
+    return at::_ops::_weight_norm_interface_out::call(v, g, dim, out0, out1);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/and_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor __and__(const at::Tensor & self, const at::Scalar & other);
+TORCH_API at::Tensor & __iand__(at::Tensor & self, const at::Scalar & other);
+TORCH_API at::Tensor __and__(const at::Tensor & self, const at::Tensor & other);
+TORCH_API at::Tensor & __iand__(at::Tensor & self, const at::Tensor & other);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/arctanh.h

@@ -0,0 +1,44 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/arctanh_ops.h>
+
+namespace at {
+
+
+// aten::arctanh(Tensor self) -> Tensor
+inline at::Tensor arctanh(const at::Tensor & self) {
+    return at::_ops::arctanh::call(self);
+}
+
+// aten::arctanh_(Tensor(a!) self) -> Tensor(a!)
+inline at::Tensor & arctanh_(at::Tensor & self) {
+    return at::_ops::arctanh_::call(self);
+}
+
+// aten::arctanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & arctanh_out(at::Tensor & out, const at::Tensor & self) {
+    return at::_ops::arctanh_out::call(self, out);
+}
+// aten::arctanh.out(Tensor self, *, Tensor(a!) out) -> Tensor(a!)
+inline at::Tensor & arctanh_outf(const at::Tensor & self, at::Tensor & out) {
+    return at::_ops::arctanh_out::call(self, out);
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/bitwise_right_shift_ops.h

@@ -0,0 +1,105 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API bitwise_right_shift_Tensor {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift.Tensor(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API bitwise_right_shift__Tensor {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift_.Tensor(Tensor(a!) self, Tensor other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API bitwise_right_shift_Tensor_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift.Tensor_out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+struct TORCH_API bitwise_right_shift_Tensor_Scalar {
+  using schema = at::Tensor (const at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift.Tensor_Scalar(Tensor self, Scalar other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Scalar & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API bitwise_right_shift__Tensor_Scalar {
+  using schema = at::Tensor & (at::Tensor &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift_.Tensor_Scalar(Tensor(a!) self, Scalar other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Scalar & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Scalar & other);
+};
+
+struct TORCH_API bitwise_right_shift_Tensor_Scalar_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Scalar &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Tensor_Scalar_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift.Tensor_Scalar_out(Tensor self, Scalar other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Scalar & other, at::Tensor & out);
+};
+
+struct TORCH_API bitwise_right_shift_Scalar_Tensor {
+  using schema = at::Tensor (const at::Scalar &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_Tensor")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift.Scalar_Tensor(Scalar self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Scalar & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other);
+};
+
+struct TORCH_API bitwise_right_shift_Scalar_Tensor_out {
+  using schema = at::Tensor & (const at::Scalar &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::bitwise_right_shift")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "Scalar_Tensor_out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "bitwise_right_shift.Scalar_Tensor_out(Scalar self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Scalar & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Scalar & self, const at::Tensor & other, at::Tensor & out);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hardtanh_cpu_dispatch.h

@@ -0,0 +1,26 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cpu {
+
+TORCH_API at::Tensor hardtanh(const at::Tensor & self, const at::Scalar & min_val=-1, const at::Scalar & max_val=1);
+TORCH_API at::Tensor & hardtanh_out(at::Tensor & out, const at::Tensor & self, const at::Scalar & min_val=-1, const at::Scalar & max_val=1);
+TORCH_API at::Tensor & hardtanh_outf(const at::Tensor & self, const at::Scalar & min_val, const at::Scalar & max_val, at::Tensor & out);
+TORCH_API at::Tensor & hardtanh_(at::Tensor & self, const at::Scalar & min_val=-1, const at::Scalar & max_val=1);
+
+} // namespace cpu
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/hypot_ops.h

@@ -0,0 +1,50 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API hypot_out {
+  using schema = at::Tensor & (const at::Tensor &, const at::Tensor &, at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hypot")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "out")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hypot.out(Tensor self, Tensor other, *, Tensor(a!) out) -> Tensor(a!)")
+  static at::Tensor & call(const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other, at::Tensor & out);
+};
+
+struct TORCH_API hypot {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hypot")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hypot(Tensor self, Tensor other) -> Tensor")
+  static at::Tensor call(const at::Tensor & self, const at::Tensor & other);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & self, const at::Tensor & other);
+};
+
+struct TORCH_API hypot_ {
+  using schema = at::Tensor & (at::Tensor &, const at::Tensor &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::hypot_")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "hypot_(Tensor(a!) self, Tensor other) -> Tensor(a!)")
+  static at::Tensor & call(at::Tensor & self, const at::Tensor & other);
+  static at::Tensor & redispatch(c10::DispatchKeySet dispatchKeySet, at::Tensor & self, const at::Tensor & other);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/linalg_inv_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor linalg_inv(const at::Tensor & A);
+TORCH_API at::Tensor & linalg_inv_out(at::Tensor & out, const at::Tensor & A);
+TORCH_API at::Tensor & linalg_inv_outf(const at::Tensor & A, at::Tensor & out);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_dropout_backward_cuda_dispatch.h

@@ -0,0 +1,23 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace cuda {
+
+TORCH_API at::Tensor native_dropout_backward(const at::Tensor & grad_output, const at::Tensor & mask, double scale);
+
+} // namespace cuda
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/native_layer_norm_backward.h

@@ -0,0 +1,91 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/native_layer_norm_backward_ops.h>
+
+namespace at {
+
+
+// aten::native_layer_norm_backward(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm_backward(const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward::call(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm_backward(const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward::call(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask);
+  }
+}
+
+// aten::native_layer_norm_backward(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask) -> (Tensor, Tensor, Tensor)
+inline ::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm_backward_symint(const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward::call(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::tuple<at::Tensor,at::Tensor,at::Tensor> native_layer_norm_backward(const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward::call(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask);
+  }
+}
+
+// aten::native_layer_norm_backward.out(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask, out0, out1, out2);
+  }
+}
+
+// aten::native_layer_norm_backward.out(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_outf(const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_outf(const at::Tensor & grad_out, const at::Tensor & input, at::IntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, c10::fromIntArrayRefSlow(normalized_shape), mean, rstd, weight, bias, output_mask, out0, out1, out2);
+  }
+}
+
+// aten::native_layer_norm_backward.out(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_symint_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_out(at::Tensor & out0, at::Tensor & out1, at::Tensor & out2, const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
+  }
+}
+
+// aten::native_layer_norm_backward.out(Tensor grad_out, Tensor input, SymInt[] normalized_shape, Tensor mean, Tensor rstd, Tensor? weight, Tensor? bias, bool[3] output_mask, *, Tensor(a!) out0, Tensor(b!) out1, Tensor(c!) out2) -> (Tensor(a!), Tensor(b!), Tensor(c!))
+inline ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_symint_outf(const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::tuple<at::Tensor &,at::Tensor &,at::Tensor &> native_layer_norm_backward_outf(const at::Tensor & grad_out, const at::Tensor & input, c10::SymIntArrayRef normalized_shape, const at::Tensor & mean, const at::Tensor & rstd, const c10::optional<at::Tensor> & weight, const c10::optional<at::Tensor> & bias, ::std::array<bool,3> output_mask, at::Tensor & out0, at::Tensor & out1, at::Tensor & out2) {
+    return at::_ops::native_layer_norm_backward_out::call(grad_out, input, normalized_shape, mean, rstd, weight, bias, output_mask, out0, out1, out2);
+  }
+}
+
+}

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/pixel_shuffle_compositeexplicitautograd_dispatch.h

@@ -0,0 +1,24 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeexplicitautograd {
+
+TORCH_API at::Tensor & pixel_shuffle_out(at::Tensor & out, const at::Tensor & self, int64_t upscale_factor);
+TORCH_API at::Tensor & pixel_shuffle_outf(const at::Tensor & self, int64_t upscale_factor, at::Tensor & out);
+
+} // namespace compositeexplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/quantized_rnn_relu_cell_ops.h

@@ -0,0 +1,28 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Operator.h
+
+#include <tuple>
+#include <vector>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+namespace _ops {
+
+
+struct TORCH_API quantized_rnn_relu_cell {
+  using schema = at::Tensor (const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Tensor &, const at::Scalar &, const at::Scalar &, const at::Scalar &, const at::Scalar &);
+  using ptr_schema = schema*;
+  // See Note [static constexpr char* members for windows NVCC]
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(name, "aten::quantized_rnn_relu_cell")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(overload_name, "")
+  STATIC_CONSTEXPR_STR_INL_EXCEPT_WIN_CUDA(schema_str, "quantized_rnn_relu_cell(Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih, Tensor b_hh, Tensor packed_ih, Tensor packed_hh, Tensor col_offsets_ih, Tensor col_offsets_hh, Scalar scale_ih, Scalar scale_hh, Scalar zero_point_ih, Scalar zero_point_hh) -> Tensor")
+  static at::Tensor call(const at::Tensor & input, const at::Tensor & hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const at::Tensor & b_ih, const at::Tensor & b_hh, const at::Tensor & packed_ih, const at::Tensor & packed_hh, const at::Tensor & col_offsets_ih, const at::Tensor & col_offsets_hh, const at::Scalar & scale_ih, const at::Scalar & scale_hh, const at::Scalar & zero_point_ih, const at::Scalar & zero_point_hh);
+  static at::Tensor redispatch(c10::DispatchKeySet dispatchKeySet, const at::Tensor & input, const at::Tensor & hx, const at::Tensor & w_ih, const at::Tensor & w_hh, const at::Tensor & b_ih, const at::Tensor & b_hh, const at::Tensor & packed_ih, const at::Tensor & packed_hh, const at::Tensor & col_offsets_ih, const at::Tensor & col_offsets_hh, const at::Scalar & scale_ih, const at::Scalar & scale_hh, const at::Scalar & zero_point_ih, const at::Scalar & zero_point_hh);
+};
+
+}} // namespace at::_ops

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/slice_native.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// @generated by torchgen/gen.py from NativeFunction.h
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+
+
+namespace at {
+namespace native {
+TORCH_API at::Tensor slice(const at::Tensor & self, int64_t dim=0, c10::optional<int64_t> start=c10::nullopt, c10::optional<int64_t> end=c10::nullopt, int64_t step=1);
+} // namespace native
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/special_erfinv_compositeimplicitautograd_dispatch.h

@@ -0,0 +1,25 @@
+#pragma once
+// @generated by torchgen/gen.py from DispatchKeyFunction.h
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace compositeimplicitautograd {
+
+TORCH_API at::Tensor special_erfinv(const at::Tensor & self);
+TORCH_API at::Tensor & special_erfinv_out(at::Tensor & out, const at::Tensor & self);
+TORCH_API at::Tensor & special_erfinv_outf(const at::Tensor & self, at::Tensor & out);
+
+} // namespace compositeimplicitautograd
+} // namespace at

videollama2/lib/python3.10/site-packages/torch/include/ATen/ops/split.h

@@ -0,0 +1,69 @@
+#pragma once
+
+// @generated by torchgen/gen.py from Function.h
+
+#include <ATen/Context.h>
+#include <ATen/DeviceGuard.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/TracerMode.h>
+#include <ATen/core/Generator.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+
+
+
+#include <ATen/ops/split_ops.h>
+
+namespace at {
+
+
+// aten::split.Tensor(Tensor(a -> *) self, SymInt split_size, int dim=0) -> Tensor(a)[]
+inline ::std::vector<at::Tensor> split(const at::Tensor & self, int64_t split_size, int64_t dim=0) {
+    return at::_ops::split_Tensor::call(self, split_size, dim);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::vector<at::Tensor> split(const at::Tensor & self, int64_t split_size, int64_t dim=0) {
+    return at::_ops::split_Tensor::call(self, split_size, dim);
+  }
+}
+
+// aten::split.Tensor(Tensor(a -> *) self, SymInt split_size, int dim=0) -> Tensor(a)[]
+inline ::std::vector<at::Tensor> split_symint(const at::Tensor & self, c10::SymInt split_size, int64_t dim=0) {
+    return at::_ops::split_Tensor::call(self, split_size, dim);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::vector<at::Tensor> split(const at::Tensor & self, c10::SymInt split_size, int64_t dim=0) {
+    return at::_ops::split_Tensor::call(self, split_size, dim);
+  }
+}
+
+// aten::split.sizes(Tensor(a -> *) self, SymInt[] split_size, int dim=0) -> Tensor(a)[]
+inline ::std::vector<at::Tensor> split(const at::Tensor & self, at::IntArrayRef split_size, int64_t dim=0) {
+    return at::_ops::split_sizes::call(self, c10::fromIntArrayRefSlow(split_size), dim);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, int64_t>::value>>
+  ::std::vector<at::Tensor> split(const at::Tensor & self, at::IntArrayRef split_size, int64_t dim=0) {
+    return at::_ops::split_sizes::call(self, c10::fromIntArrayRefSlow(split_size), dim);
+  }
+}
+
+// aten::split.sizes(Tensor(a -> *) self, SymInt[] split_size, int dim=0) -> Tensor(a)[]
+inline ::std::vector<at::Tensor> split_symint(const at::Tensor & self, c10::SymIntArrayRef split_size, int64_t dim=0) {
+    return at::_ops::split_sizes::call(self, split_size, dim);
+}
+namespace symint {
+  template <typename T, typename = std::enable_if_t<std::is_same<T, c10::SymInt>::value>>
+  ::std::vector<at::Tensor> split(const at::Tensor & self, c10::SymIntArrayRef split_size, int64_t dim=0) {
+    return at::_ops::split_sizes::call(self, split_size, dim);
+  }
+}
+
+}