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

scipy/special/_ufuncs_cxx.pxd

@@ -84,8 +84,6 @@ cdef void *_export_nct_mean_float
 cdef void *_export_nct_mean_double
 cdef void *_export_nct_pdf_float
 cdef void *_export_nct_pdf_double
-cdef void *_export_nct_ppf_float
-cdef void *_export_nct_ppf_double
 cdef void *_export_nct_sf_float
 cdef void *_export_nct_sf_double
 cdef void *_export_nct_skewness_float
@@ -117,8 +115,6 @@ cdef void *_export_ibetac_inv_float
 cdef void *_export_ibetac_inv_double
 cdef void *_export_ibeta_inv_float
 cdef void *_export_ibeta_inv_double
-cdef void *_export_faddeeva_dawsn
-cdef void *_export_faddeeva_dawsn_complex
 cdef void *_export_fellint_RC
 cdef void *_export_cellint_RC
 cdef void *_export_fellint_RD
@@ -129,27 +125,18 @@ cdef void *_export_fellint_RG
 cdef void *_export_cellint_RG
 cdef void *_export_fellint_RJ
 cdef void *_export_cellint_RJ
-cdef void *_export_faddeeva_erf
-cdef void *_export_faddeeva_erfc_complex
-cdef void *_export_faddeeva_erfcx
-cdef void *_export_faddeeva_erfcx_complex
-cdef void *_export_faddeeva_erfi
-cdef void *_export_faddeeva_erfi_complex
 cdef void *_export_erfinv_float
 cdef void *_export_erfinv_double
 cdef void *_export_hyp1f1_double
-cdef void *_export_faddeeva_log_ndtr
-cdef void *_export_faddeeva_log_ndtr_complex
 cdef void *_export_ncf_cdf_float
 cdef void *_export_ncf_cdf_double
 cdef void *_export_ncf_ppf_float
 cdef void *_export_ncf_ppf_double
 cdef void *_export_nct_cdf_float
 cdef void *_export_nct_cdf_double
-cdef void *_export_faddeeva_ndtr
+cdef void *_export_nct_ppf_float
+cdef void *_export_nct_ppf_double
 cdef void *_export_powm1_float
 cdef void *_export_powm1_double
-cdef void *_export_faddeeva_voigt_profile
-cdef void *_export_faddeeva_w
 cdef void *_export_wrightomega
 cdef void *_export_wrightomega_real

scipy/special/_ufuncs_cxx.pyx

@@ -257,12 +257,6 @@ cdef void *_export_nct_pdf_float = <void*>_func_nct_pdf_float
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double _func_nct_pdf_double "nct_pdf_double"(double, double, double) noexcept nogil
 cdef void *_export_nct_pdf_double = <void*>_func_nct_pdf_double
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef float _func_nct_ppf_float "nct_ppf_float"(float, float, float) noexcept nogil
-cdef void *_export_nct_ppf_float = <void*>_func_nct_ppf_float
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double _func_nct_ppf_double "nct_ppf_double"(double, double, double) noexcept nogil
-cdef void *_export_nct_ppf_double = <void*>_func_nct_ppf_double
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef float _func_nct_sf_float "nct_sf_float"(float, float, float) noexcept nogil
 cdef void *_export_nct_sf_float = <void*>_func_nct_sf_float
@@ -356,12 +350,6 @@ cdef void *_export_ibeta_inv_float = <void*>_func_ibeta_inv_float
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double _func_ibeta_inv_double "ibeta_inv_double"(double, double, double) noexcept nogil
 cdef void *_export_ibeta_inv_double = <void*>_func_ibeta_inv_double
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double _func_faddeeva_dawsn "faddeeva_dawsn"(double) noexcept nogil
-cdef void *_export_faddeeva_dawsn = <void*>_func_faddeeva_dawsn
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_dawsn_complex "faddeeva_dawsn_complex"(double complex) noexcept nogil
-cdef void *_export_faddeeva_dawsn_complex = <void*>_func_faddeeva_dawsn_complex
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double _func_fellint_RC "fellint_RC"(double, double) noexcept nogil
 cdef void *_export_fellint_RC = <void*>_func_fellint_RC
