Merge pull request scipy#20588 from j-bowhay/comb_dep

Author: lucascolley

scipy/special/_basic.py

@@ -18,7 +18,6 @@
                        _sph_harm_all as _sph_harm_all_gufunc)
 from . import _specfun
 from ._comb import _comb_int
-from scipy._lib.deprecation import _NoValue, _deprecate_positional_args
 
 
 __all__ = [
@@ -2679,8 +2678,7 @@ def obl_cv_seq(m, n, c):
     return _specfun.segv(m, n, c, -1)[1][:maxL]
 
 
-@_deprecate_positional_args(version="1.14")
-def comb(N, k, *, exact=False, repetition=False, legacy=_NoValue):
+def comb(N, k, *, exact=False, repetition=False):
     """The number of combinations of N things taken k at a time.
 
     This is often expressed as "N choose k".
@@ -2693,21 +2691,10 @@ def comb(N, k, *, exact=False, repetition=False, legacy=_NoValue):
         Number of elements taken.
     exact : bool, optional
         For integers, if `exact` is False, then floating point precision is
-        used, otherwise the result is computed exactly. For non-integers, if
-        `exact` is True, is disregarded.
+        used, otherwise the result is computed exactly.
     repetition : bool, optional
         If `repetition` is True, then the number of combinations with
         repetition is computed.
-    legacy : bool, optional
-        If `legacy` is True and `exact` is True, then non-integral arguments
-        are cast to ints; if `legacy` is False, the result for non-integral
-        arguments is unaffected by the value of `exact`.
-
-        .. deprecated:: 1.9.0
-            Using `legacy` is deprecated and will removed by
-            Scipy 1.14.0. If you want to keep the legacy behaviour, cast
-            your inputs directly, e.g.
-            ``comb(int(your_N), int(your_k), exact=True)``.
 
     Returns
     -------
@@ -2739,25 +2726,12 @@ def comb(N, k, *, exact=False, repetition=False, legacy=_NoValue):
     220
 
     """
-    if legacy is not _NoValue:
-        warnings.warn(
-            "Using 'legacy' keyword is deprecated and will be removed by "
-            "Scipy 1.14.0. If you want to keep the legacy behaviour, cast "
-            "your inputs directly, e.g. "
-            "'comb(int(your_N), int(your_k), exact=True)'.",
-            DeprecationWarning,
-            stacklevel=2
-        )
     if repetition:
-        return comb(N + k - 1, k, exact=exact, legacy=legacy)
+        return comb(N + k - 1, k, exact=exact)
     if exact:
         if int(N) == N and int(k) == k:
             # _comb_int casts inputs to integers, which is safe & intended here
             return _comb_int(N, k)
-        elif legacy:
-            # here at least one number is not an integer; legacy behavior uses
-            # lossy casts to int
-            return _comb_int(N, k)
         # otherwise, we disregard `exact=True`; it makes no sense for
         # non-integral arguments
         return comb(N, k)

scipy/special/_special_ufuncs_docs.cpp

@@ -398,16 +398,16 @@ const char *binom_doc = R"(
     ``y`` is negative or ``x`` is less than ``y``.
 
     >>> x, y = -3, 2
-    >>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
-    (nan, 0.0, 0)
+    >>> (binom(x, y), comb(x, y))
+    (nan, 0.0)
 
     >>> x, y = -3.1, 2.2
-    >>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
-    (18.714147876804432, 0.0, 0)
+    >>> (binom(x, y), comb(x, y))
+    (18.714147876804432, 0.0)
 
     >>> x, y = 2.2, 3.1
-    >>> (binom(x, y), comb(x, y), comb(x, y, exact=True))
-    (0.037399983365134115, 0.0, 0)
+    >>> (binom(x, y), comb(x, y))
+    (0.037399983365134115, 0.0)
     )";
 
 const char *exp1_doc = R"(

scipy/special/tests/test_basic.py

@@ -40,7 +40,6 @@
 from scipy.special import ellipe, ellipk, ellipkm1
 from scipy.special import elliprc, elliprd, elliprf, elliprg, elliprj
 from scipy.special import mathieu_odd_coef, mathieu_even_coef, stirling2
