scipy 1.15.3__cp313-cp313t-win_amd64.whl → 1.16.0rc2__cp313-cp313t-win_amd64.whl

scipy/stats/_unuran/unuran_wrapper.pyi

@@ -1,5 +1,6 @@
 import numpy as np
-from typing import (overload, Callable, NamedTuple, Protocol)
+from typing import (overload, NamedTuple, Protocol)
+from collections.abc import Callable
 import numpy.typing as npt
 from scipy._lib._util import SeedType
 import scipy.stats as stats

scipy/stats/_variation.py

@@ -1,13 +1,13 @@
 import numpy as np
 
 from scipy._lib._util import _get_nan
-from scipy._lib._array_api import array_namespace, xp_copysign
+from scipy._lib._array_api import array_namespace
 
 from ._axis_nan_policy import _axis_nan_policy_factory
 
 
 @_axis_nan_policy_factory(
-    lambda x: x, n_outputs=1, result_to_tuple=lambda x: (x,)
+    lambda x: x, n_outputs=1, result_to_tuple=lambda x, _: (x,)
 )
 def variation(a, axis=0, nan_policy='propagate', ddof=0, *, keepdims=False):
     """
@@ -103,22 +103,20 @@ def variation(a, axis=0, nan_policy='propagate', ddof=0, *, keepdims=False):
         axis = 0
 
     n = a.shape[axis]
-    NaN = _get_nan(a)
 
     if a.size == 0 or ddof > n:
         # Handle as a special case to avoid spurious warnings.
         # The return values, if any, are all nan.
-        shp = list(a.shape)
-        shp.pop(axis)
-        result = xp.full(shp, fill_value=NaN)
-        return result[()] if result.ndim == 0 else result
+        shape = list(a.shape)
+        shape.pop(axis)
+        return _get_nan(a, shape=tuple(shape), xp=xp)
 
     mean_a = xp.mean(a, axis=axis)
 
     if ddof == n:
         # Another special case.  Result is either inf or nan.
         std_a = xp.std(a, axis=axis, correction=0)
-        result = xp.where(std_a > 0, xp_copysign(xp.asarray(xp.inf), mean_a), NaN)
+        result = xp.where(std_a > 0, xp.copysign(xp.inf, mean_a), xp.nan)
         return result[()] if result.ndim == 0 else result
 
     with np.errstate(divide='ignore', invalid='ignore'):

scipy/stats/_wilcoxon.py

@@ -5,7 +5,8 @@ from ._stats_py import _get_pvalue, _rankdata, _SimpleNormal
 from . import _morestats
 from ._axis_nan_policy import _broadcast_arrays
 from ._hypotests import _get_wilcoxon_distr
-from scipy._lib._util import _lazywhere, _get_nan
+from scipy._lib._util import _get_nan
+import scipy._lib.array_api_extra as xpx
 
 
 class WilcoxonDistribution:
@@ -40,13 +41,17 @@ class WilcoxonDistribution:
 
     def cdf(self, k):
         k, mn, out = self._prep(k)
-        return _lazywhere(k <= mn, (k, self.n), self._cdf,
-                          f2=lambda k, n: 1 - self._sf(k+1, n))[()]
+        return xpx.apply_where(
+            k <= mn, (k, self.n),
+            self._cdf,
+            lambda k, n: 1 - self._sf(k+1, n))[()]
 
     def sf(self, k):
         k, mn, out = self._prep(k)
-        return _lazywhere(k <= mn, (k, self.n), self._sf,
-                          f2=lambda k, n: 1 - self._cdf(k-1, n))[()]
+        return xpx.apply_where(
+            k <= mn, (k, self.n),
+            self._sf,
+            lambda k, n: 1 - self._cdf(k-1, n))[()]
 
 
 def _wilcoxon_iv(x, y, zero_method, correction, alternative, method, axis):
@@ -57,6 +62,7 @@ def _wilcoxon_iv(x, y, zero_method, correction, alternative, method, axis):
         raise ValueError(message)
 
     message = '`axis` must be compatible with the shape(s) of `x` (and `y`)'
+    AxisError = getattr(np, 'AxisError', None) or np.exceptions.AxisError
     try:
         if y is None:
             x = np.asarray(x)
@@ -65,8 +71,8 @@ def _wilcoxon_iv(x, y, zero_method, correction, alternative, method, axis):
             x, y = _broadcast_arrays((x, y), axis=axis)
             d = x - y
         d = np.moveaxis(d, axis, -1)
-    except np.AxisError as e:
-        raise ValueError(message) from e
+    except AxisError as e:
+        raise AxisError(message) from e
 
     message = "`x` and `y` must have the same length along `axis`."
     if y is not None and x.shape[axis] != y.shape[axis]:

scipy/stats/tests/common_tests.py

@@ -344,11 +344,13 @@ def check_freezing(distfn, args):
 
 
 def check_rvs_broadcast(distfunc, distname, allargs, shape, shape_only, otype):
-    np.random.seed(123)
-    sample = distfunc.rvs(*allargs)
+    rng = np.random.RandomState(123)
+    sample = distfunc.rvs(*allargs, random_state=rng)
     assert_equal(sample.shape, shape, f"{distname}: rvs failed to broadcast")
     if not shape_only:
-        rvs = np.vectorize(lambda *allargs: distfunc.rvs(*allargs), otypes=otype)
-        np.random.seed(123)
+        rvs = np.vectorize(
+            lambda *allargs: distfunc.rvs(*allargs, random_state=rng),
+            otypes=otype)
+        rng = np.random.RandomState(123)
         expected = rvs(*allargs)
         assert_allclose(sample, expected, rtol=1e-13)

scipy/stats/tests/test_axis_nan_policy.py

@@ -56,11 +56,23 @@ def xp_var(*args, **kwargs):
     return stats._stats_py._xp_var(*args, **kwargs)
 
 
+def gstd(*args, **kwargs):
+    kwargs.pop('_no_deco', None)
+    return stats.gstd(*args, **kwargs)
+
+
 def combine_pvalues_weighted(*args, **kwargs):
     return stats.combine_pvalues(args[0], *args[2:], weights=args[1],
                                  method='stouffer', **kwargs)
 
 
+def weightedtau_weighted(x, y, rank, **kwargs):
+    axis = kwargs.get('axis', 0)
+    nan_policy = kwargs.get('nan_policy', 'propagate')
+    rank = stats.rankdata(rank, axis=axis, nan_policy=nan_policy)
+    return stats.weightedtau(x, y, rank, **kwargs)
+
+
 axis_nan_policy_cases = [
     # function, args, kwds, number of samples, number of outputs,
     # ... paired, unpacker function
@@ -133,6 +145,7 @@ axis_nan_policy_cases = [
     (stats.circvar, tuple(), dict(), 1, 1, False, lambda x: (x,)),
     (stats.circstd, tuple(), dict(), 1, 1, False, lambda x: (x,)),
     (stats.f_oneway, tuple(), {}, 2, 2, False, None),
+    (stats.f_oneway, tuple(), {'equal_var': False}, 2, 2, False, None),
     (stats.alexandergovern, tuple(), {}, 2, 2, False,
      lambda res: (res.statistic, res.pvalue)),
     (stats.combine_pvalues, tuple(), {}, 1, 2, False, None),
@@ -143,6 +156,24 @@ axis_nan_policy_cases = [
     (xp_var, tuple(), dict(), 1, 1, False, lambda x: (x,)),
     (stats.chatterjeexi, tuple(), dict(), 2, 2, True,
      lambda res: (res.statistic, res.pvalue)),
+    (stats.pointbiserialr, tuple(), dict(), 2, 3, True,
+     lambda res: (res.statistic, res.pvalue, res.correlation)),
+    (stats.kendalltau, tuple(), dict(), 2, 3, True,
+     lambda res: (res.statistic, res.pvalue, res.correlation)),
+    (stats.weightedtau, tuple(), dict(), 2, 3, True,
+     lambda res: (res.statistic, res.pvalue, res.correlation)),
+    (weightedtau_weighted, tuple(), dict(), 3, 3, True,
+     lambda res: (res.statistic, res.pvalue, res.correlation)),
+    (stats.linregress, tuple(), dict(), 2, 6, True,
+     lambda res: tuple(res) + (res.intercept_stderr,)),
+    (stats.theilslopes, tuple(), dict(), 2, 4, True, tuple),
+    (stats.theilslopes, tuple(), dict(), 1, 4, True, tuple),
+    (stats.siegelslopes, tuple(), dict(), 2, 2, True, tuple),
+    (stats.siegelslopes, tuple(), dict(), 1, 2, True, tuple),
+    (gstd, tuple(), dict(), 1, 1, False, lambda x: (x,)),
+    (stats.power_divergence, tuple(), dict(), 1, 2, False, None),
+    (stats.chisquare, tuple(), dict(), 1, 2, False, None),
+    (stats._morestats._boxcox_llf, tuple(), dict(lmb=1.5), 1, 1, False, lambda x: (x,)),
 ]
 
 # If the message is one of those expected, put nans in
@@ -175,6 +206,9 @@ too_small_messages = {"Degrees of freedom <= 0 for slice",
                       "One or more sample arguments is too small",
                       "invalid value encountered",
                       "divide by zero encountered",
+                      "`x` and `y` must have length at least 2.",
+                      "Inputs must not be empty.",
+                      "All `x` coordinates are identical.",
 }
 
 # If the message is one of these, results of the function may be inaccurate,
@@ -183,13 +217,13 @@ inaccuracy_messages = {"Precision loss occurred in moment calculation",
                        "Sample size too small for normal approximation."}
 
 # For some functions, nan_policy='propagate' should not just return NaNs
-override_propagate_funcs = {stats.mode}
+override_propagate_funcs = {stats.mode, weightedtau_weighted, stats.weightedtau}
 
 # For some functions, empty arrays produce non-NaN results
-empty_special_case_funcs = {stats.entropy}
+empty_special_case_funcs = {stats.entropy, stats.chisquare, stats.power_divergence}
 
 # Some functions don't follow the usual "too small" warning rules
-too_small_special_case_funcs = {stats.entropy}
+too_small_special_case_funcs = {stats.entropy, stats.chisquare, stats.power_divergence}
 
 def _mixed_data_generator(n_samples, n_repetitions, axis, rng,
                           paired=False):
@@ -301,6 +335,7 @@ def nan_policy_1d(hypotest, data1d, unpacker, *args, n_outputs=2,
 @pytest.mark.parametrize(("nan_policy"), ("propagate", "omit", "raise"))
 @pytest.mark.parametrize(("axis"), (1,))
 @pytest.mark.parametrize(("data_generator"), ("mixed",))
+@pytest.mark.parallel_threads(1)
 def test_axis_nan_policy_fast(hypotest, args, kwds, n_samples, n_outputs,
                               paired, unpacker, nan_policy, axis,
                               data_generator):
@@ -413,7 +448,7 @@ def _axis_nan_policy_test(hypotest, args, kwds, n_samples, n_outputs, paired,
                                     n_outputs=n_outputs,
                                     nan_policy=nan_policy,
                                     paired=paired, _no_deco=True, **kwds)
-        except (ValueError, RuntimeWarning, ZeroDivisionError) as ea:
+        except (ValueError, RuntimeWarning, ZeroDivisionError, UserWarning) as ea:
             ea_str = str(ea)
             if any([str(ea_str).startswith(msg) for msg in too_small_messages]):
                 res_1da = np.full(n_outputs, np.nan)
@@ -472,6 +507,7 @@ def _axis_nan_policy_test(hypotest, args, kwds, n_samples, n_outputs, paired,
 @pytest.mark.parametrize(("nan_policy"), ("propagate", "omit", "raise"))
 @pytest.mark.parametrize(("data_generator"),
                          ("all_nans", "all_finite", "mixed", "empty"))
+@pytest.mark.parallel_threads(1)
 def test_axis_nan_policy_axis_is_None(hypotest, args, kwds, n_samples,
                                       n_outputs, paired, unpacker, nan_policy,
                                       data_generator):
@@ -524,7 +560,7 @@ def test_axis_nan_policy_axis_is_None(hypotest, args, kwds, n_samples,
             res1da = nan_policy_1d(hypotest, data_raveled, unpacker, *args,
                                    n_outputs=n_outputs, nan_policy=nan_policy,
                                    paired=paired, _no_deco=True, **kwds)
-        except (RuntimeWarning, ValueError, ZeroDivisionError) as ea:
+        except (RuntimeWarning, ValueError, ZeroDivisionError, UserWarning) as ea:
             res1da = None
             ea_str = str(ea)
 
@@ -594,6 +630,8 @@ def test_keepdims(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker,
                            stats.differential_entropy}
     if sample_shape == (2, 3, 3, 4) and hypotest in small_sample_raises:
         pytest.skip("Sample too small; test raises error.")
+    if hypotest in {weightedtau_weighted}:
+        pytest.skip("`rankdata` used in testing doesn't support axis tuple.")
     # test if keepdims parameter works correctly
     if not unpacker:
         def unpacker(res):
@@ -787,6 +825,7 @@ def _check_arrays_broadcastable(arrays, axis):
 @pytest.mark.slow
 @pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
                           "paired", "unpacker"), axis_nan_policy_cases)
+@pytest.mark.parallel_threads(1)
 def test_empty(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker):
     # test for correct output shape when at least one input is empty
     if hypotest in {stats.kruskal, stats.friedmanchisquare} and not SCIPY_XSLOW:
@@ -834,15 +873,16 @@ def test_empty(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker):
                     sup.filter(RuntimeWarning, "Mean of empty slice.")
                     sup.filter(RuntimeWarning, "invalid value encountered")
                     expected = np.mean(concat, axis=axis) * np.nan
+                    mask = np.isnan(expected)
+                    expected = [np.asarray(expected.copy()) for i in range(n_outputs)]
 
                 if hypotest in empty_special_case_funcs:
                     empty_val = hypotest(*([[]]*len(samples)), *args, **kwds)
-                    expected = np.asarray(expected)
-                    mask = np.isnan(expected)
-                    expected[mask] = empty_val
-                    expected = expected[()]
+                    empty_val = list(unpacker(empty_val))
+                    for i in range(n_outputs):
+                        expected[i][mask] = empty_val[i]
 
-                if expected.size and hypotest not in too_small_special_case_funcs:
+                if expected[0].size and hypotest not in too_small_special_case_funcs:
                     message = (too_small_1d_not_omit if max_axis == 1
                                else too_small_nd_not_omit)
                     with pytest.warns(SmallSampleWarning, match=message):
@@ -855,7 +895,7 @@ def test_empty(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker):
                 res = unpacker(res)
 
                 for i in range(n_outputs):
-                    assert_equal(res[i], expected)
+                    assert_equal(res[i], expected[i])
 
             except ValueError:
                 # confirm that the arrays truly are not broadcastable
@@ -872,22 +912,21 @@ def test_empty(hypotest, args, kwds, n_samples, n_outputs, paired, unpacker):
 
 
 def paired_non_broadcastable_cases():
-    rng = np.random.default_rng(91359824598245)
     for case in axis_nan_policy_cases:
         hypotest, args, kwds, n_samples, n_outputs, paired, unpacker = case
         if n_samples == 1:  # broadcasting only needed with >1 sample
             continue
-        yield case + (rng,)
+        yield case
 
 
 @pytest.mark.parametrize("axis", [0, 1])
 @pytest.mark.parametrize(("hypotest", "args", "kwds", "n_samples", "n_outputs",
-                          "paired", "unpacker", "rng"),
+                          "paired", "unpacker"),
                          paired_non_broadcastable_cases())
 def test_non_broadcastable(hypotest, args, kwds, n_samples, n_outputs, paired,
-                           unpacker, rng, axis):
+                           unpacker, axis):
     # test for correct error message when shapes are not broadcastable
-
+    rng = np.random.default_rng(91359824598245)
     get_samples = True
     while get_samples:
         samples = [rng.random(size=rng.integers(2, 100, size=2))
@@ -913,7 +952,6 @@ def test_non_broadcastable(hypotest, args, kwds, n_samples, n_outputs, paired,
     with pytest.raises(ValueError, match=message):
         hypotest(other_sample, *most_samples, *args, **kwds)
 
-
 def test_masked_array_2_sentinel_array():
     # prepare arrays
     np.random.seed(0)
@@ -1078,13 +1116,13 @@ def test_mixed_mask_nan_1():
     m, n = 3, 20
     axis = -1
 
-    np.random.seed(0)
-    a = np.random.rand(m, n)
-    b = np.random.rand(m, n)
-    mask_a1 = np.random.rand(m, n) < 0.2
-    mask_a2 = np.random.rand(m, n) < 0.1
-    mask_b1 = np.random.rand(m, n) < 0.15
-    mask_b2 = np.random.rand(m, n) < 0.15
+    rng = np.random.RandomState(0)
+    a = rng.rand(m, n)
+    b = rng.rand(m, n)
+    mask_a1 = rng.rand(m, n) < 0.2
+    mask_a2 = rng.rand(m, n) < 0.1
+    mask_b1 = rng.rand(m, n) < 0.15
+    mask_b2 = rng.rand(m, n) < 0.15
     mask_a1[2, :] = True
 
     a_nans = a.copy()

scipy/stats/tests/test_continued_fraction.py

@@ -0,0 +1,173 @@
+import math
+
+import pytest
+import numpy as np
+
+from scipy._lib._array_api import array_namespace
+from scipy._lib._array_api_no_0d import xp_assert_close, xp_assert_less, xp_assert_equal
+from scipy.stats._continued_fraction import _continued_fraction
+
+
+@pytest.mark.skip_xp_backends('array_api_strict', reason='No fancy indexing assignment')
+@pytest.mark.skip_xp_backends('jax.numpy', reason="Don't support mutation")
+# dask doesn't like lines like this
+# n = int(xp.real(xp_ravel(n))[0])
+# (at some point in here the shape becomes nan)
+@pytest.mark.skip_xp_backends('dask.array', reason="dask has issues with the shapes")
+class TestContinuedFraction:
+    rng = np.random.default_rng(5895448232066142650)
+    p = rng.uniform(1, 10, size=10)
+
+    def a1(self, n, x=1.5):
+        if n == 0:
+            y = 0*x
+        elif n == 1:
+            y = x
+        else:
+            y = -x**2
+        if np.isscalar(y) and np.__version__ < "2.0":
+            y = np.full_like(x, y)  # preserve dtype pre NEP 50
+        return y
+
+    def b1(self, n, x=1.5):
+        if n == 0:
+            y = 0*x
+        else:
+            one = x/x  # gets array of correct type, dtype, and shape
+            y = one * (2*n - 1)
+        if np.isscalar(y) and np.__version__ < "2.0":
+            y = np.full_like(x, y)  # preserve dtype pre NEP 50
+        return y
+
+    def log_a1(self, n, x):
+        xp = array_namespace(x)
+        if n == 0:
+            y = xp.full_like(x, -xp.asarray(math.inf, dtype=x.dtype))
+        elif n == 1:
+            y = xp.log(x)
+        else:
+            y = 2 * xp.log(x) + math.pi * 1j
+        return y
+
+    def log_b1(self, n, x):
+        xp = array_namespace(x)
+        if n == 0:
+            y = xp.full_like(x, -xp.asarray(math.inf, dtype=x.dtype))
+        else:
+            one = x - x  # gets array of correct type, dtype, and shape
+            y = one + math.log(2 * n - 1)
+        return y
+
+    def test_input_validation(self, xp):
+        a1 = self.a1
+        b1 = self.b1
+
+        message = '`a` and `b` must be callable.'
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(1, b1)
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, 1)
+
+        message = r'`eps` and `tiny` must be \(or represent the logarithm of\)...'
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, tolerances={'eps': -10})
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, tolerances={'eps': np.nan})
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, tolerances={'eps': 1+1j}, log=True)
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, tolerances={'tiny': 0})
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, tolerances={'tiny': np.inf})
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, tolerances={'tiny': np.inf}, log=True)
+        # this should not raise
+        kwargs = dict(args=xp.asarray(1.5+0j), log=True, maxiter=0)
+        _continued_fraction(a1, b1, tolerances={'eps': -10}, **kwargs)
+        _continued_fraction(a1, b1, tolerances={'tiny': -10}, **kwargs)
+
+        message = '`maxiter` must be a non-negative integer.'
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, maxiter=-1)
+
+        message = '`log` must be boolean.'
+        with pytest.raises(ValueError, match=message):
+            _continued_fraction(a1, b1, log=2)
+
+    @pytest.mark.parametrize('dtype', ['float32', 'float64', 'complex64', 'complex128'])
+    @pytest.mark.parametrize('shape', [(), (1,), (3,), (3, 2)])
+    def test_basic(self, shape, dtype, xp):
+        np_dtype = getattr(np, dtype)
+        xp_dtype = getattr(xp, dtype)
+        rng = np.random.default_rng(2435908729190400)
+
+        x = rng.random(shape).astype(np_dtype)
+        x = x + rng.random(shape).astype(np_dtype)*1j if dtype.startswith('c') else x
+        x = xp.asarray(x, dtype=xp_dtype)
+
+        res = _continued_fraction(self.a1, self.b1, args=(x,))
+        ref = xp.tan(x)
+        xp_assert_close(res.f, ref)
+
+    @pytest.mark.skip_xp_backends('torch', reason='pytorch/pytorch#136063')
+    @pytest.mark.parametrize('dtype', ['float32', 'float64'])
+    @pytest.mark.parametrize('shape', [(), (1,), (3,), (3, 2)])
+    def test_log(self, shape, dtype, xp):
+        if (np.__version__ < "2") and (dtype == 'float32'):
+            pytest.skip("Scalar dtypes only respected after NEP 50.")
+        np_dtype = getattr(np, dtype)
+        rng = np.random.default_rng(2435908729190400)
+        x = rng.random(shape).astype(np_dtype)
+        x = xp.asarray(x)
+
+        res = _continued_fraction(self.log_a1, self.log_b1, args=(x + 0j,), log=True)
+        ref = xp.tan(x)
+        xp_assert_close(xp.exp(xp.real(res.f)), ref)
+
+    def test_maxiter(self, xp):
+        rng = np.random.default_rng(2435908729190400)
+        x = xp.asarray(rng.random(), dtype=xp.float64)
+        ref = xp.tan(x)
+
+        res1 = _continued_fraction(self.a1, self.b1, args=(x,), maxiter=3)
+        assert res1.nit == 3
+
+        res2 = _continued_fraction(self.a1, self.b1, args=(x,), maxiter=6)
+        assert res2.nit == 6
+
+        xp_assert_less(xp.abs(res2.f - ref), xp.abs(res1.f - ref))
+
+    def test_eps(self, xp):
+        x = xp.asarray(1.5, dtype=xp.float64)  # x = 1.5 is the default defined above
+        ref = xp.tan(x)
+        res1 = _continued_fraction(self.a1, self.b1, args=(x,),
+                                   tolerances={'eps': 1e-6})
+        res2 = _continued_fraction(self.a1, self.b1, args=(x,))
+        xp_assert_less(res1.nit, res2.nit)
+        xp_assert_less(xp.abs(res2.f - ref), xp.abs(res1.f - ref))
+
+    def test_feval(self, xp):
+        def a(n, x):
+            a.nfev += 1
+            return n * x
+
+        def b(n, x):
+            b.nfev += 1
+            return n * x
+
+        a.nfev, b.nfev = 0, 0
+
+        res = _continued_fraction(a, b, args=(xp.asarray(1.),))
+        assert res.nfev == a.nfev == b.nfev == res.nit + 1
+
+    def test_status(self, xp):
+        x = xp.asarray([1, 10, np.nan], dtype=xp.float64)
+        res = _continued_fraction(self.a1, self.b1, args=(x,), maxiter=15)
+        xp_assert_equal(res.success, xp.asarray([True, False, False]))
+        xp_assert_equal(res.status, xp.asarray([0, -2, -3], dtype=xp.int32))
+
+    def test_special_cases(self, xp):
+        one = xp.asarray(1)
+        res = _continued_fraction(lambda x: one, lambda x: one, maxiter=0)
+        xp_assert_close(res.f, xp.asarray(1.))
+        assert res.nit == res.nfev - 1 == 0