@@ -392,24 +380,6 @@ cdef void *_export_fellint_RJ = <void*>_func_fellint_RJ
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double complex _func_cellint_RJ "cellint_RJ"(double complex, double complex, double complex, double complex) noexcept nogil
 cdef void *_export_cellint_RJ = <void*>_func_cellint_RJ
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_erf "faddeeva_erf"(double complex) noexcept nogil
-cdef void *_export_faddeeva_erf = <void*>_func_faddeeva_erf
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_erfc_complex "faddeeva_erfc_complex"(double complex) noexcept nogil
-cdef void *_export_faddeeva_erfc_complex = <void*>_func_faddeeva_erfc_complex
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double _func_faddeeva_erfcx "faddeeva_erfcx"(double) noexcept nogil
-cdef void *_export_faddeeva_erfcx = <void*>_func_faddeeva_erfcx
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_erfcx_complex "faddeeva_erfcx_complex"(double complex) noexcept nogil
-cdef void *_export_faddeeva_erfcx_complex = <void*>_func_faddeeva_erfcx_complex
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double _func_faddeeva_erfi "faddeeva_erfi"(double) noexcept nogil
-cdef void *_export_faddeeva_erfi = <void*>_func_faddeeva_erfi
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_erfi_complex "faddeeva_erfi_complex"(double complex) noexcept nogil
-cdef void *_export_faddeeva_erfi_complex = <void*>_func_faddeeva_erfi_complex
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef float _func_erfinv_float "erfinv_float"(float) noexcept nogil
 cdef void *_export_erfinv_float = <void*>_func_erfinv_float
@@ -419,12 +389,6 @@ cdef void *_export_erfinv_double = <void*>_func_erfinv_double
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double _func_hyp1f1_double "hyp1f1_double"(double, double, double) noexcept nogil
 cdef void *_export_hyp1f1_double = <void*>_func_hyp1f1_double
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double _func_faddeeva_log_ndtr "faddeeva_log_ndtr"(double) noexcept nogil
-cdef void *_export_faddeeva_log_ndtr = <void*>_func_faddeeva_log_ndtr
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_log_ndtr_complex "faddeeva_log_ndtr_complex"(double complex) noexcept nogil
-cdef void *_export_faddeeva_log_ndtr_complex = <void*>_func_faddeeva_log_ndtr_complex
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef float _func_ncf_cdf_float "ncf_cdf_float"(float, float, float, float) noexcept nogil
 cdef void *_export_ncf_cdf_float = <void*>_func_ncf_cdf_float
@@ -444,20 +408,17 @@ cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double _func_nct_cdf_double "nct_cdf_double"(double, double, double) noexcept nogil
 cdef void *_export_nct_cdf_double = <void*>_func_nct_cdf_double
 cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_ndtr "faddeeva_ndtr"(double complex) noexcept nogil
-cdef void *_export_faddeeva_ndtr = <void*>_func_faddeeva_ndtr
+    cdef float _func_nct_ppf_float "nct_ppf_float"(float, float, float) noexcept nogil
+cdef void *_export_nct_ppf_float = <void*>_func_nct_ppf_float
+cdef extern from r"_ufuncs_cxx_defs.h":
+    cdef double _func_nct_ppf_double "nct_ppf_double"(double, double, double) noexcept nogil
+cdef void *_export_nct_ppf_double = <void*>_func_nct_ppf_double
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef float _func_powm1_float "powm1_float"(float, float) noexcept nogil
 cdef void *_export_powm1_float = <void*>_func_powm1_float
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double _func_powm1_double "powm1_double"(double, double) noexcept nogil
 cdef void *_export_powm1_double = <void*>_func_powm1_double
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double _func_faddeeva_voigt_profile "faddeeva_voigt_profile"(double, double, double) noexcept nogil
-cdef void *_export_faddeeva_voigt_profile = <void*>_func_faddeeva_voigt_profile
-cdef extern from r"_ufuncs_cxx_defs.h":
-    cdef double complex _func_faddeeva_w "faddeeva_w"(double complex) noexcept nogil
-cdef void *_export_faddeeva_w = <void*>_func_faddeeva_w
 cdef extern from r"_ufuncs_cxx_defs.h":
     cdef double complex _func_wrightomega "wrightomega"(double complex) noexcept nogil
 cdef void *_export_wrightomega = <void*>_func_wrightomega

scipy/special/_ufuncs_cxx_defs.h

@@ -85,8 +85,6 @@ npy_float nct_mean_float(npy_float, npy_float);
 npy_double nct_mean_double(npy_double, npy_double);
 npy_float nct_pdf_float(npy_float, npy_float, npy_float);
 npy_double nct_pdf_double(npy_double, npy_double, npy_double);