-from scipy._lib.deprecation import _NoValue
 from scipy._lib._util import np_long, np_ulong
 
 from scipy.special._basic import _FACTORIALK_LIMITS_64BITS, \
@@ -1429,8 +1428,8 @@ def test_betainc_domain_errors(self, func, args):
 
 class TestCombinatorics:
     def test_comb(self):
-        assert_array_almost_equal(special.comb([10, 10], [3, 4]), [120., 210.])
-        assert_almost_equal(special.comb(10, 3), 120.)
+        assert_allclose(special.comb([10, 10], [3, 4]), [120., 210.])
+        assert_allclose(special.comb(10, 3), 120.)
         assert_equal(special.comb(10, 3, exact=True), 120)
         assert_equal(special.comb(10, 3, exact=True, repetition=True), 220)
 
@@ -1443,39 +1442,6 @@ def test_comb(self):
         expected = 100891344545564193334812497256
         assert special.comb(100, 50, exact=True) == expected
 
-    @pytest.mark.parametrize("repetition", [True, False])
-    @pytest.mark.parametrize("legacy", [True, False, _NoValue])
-    @pytest.mark.parametrize("k", [3.5, 3])
-    @pytest.mark.parametrize("N", [4.5, 4])
-    def test_comb_legacy(self, N, k, legacy, repetition):
-        # test is only relevant for exact=True
-        if legacy is not _NoValue:
-            with pytest.warns(
-                DeprecationWarning,
-                match=r"Using 'legacy' keyword is deprecated"
-            ):
-                result = special.comb(N, k, exact=True, legacy=legacy,
-                                      repetition=repetition)
-        else:
-            result = special.comb(N, k, exact=True, legacy=legacy,
-                                  repetition=repetition)
-        if legacy:
-            # for exact=True and legacy=True, cast input arguments, else don't
-            if repetition:
-                # the casting in legacy mode happens AFTER transforming N & k,
-                # so rounding can change (e.g. both floats, but sum to int);
-                # hence we need to emulate the repetition-transformation here
-                N, k = int(N + k - 1), int(k)
-                repetition = False
-            else:
-                N, k = int(N), int(k)
-        # expected result is the same as with exact=False
-        with suppress_warnings() as sup:
-            if legacy is not _NoValue:
-                sup.filter(DeprecationWarning)
-            expected = special.comb(N, k, legacy=legacy, repetition=repetition)
-        assert_equal(result, expected)
-
     def test_comb_with_np_int64(self):
         n = 70
         k = 30
@@ -1490,11 +1456,10 @@ def test_comb_zeros(self):
         assert_equal(special.comb(-1, 3, exact=True), 0)
         assert_equal(special.comb(2, -1, exact=True), 0)
         assert_equal(special.comb(2, -1, exact=False), 0)
-        assert_array_almost_equal(special.comb([2, -1, 2, 10], [3, 3, -1, 3]),
-                [0., 0., 0., 120.])
+        assert_allclose(special.comb([2, -1, 2, 10], [3, 3, -1, 3]), [0., 0., 0., 120.])
 
     def test_perm(self):
-        assert_array_almost_equal(special.perm([10, 10], [3, 4]), [720., 5040.])
+        assert_allclose(special.perm([10, 10], [3, 4]), [720., 5040.])
         assert_almost_equal(special.perm(10, 3), 720.)
         assert_equal(special.perm(10, 3, exact=True), 720)
 
@@ -1503,14 +1468,8 @@ def test_perm_zeros(self):
         assert_equal(special.perm(-1, 3, exact=True), 0)
         assert_equal(special.perm(2, -1, exact=True), 0)
         assert_equal(special.perm(2, -1, exact=False), 0)
-        assert_array_almost_equal(special.perm([2, -1, 2, 10], [3, 3, -1, 3]),
-                [0., 0., 0., 720.])
-
-    def test_positional_deprecation(self):
-        with pytest.deprecated_call(match="use keyword arguments"):
-            # from test_comb
-            special.comb([10, 10], [3, 4], False, False)
-
+        assert_allclose(special.perm([2, -1, 2, 10], [3, 3, -1, 3]), [0., 0., 0., 720.])
+    
 
 class TestTrigonometric:
     def test_cbrt(self):