-npy_float nct_ppf_float(npy_float, npy_float, npy_float);
-npy_double nct_ppf_double(npy_double, npy_double, npy_double);
 npy_float nct_sf_float(npy_float, npy_float, npy_float);
 npy_double nct_sf_double(npy_double, npy_double, npy_double);
 npy_float nct_skewness_float(npy_float, npy_float);
@@ -119,9 +117,6 @@ npy_float ibetac_inv_float(npy_float, npy_float, npy_float);
 npy_double ibetac_inv_double(npy_double, npy_double, npy_double);
 npy_float ibeta_inv_float(npy_float, npy_float, npy_float);
 npy_double ibeta_inv_double(npy_double, npy_double, npy_double);
-#include "_faddeeva.h"
-npy_double faddeeva_dawsn(npy_double);
-npy_cdouble faddeeva_dawsn_complex(npy_cdouble);
 #include "ellint_carlson_wrap.hh"
 npy_double fellint_RC(npy_double, npy_double);
 npy_cdouble cellint_RC(npy_cdouble, npy_cdouble);
@@ -133,28 +128,19 @@ npy_double fellint_RG(npy_double, npy_double, npy_double);
 npy_cdouble cellint_RG(npy_cdouble, npy_cdouble, npy_cdouble);
 npy_double fellint_RJ(npy_double, npy_double, npy_double, npy_double);
 npy_cdouble cellint_RJ(npy_cdouble, npy_cdouble, npy_cdouble, npy_cdouble);
-npy_cdouble faddeeva_erf(npy_cdouble);
-npy_cdouble faddeeva_erfc_complex(npy_cdouble);
-npy_double faddeeva_erfcx(npy_double);
-npy_cdouble faddeeva_erfcx_complex(npy_cdouble);
-npy_double faddeeva_erfi(npy_double);
-npy_cdouble faddeeva_erfi_complex(npy_cdouble);
 npy_float erfinv_float(npy_float);
 npy_double erfinv_double(npy_double);
 npy_double hyp1f1_double(npy_double, npy_double, npy_double);
-npy_double faddeeva_log_ndtr(npy_double);
-npy_cdouble faddeeva_log_ndtr_complex(npy_cdouble);
 npy_float ncf_cdf_float(npy_float, npy_float, npy_float, npy_float);
 npy_double ncf_cdf_double(npy_double, npy_double, npy_double, npy_double);
 npy_float ncf_ppf_float(npy_float, npy_float, npy_float, npy_float);
 npy_double ncf_ppf_double(npy_double, npy_double, npy_double, npy_double);
 npy_float nct_cdf_float(npy_float, npy_float, npy_float);
 npy_double nct_cdf_double(npy_double, npy_double, npy_double);
-npy_cdouble faddeeva_ndtr(npy_cdouble);
+npy_float nct_ppf_float(npy_float, npy_float, npy_float);
+npy_double nct_ppf_double(npy_double, npy_double, npy_double);
 npy_float powm1_float(npy_float, npy_float);
 npy_double powm1_double(npy_double, npy_double);
-npy_double faddeeva_voigt_profile(npy_double, npy_double, npy_double);
-npy_cdouble faddeeva_w(npy_cdouble);
 #include "_wright.h"
 npy_cdouble wrightomega(npy_cdouble);
 npy_double wrightomega_real(npy_double);

scipy/special/_ufuncs_defs.h

@@ -10,7 +10,6 @@ npy_double xsf_kolmogci(npy_double);
 npy_double xsf_kolmogp(npy_double);
 npy_double cephes_lanczos_sum_expg_scaled(npy_double);
 npy_double cephes_lgam1p(npy_double);
-npy_double cephes_log1pmx(npy_double);
 npy_double cephes_smirnovc_wrap(npy_intp, npy_double);
 npy_double cephes_smirnovci_wrap(npy_intp, npy_double);
 npy_double cephes_smirnovp_wrap(npy_intp, npy_double);
@@ -23,12 +22,7 @@ npy_double cephes_bdtri_wrap(npy_double, npy_intp, npy_double);
 npy_double xsf_chdtr(npy_double, npy_double);
 npy_double xsf_chdtrc(npy_double, npy_double);
 npy_double xsf_chdtri(npy_double, npy_double);
-npy_double cephes_erf(npy_double);
-npy_double cephes_erfc(npy_double);
 npy_double cephes_erfcinv(npy_double);
-npy_double cephes_exp10(npy_double);
-npy_double cephes_exp2(npy_double);
-npy_double cephes_expm1(npy_double);
 npy_double cephes_expn_wrap(npy_intp, npy_double);
 npy_double xsf_fdtr(npy_double, npy_double, npy_double);
 npy_double xsf_fdtrc(npy_double, npy_double, npy_double);
@@ -40,12 +34,10 @@ npy_cdouble chyp1f1_wrap(npy_double, npy_double, npy_cdouble);
 npy_double special_cyl_bessel_k_int(npy_intp, npy_double);
 npy_double xsf_kolmogi(npy_double);
 npy_double xsf_kolmogorov(npy_double);
-npy_double cephes_log1p(npy_double);
 npy_double pmv_wrap(npy_double, npy_double, npy_double);
 npy_double cephes_nbdtr_wrap(npy_intp, npy_intp, npy_double);
 npy_double cephes_nbdtrc_wrap(npy_intp, npy_intp, npy_double);
 npy_double cephes_nbdtri_wrap(npy_intp, npy_intp, npy_double);
-npy_double xsf_ndtr(npy_double);
 npy_double xsf_ndtri(npy_double);
 npy_double xsf_owens_t(npy_double, npy_double);
 npy_double xsf_pdtr(npy_double, npy_double);

scipy/special/cython_special.pxd

@@ -196,7 +196,7 @@ cpdef double ncfdtrinc(double x0, double x1, double x2, double x3) noexcept nogi
 cpdef df_number_t nctdtr(df_number_t x0, df_number_t x1, df_number_t x2) noexcept nogil
 cpdef double nctdtridf(double x0, double x1, double x2) noexcept nogil
 cpdef double nctdtrinc(double x0, double x1, double x2) noexcept nogil
-cpdef double nctdtrit(double x0, double x1, double x2) noexcept nogil
+cpdef df_number_t nctdtrit(df_number_t x0, df_number_t x1, df_number_t x2) noexcept nogil
 cpdef Dd_number_t ndtr(Dd_number_t x0) noexcept nogil
 cpdef double ndtri(double x0) noexcept nogil
 cpdef double nrdtrimn(double x0, double x1, double x2) noexcept nogil

scipy/special/tests/_cython_examples/meson.build

@@ -10,10 +10,17 @@ if not cy.version().version_compare('>=3.0.8')
   error('tests requires Cython >= 3.0.8')
 endif
 
+cython_args = []
+if cy.version().version_compare('>=3.1.0')
+  cython_args += ['-Xfreethreading_compatible=True']
+endif
+
 py3.extension_module(
   'extending',
   'extending.pyx',
   install: false,
+  cython_args: cython_args,
+  c_args: ['-DCYTHON_CCOMPLEX=0'] # see gh-18975 for why we need this
 )
 
 extending_cpp = fs.copyfile('extending.pyx', 'extending_cpp.pyx')
@@ -21,5 +28,7 @@ py3.extension_module(
   'extending_cpp',
   extending_cpp,
   install: false,
-  override_options : ['cython_language=cpp']
+  override_options : ['cython_language=cpp'],
+  cython_args: cython_args,
+  cpp_args: ['-DCYTHON_CCOMPLEX=0']
 )

scipy/special/tests/test_basic.py

@@ -1442,14 +1442,79 @@ class TestBetaInc:
 
     @pytest.mark.parametrize('func', [special.betainc, special.betaincinv,
                                       special.betaincc, special.betainccinv])
-    @pytest.mark.parametrize('args', [(-1.0, 2, 0.5), (0, 2, 0.5),
-                                      (1.5, -2.0, 0.5), (1.5, 0, 0.5),
+    @pytest.mark.parametrize('args', [(-1.0, 2, 0.5), (1.5, -2.0, 0.5),
                                       (1.5, 2.0, -0.3), (1.5, 2.0, 1.1)])
     def test_betainc_domain_errors(self, func, args):
         with special.errstate(domain='raise'):
             with pytest.raises(special.SpecialFunctionError, match='domain'):
                 special.betainc(*args)
 
+    @pytest.mark.parametrize(
+        "args,expected",
+        [
+            ((0.0, 0.0, 0.0), np.nan),
+            ((0.0, 0.0, 0.5), np.nan),
+            ((0.0, 0.0, 1.0), np.nan),
+            ((np.inf, np.inf, 0.0), np.nan),
+            ((np.inf, np.inf, 0.5), np.nan),
+            ((np.inf, np.inf, 1.0), np.nan),
+            ((0.0, 1.0, 0.0), 0.0),
+            ((0.0, 1.0, 0.5), 1.0),
+            ((0.0, 1.0, 1.0), 1.0),
+            ((1.0, 0.0, 0.0), 0.0),
+            ((1.0, 0.0, 0.5), 0.0),
+            ((1.0, 0.0, 1.0), 1.0),
+            ((0.0, np.inf, 0.0), 0.0),
+            ((0.0, np.inf, 0.5), 1.0),
+            ((0.0, np.inf, 1.0), 1.0),
+            ((np.inf, 0.0, 0.0), 0.0),
+            ((np.inf, 0.0, 0.5), 0.0),
+            ((np.inf, 0.0, 1.0), 1.0),
+            ((1.0, np.inf, 0.0), 0.0),
+            ((1.0, np.inf, 0.5), 1.0),
+            ((1.0, np.inf, 1.0), 1.0),
+            ((np.inf, 1.0, 0.0), 0.0),
+            ((np.inf, 1.0, 0.5), 0.0),
+            ((np.inf, 1.0, 1.0), 1.0),
+        ]
+    )
+    def test_betainc_edge_cases(self, args, expected):
+        observed = special.betainc(*args)
+        assert_equal(observed, expected)
+
+    @pytest.mark.parametrize(
+        "args,expected",
+        [
+            ((0.0, 0.0, 0.0), np.nan),
+            ((0.0, 0.0, 0.5), np.nan),
+            ((0.0, 0.0, 1.0), np.nan),
+            ((np.inf, np.inf, 0.0), np.nan),
+            ((np.inf, np.inf, 0.5), np.nan),
+            ((np.inf, np.inf, 1.0), np.nan),
+            ((0.0, 1.0, 0.0), 1.0),
+            ((0.0, 1.0, 0.5), 0.0),
+            ((0.0, 1.0, 1.0), 0.0),
+            ((1.0, 0.0, 0.0), 1.0),
+            ((1.0, 0.0, 0.5), 1.0),
+            ((1.0, 0.0, 1.0), 0.0),
+            ((0.0, np.inf, 0.0), 1.0),
+            ((0.0, np.inf, 0.5), 0.0),
+            ((0.0, np.inf, 1.0), 0.0),
+            ((np.inf, 0.0, 0.0), 1.0),
+            ((np.inf, 0.0, 0.5), 1.0),
+            ((np.inf, 0.0, 1.0), 0.0),
+            ((1.0, np.inf, 0.0), 1.0),
+            ((1.0, np.inf, 0.5), 0.0),
+            ((1.0, np.inf, 1.0), 0.0),
+            ((np.inf, 1.0, 0.0), 1.0),
+            ((np.inf, 1.0, 0.5), 1.0),
+            ((np.inf, 1.0, 1.0), 0.0),
+        ]
+    )
+    def test_betaincc_edge_cases(self, args, expected):
+        observed = special.betaincc(*args)
+        assert_equal(observed, expected)
+
     @pytest.mark.parametrize('dtype', [np.float32, np.float64])
     def test_gh21426(self, dtype):
         # Test for gh-21426: betaincinv must not return NaN
@@ -1492,10 +1557,13 @@ class TestCombinatorics:
         assert_allclose(special.comb([2, -1, 2, 10], [3, 3, -1, 3]), [0., 0., 0., 120.])
 
     @pytest.mark.thread_unsafe
-    def test_comb_exact_non_int_dep(self):
+    def test_comb_exact_non_int_error(self):
         msg = "`exact=True`"
-        with pytest.deprecated_call(match=msg):
+        with pytest.raises(ValueError, match=msg):
             special.comb(3.4, 4, exact=True)
+        with pytest.raises(ValueError, match=msg):
+            special.comb(3, 4.4, exact=True)
+
 
     def test_perm(self):
         assert_allclose(special.perm([10, 10], [3, 4]), [720., 5040.])
@@ -1515,17 +1583,12 @@ class TestCombinatorics:
         with pytest.raises(ValueError, match="scalar integers"):
             special.perm([1, 2], [4, 5], exact=True)
 
-        # Non-integral scalars with N < k, or N,k < 0 used to return 0, this is now
-        # deprecated and will raise an error in SciPy 1.16.0
-        with pytest.deprecated_call(match="Non-integer"):
+        with pytest.raises(ValueError, match="Non-integer"):
             special.perm(4.6, 6, exact=True)
-        with pytest.deprecated_call(match="Non-integer"):
+        with pytest.raises(ValueError, match="Non-integer"):
             special.perm(-4.6, 3, exact=True)
-        with pytest.deprecated_call(match="Non-integer"):
+        with pytest.raises(ValueError, match="Non-integer"):
             special.perm(4, -3.9, exact=True)
-
-        # Non-integral scalars which aren't included in the cases above an raise an
-        # error directly without deprecation as this code never worked
         with pytest.raises(ValueError, match="Non-integer"):
             special.perm(6.0, 4.6, exact=True)
 
@@ -2353,6 +2416,7 @@ class TestFactorialFunctions:
         assert_func(special.factorialk(n, 3, exact=exact),
                     np.array(exp_nucleus[3], ndmin=level))
 
+    @pytest.mark.fail_slow(5)
     @pytest.mark.parametrize("dtype", [np.uint8, np.uint16, np.uint32, np.uint64])
     @pytest.mark.parametrize("exact,extend",
                              [(True, "zero"), (False, "zero"), (False, "complex")])
@@ -2366,10 +2430,38 @@ class TestFactorialFunctions:
             assert_func(special.factorial2(n, **kw), special.factorial2(n_ref, **kw))
             assert_func(special.factorialk(n, k=3, **kw),
                         special.factorialk(n_ref, k=3, **kw))
+        def _check_inf(n):
+            # produce inf of same type/dimension
+            with suppress_warnings() as sup:
+                sup.filter(RuntimeWarning)
+                shaped_inf = n / 0
+            assert_func(special.factorial(n, **kw), shaped_inf)
+            assert_func(special.factorial2(n, **kw), shaped_inf)
+            assert_func(special.factorialk(n, k=3, **kw), shaped_inf)
+
         _check(dtype(0))
         _check(dtype(1))
         _check(np.array(0, dtype=dtype))
         _check(np.array([0, 1], dtype=dtype))
+        # test that maximal uint values work as well
+        N = dtype(np.iinfo(dtype).max)
+        # TODO: cannot use N itself yet; factorial uses `gamma(N+1)` resp. `(hi+lo)//2`
+        if dtype == np.uint64:
+            if exact:
+                # avoid attempting huge calculation
+                pass
+            elif np.lib.NumpyVersion(np.__version__) >= "2.0.0":
+                # N does not fit into int64 --> cannot use _check
+                _check_inf(dtype(N-1))
+                _check_inf(np.array(N-1, dtype=dtype))
+                _check_inf(np.array([N-1], dtype=dtype))
+        elif dtype in [np.uint8, np.uint16] or not exact:
+            # factorial(65535, exact=True) has 287189 digits and is calculated almost
+            # instantaneously on modern hardware; however, dtypes bigger than uint16
+            # would blow up runtime and memory consumption for exact=True
+            _check(N-1)
+            _check(np.array(N-1, dtype=dtype))
+            _check(np.array([N-2, N-1], dtype=dtype))
 
     # note that n=170 is the last integer such that factorial(n) fits float64
     @pytest.mark.parametrize('n', range(30, 180, 10))
@@ -2965,10 +3057,10 @@ class TestGamma:
         pts = [0.25,
                np.nextafter(0.25, 0), 0.25 - 1e-12,
                np.nextafter(0.25, 1), 0.25 + 1e-12]
-        for xp in pts:
-            y = special.gammaincinv(.4, xp)
+        for pt in pts:
+            y = special.gammaincinv(.4, pt)
             x = special.gammainc(0.4, y)
-            assert_allclose(x, xp, rtol=1e-12)
+            assert_allclose(x, pt, rtol=1e-12)
 
     def test_rgamma(self):
         rgam = special.rgamma(8)
@@ -3241,7 +3333,7 @@ class TestHyper:
         ]
         for i, (a, b, c, x, v) in enumerate(values):
             cv = special.hyp2f1(a, b, c, x)
-            assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
+            assert_almost_equal(cv, v, 8, err_msg=f'test #{i}')
 
     def test_hyperu(self):
         val1 = special.hyperu(1,0.1,100)
@@ -3307,7 +3399,7 @@ class TestBessel:
                   ]
         for i, (v, x, y) in enumerate(values):
             yc = special.jv(v, x)
-            assert_almost_equal(yc, y, 8, err_msg='test #%d' % i)
+            assert_almost_equal(yc, y, 8, err_msg=f'test #{i}')
 
     def test_negv_jve(self):
         assert_almost_equal(special.jve(-3,2), -special.jve(3,2), 14)
@@ -3379,7 +3471,7 @@ class TestBessel:
                 elif tt == 1:
                     assert_allclose(jnp(nn, zz), 0, atol=1e-6)
                 else:
-                    raise AssertionError("Invalid t return for nt=%d" % nt)
+                    raise AssertionError(f"Invalid t return for nt={nt}")
 
     def test_jnp_zeros(self):
         jnp = special.jnp_zeros(1,5)
@@ -3799,7 +3891,7 @@ class TestBessel:
                   ]
         for i, (x, v) in enumerate(values):
             cv = special.i0(x) * exp(-x)
-            assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
+            assert_almost_equal(cv, v, 8, err_msg=f'test #{i}')
 
     def test_i0e(self):
         oize = special.i0e(.1)
@@ -3817,7 +3909,7 @@ class TestBessel:
                   ]
         for i, (x, v) in enumerate(values):
             cv = special.i1(x) * exp(-x)
-            assert_almost_equal(cv, v, 8, err_msg='test #%d' % i)
+            assert_almost_equal(cv, v, 8, err_msg=f'test #{i}')
 
     def test_i1e(self):
         oi1e = special.i1e(.1)
@@ -4224,6 +4316,47 @@ def test_ch2_inf():
     assert_equal(special.chdtr(0.7,np.inf), 1.0)
 
 
+@pytest.mark.parametrize("x", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+def test_chi2_v_nan(x):
+    assert np.isnan(special.chdtr(np.nan, x))
+
+
+@pytest.mark.parametrize("v", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+def test_chi2_x_nan(v):
+    assert np.isnan(special.chdtr(v, np.nan))
+
+
+@pytest.mark.parametrize("x", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+def test_chi2c_v_nan(x):
+    assert np.isnan(special.chdtrc(np.nan, x))
+
+
+@pytest.mark.parametrize("v", [-np.inf, -1.0, -0.0, 0.0, np.inf, np.nan])
+def test_chi2c_x_nan(v):
+    assert np.isnan(special.chdtrc(v, np.nan))
+
+
+def test_chi2_edgecases_gh20972():
+    # Tests that a variety of edgecases for chi square distribution functions
+    # correctly return NaN when and only when they are supposed to, when
+    # computed through different related ufuncs. See gh-20972.
+    v = np.asarray([-0.01, 0, 0.01, 1, np.inf])[:, np.newaxis]
+    x = np.asarray([-np.inf, -0.01, 0, 0.01, np.inf])
+
+    # Check that `gammainc` is NaN when it should be and finite otherwise
+    ref = special.gammainc(v / 2, x / 2)
+    mask = (x < 0) | (v < 0) | (x == 0) & (v == 0) | np.isinf(v) & np.isinf(x)
+    assert np.all(np.isnan(ref[mask]))
+    assert np.all(np.isfinite(ref[~mask]))
+
+    # Use `gammainc` as a reference for the rest
+    assert_allclose(special.chdtr(v, x), ref)
+    assert_allclose(special.gdtr(1, v / 2, x / 2), ref)
+    assert_allclose(1 - special.gammaincc(v / 2, x / 2), ref)
+    assert_allclose(1 - special.chdtrc(v, x), ref)
+    assert_allclose(1 - special.gdtrc(1, v / 2, x / 2), ref)
+
+
 def test_chi2c_smalldf():
     assert_almost_equal(special.chdtrc(0.6,3), 1-0.957890536704110)
 

scipy/special/tests/test_boost_ufuncs.py

@@ -59,3 +59,6 @@ def test_landau():
     assert_allclose(ppf, x)
     isf = scu._landau_isf(sf, *args)
     assert_allclose(isf, x, rtol=1e-6)
+
+def test_gh22956():
+    _ = scu._ncx2_pdf(30, 1e307, 16)

scipy/special/tests/test_cdflib.py

@@ -3,14 +3,12 @@ Test cdflib functions versus mpmath, if available.
 
 The following functions still need tests:
 
-- ncfdtri
 - ncfdtridfn
 - ncfdtridfd
 - ncfdtrinc
 - nbdtrik
 - nbdtrin
 - pdtrik
-- nctdtrit
 - nctdtridf
 - nctdtrinc
 
@@ -492,7 +490,7 @@ def test_bdtrik_nbdtrik_inf():
 
 
 @pytest.mark.parametrize(
-    "dfn,dfd,nc,f,expected",
+    "dfn,dfd,nc,f,expected_cdf",
     [[100.0, 0.1, 0.1, 100.0, 0.29787396410092676],
      [100.0, 100.0, 0.01, 0.1, 4.4344737598690424e-26],
      [100.0, 0.01, 0.1, 0.01, 0.002848616633080384],
@@ -506,7 +504,7 @@ def test_bdtrik_nbdtrik_inf():
      [100.0, 100.0, 0.1, 10.0, 1.0],
      [1.0, 0.1, 100.0, 10.0, 0.02926064279680897]]
 )
-def test_ncfdtr(dfn, dfd, nc, f, expected):
+def test_ncfdtr_ncfdtri(dfn, dfd, nc, f, expected_cdf):
     # Reference values computed with mpmath with the following script
     #
     # import numpy as np
@@ -549,10 +547,26 @@ def test_ncfdtr(dfn, dfd, nc, f, expected):
     # rng = np.random.default_rng(1234)
     # sample_idx = rng.choice(len(re), replace=False, size=12)
     # cases = np.array(cases)[sample_idx].tolist()
-    assert_allclose(sp.ncfdtr(dfn, dfd, nc, f), expected, rtol=1e-13, atol=0)
+    assert_allclose(sp.ncfdtr(dfn, dfd, nc, f), expected_cdf, rtol=1e-13, atol=0)
+    # testing tails where the CDF reaches 0 or 1 does not make sense for inverses
+    # of a CDF as they are not bijective in these regions
+    if 0 < expected_cdf < 1:
+        assert_allclose(sp.ncfdtri(dfn, dfd, nc, expected_cdf), f, rtol=5e-11)
 
+@pytest.mark.parametrize(
+    "args",
+    [(-1.0, 0.1, 0.1, 0.5),
+     (1, -1.0, 0.1, 0.5),
+     (1, 1, -1.0, 0.5),
+     (1, 1, 1, 100),
+     (1, 1, 1, -1)]
+)
+def test_ncfdtri_domain_error(args):
+    with sp.errstate(domain="raise"):
+        with pytest.raises(sp.SpecialFunctionError, match="domain"):
+            sp.ncfdtri(*args)
 
-class TestNctdtr:
+class TestNoncentralTFunctions:
 
     # Reference values computed with mpmath with the following script
     # Formula from:
@@ -592,7 +606,7 @@ class TestNctdtr:
     #         result = mp.one - f(df, -nc, x)
     #     return float(result)
 
-    @pytest.mark.parametrize("df, nc, x, expected", [
+    @pytest.mark.parametrize("df, nc, x, expected_cdf", [
         (0.98, -3.8, 0.0015, 0.9999279987514815),
         (0.98, -3.8, 0.15, 0.9999528361700505),
         (0.98, -3.8, 1.5, 0.9999908823016942),
@@ -660,13 +674,13 @@ class TestNctdtr:
                         reason="Bug in underlying Boost math implementation")),
         (980, 38, 15, 5.407535300713606e-105)
     ])
-    def test_gh19896(self, df, nc, x, expected):
+    def test_gh19896(self, df, nc, x, expected_cdf):
         # test that gh-19896 is resolved.
         # Originally this was a regression test that used the old Fortran results
         # as a reference. The Fortran results were not accurate, so the reference
         # values were recomputed with mpmath.
-        result = sp.nctdtr(df, nc, x)
-        assert_allclose(result, expected, rtol=1e-13, atol=1e-303)
+        nctdtr_result = sp.nctdtr(df, nc, x)
+        assert_allclose(nctdtr_result, expected_cdf, rtol=1e-13, atol=1e-303)
 
     def test_nctdtr_gh8344(self):
         # test that gh-8344 is resolved.
@@ -684,5 +698,15 @@ class TestNctdtr:
          [1., 1., -np.inf, 0.0, 0.0]
         ]
     )
-    def test_accuracy(self, df, nc, x, expected, rtol):
+    def test_nctdtr_accuracy(self, df, nc, x, expected, rtol):
         assert_allclose(sp.nctdtr(df, nc, x), expected, rtol=rtol)
+
+    @pytest.mark.parametrize("df, nc, x, expected_cdf", [
+        (0.98, 38, 1.5, 2.591995360483094e-97),
+        (3000, 3, 0.1, 0.0018657780826323328),
+        (0.98, -3.8, 15, 0.9999990264591945),
+        (9.8, 38, 15, 2.252076291604796e-09),
+
+    ])
+    def test_nctdtrit(self, df, nc, x, expected_cdf):
+        assert_allclose(sp.nctdtrit(df, nc, expected_cdf), x, rtol=1e-10)