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

scipy/stats/tests/test_qmc.py

@@ -4,7 +4,7 @@ from itertools import combinations, product
 
 import pytest
 import numpy as np
-from numpy.testing import (assert_allclose, assert_equal, assert_array_equal, 
+from numpy.testing import (assert_allclose, assert_equal, assert_array_equal,
     assert_array_less)
 
 from scipy.spatial import distance
@@ -144,6 +144,7 @@ class TestUtils:
         with pytest.raises(ValueError, match=r"'toto' is not a valid ..."):
             qmc.discrepancy(sample, method="toto")
 
+    @pytest.mark.thread_unsafe
     def test_discrepancy_parallel(self, monkeypatch):
         sample = np.array([[2, 1, 1, 2, 2, 2],
                            [1, 2, 2, 2, 2, 2],
@@ -228,6 +229,7 @@ class TestUtils:
             reason="minimum_spanning_tree ignores zero distances (#18892)",
             strict=True,
     )
+    @pytest.mark.thread_unsafe
     def test_geometric_discrepancy_mst_with_zero_distances(self):
         sample = np.array([[0, 0], [0, 0], [0, 1]])
         assert_allclose(qmc.geometric_discrepancy(sample, method='mst'), 0.5)
@@ -600,6 +602,7 @@ class QMCEngineTests:
             None,
         ),
     )
+    @pytest.mark.thread_unsafe
     def test_reset(self, scramble, rng):
         engine = self.engine(d=2, scramble=scramble, rng=rng)
         ref_sample = engine.random(n=8)
@@ -951,8 +954,8 @@ class TestPoisson(QMCEngineTests):
         sample = engine.random(30)
 
         for point in sample:
-            assert_array_less(point, u_bounds) 
-            assert_array_less(l_bounds, point) 
+            assert_array_less(point, u_bounds)
+            assert_array_less(l_bounds, point)
 
     @pytest.mark.parametrize("u_bounds", [[-1, -2, -1], [1, 2, 1]])
     def test_sample_inside_upper_bounds(self, u_bounds):
@@ -964,15 +967,15 @@ class TestPoisson(QMCEngineTests):
         sample = engine.random(30)
 
         for point in sample:
-            assert_array_less(point, u_bounds) 
-            assert_array_less(l_bounds, point) 
+            assert_array_less(point, u_bounds)
+            assert_array_less(l_bounds, point)
 
     def test_inconsistent_bound_value(self):
         radius = 0.2
         l_bounds=[3, 2, 1]
         u_bounds=[-1, -2, -1]
         with pytest.raises(
-            ValueError, 
+            ValueError,
             match="Bounds are not consistent 'l_bounds' < 'u_bounds'"):
             self.qmce(d=3, radius=radius, l_bounds=l_bounds, u_bounds=u_bounds)
 
@@ -981,14 +984,14 @@ class TestPoisson(QMCEngineTests):
     def test_inconsistent_bounds(self, u_bounds, l_bounds):
         radius = 0.2
         with pytest.raises(
-            ValueError, 
-            match="'l_bounds' and 'u_bounds' must be broadcastable and respect" 
+            ValueError,
+            match="'l_bounds' and 'u_bounds' must be broadcastable and respect"
             " the sample dimension"):
             self.qmce(
-                d=3, radius=radius, 
+                d=3, radius=radius,
                 l_bounds=l_bounds, u_bounds=u_bounds
             )
-        
+
     def test_raises(self):
         message = r"'toto' is not a valid hypersphere sampling"
         with pytest.raises(ValueError, match=message):

scipy/stats/tests/test_quantile.py

@@ -0,0 +1,199 @@
+import pytest
+import numpy as np
+
+from scipy import stats
+from scipy._lib._array_api import xp_default_dtype, is_numpy, is_torch, SCIPY_ARRAY_API
+from scipy._lib._array_api_no_0d import xp_assert_close, xp_assert_equal
+from scipy._lib._util import _apply_over_batch
+
+skip_xp_backends = pytest.mark.skip_xp_backends
+
+
+@_apply_over_batch(('x', 1), ('p', 1))
+def quantile_reference_last_axis(x, p, nan_policy, method):
+    if nan_policy == 'omit':
+        x = x[~np.isnan(x)]
+    p_mask = np.isnan(p)
+    p = p.copy()
+    p[p_mask] = 0.5
+    if method == 'harrell-davis':
+        # hdquantiles returns masked element if length along axis is 1 (bug)
+        res = (np.full_like(p, x[0]) if x.size == 1
+               else stats.mstats.hdquantiles(x, p).data)
+        if nan_policy == 'propagate' and np.any(np.isnan(x)):
+            res[:] = np.nan
+    else:
+        res = np.quantile(x, p)
+    res[p_mask] = np.nan
+    return res
+
+
+def quantile_reference(x, p, *, axis, nan_policy, keepdims, method):
+    x, p = np.moveaxis(x, axis, -1), np.moveaxis(p, axis, -1)
+    res = quantile_reference_last_axis(x, p, nan_policy, method)
+    res = np.moveaxis(res, -1, axis)
+    if not keepdims:
+        res = np.squeeze(res, axis=axis)
+    return res
+
+
+@skip_xp_backends('dask.array', reason="No take_along_axis yet.")
+@skip_xp_backends('jax.numpy', reason="No mutation.")
+class TestQuantile:
+
+    def test_input_validation(self, xp):
+        x = xp.asarray([1, 2, 3])
+        p = xp.asarray(0.5)
+
+        message = "`x` must have real dtype."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(xp.asarray([True, False]), p)
+        with pytest.raises(ValueError):
+            stats.quantile(xp.asarray([1+1j, 2]), p)
+
+        message = "`p` must have real floating dtype."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, xp.asarray([0, 1]))
+
+        message = "`axis` must be an integer or None."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, p, axis=0.5)
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, p, axis=(0, -1))
+
+        message = "`axis` is not compatible with the shapes of the inputs."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, p, axis=2)
+
+        message = "The input contains nan values"
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(xp.asarray([xp.nan, 1, 2]), p, nan_policy='raise')
+
+        message = "method` must be one of..."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, p, method='a duck')
+
+        message = "If specified, `keepdims` must be True or False."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, p, keepdims=42)
+
+        message = "`keepdims` may be False only if the length of `p` along `axis` is 1."
+        with pytest.raises(ValueError, match=message):
+            stats.quantile(x, xp.asarray([0.5, 0.6]), keepdims=False)
+
+    @pytest.mark.parametrize('method',
+         ['inverted_cdf', 'averaged_inverted_cdf', 'closest_observation',
+          'hazen', 'interpolated_inverted_cdf', 'linear',
+          'median_unbiased', 'normal_unbiased', 'weibull'])
+    @pytest.mark.parametrize('shape_x, shape_p, axis',
+         [(10, None, -1), (10, 10, -1), (10, (2, 3), -1),
+          ((10, 2), None, 0), ((10, 2), None, 0),])
+    def test_against_numpy(self, method, shape_x, shape_p, axis, xp):
+        dtype = xp_default_dtype(xp)
+        rng = np.random.default_rng(23458924568734956)
+        x = rng.random(size=shape_x)
+        p = rng.random(size=shape_p)
+        ref = np.quantile(x, p, method=method, axis=axis)
+
+        x, p = xp.asarray(x, dtype=dtype), xp.asarray(p, dtype=dtype)
+        res = stats.quantile(x, p, method=method, axis=axis)
+
+        xp_assert_close(res, xp.asarray(ref, dtype=dtype))
+
+    @skip_xp_backends(cpu_only=True, reason="PyTorch doesn't have `betainc`.")
+    @pytest.mark.parametrize('axis', [0, 1])
+    @pytest.mark.parametrize('keepdims', [False, True])
+    @pytest.mark.parametrize('nan_policy', ['omit', 'propagate', 'marray'])
+    @pytest.mark.parametrize('dtype', ['float32', 'float64'])
+    @pytest.mark.parametrize('method', ['linear', 'harrell-davis'])
+    def test_against_reference(self, axis, keepdims, nan_policy, dtype, method, xp):
+        rng = np.random.default_rng(23458924568734956)
+        shape = (5, 6)
+        x = rng.random(size=shape).astype(dtype)
+        p = rng.random(size=shape).astype(dtype)
+        mask = rng.random(size=shape) > 0.8
+        assert np.any(mask)
+        x[mask] = np.nan
+        if not keepdims:
+            p = np.mean(p, axis=axis, keepdims=True)
+
+        # inject p = 0 and p = 1 to test edge cases
+        # Currently would fail with CuPy/JAX (cupy/cupy#8934, jax-ml/jax#21900);
+        # remove the `if` when those are resolved.
+        if is_numpy(xp):
+            p0 = p.ravel()
+            p0[1] = 0.
+            p0[-2] = 1.
+
+        dtype = getattr(xp, dtype)
+
+        if nan_policy == 'marray':
+            if method == 'harrell-davis':
+                pytest.skip("Needs gh-22490")
+            if is_torch(xp):
+                pytest.skip("sum_cpu not implemented for UInt64, see "
+                            "data-apis/array-api-compat#242")
+            if not SCIPY_ARRAY_API:
+                pytest.skip("MArray is only available if SCIPY_ARRAY_API=1")
+            marray = pytest.importorskip('marray')
+            kwargs = dict(axis=axis, keepdims=keepdims, method=method)
+            mxp = marray._get_namespace(xp)
+            x_mp = mxp.asarray(x, mask=mask)
+            res = stats.quantile(x_mp, mxp.asarray(p), **kwargs)
+            ref = quantile_reference(x, p, nan_policy='omit', **kwargs)
+            xp_assert_close(res.data, xp.asarray(ref, dtype=dtype))
+            return
+
+        kwargs = dict(axis=axis, keepdims=keepdims,
+                      nan_policy=nan_policy, method=method)
+        res = stats.quantile(xp.asarray(x), xp.asarray(p), **kwargs)
+        ref = quantile_reference(x, p, **kwargs)
+        xp_assert_close(res, xp.asarray(ref, dtype=dtype))
+
+    def test_integer_input_output_dtype(self, xp):
+        res = stats.quantile(xp.arange(10, dtype=xp.int64), 0.5)
+        assert res.dtype == xp_default_dtype(xp)
+
+    @pytest.mark.parametrize('x, p, ref, kwargs',
+        [([], 0.5, np.nan, {}),
+         ([1, 2, 3], [-1, 0, 1, 1.5, np.nan], [np.nan, 1, 3, np.nan, np.nan], {}),
+         ([1, 2, 3], [], [], {}),
+         ([[np.nan, 2]], 0.5, [np.nan, 2], {'nan_policy': 'omit'}),
+         ([[], []], 0.5, np.full(2, np.nan), {'axis': -1}),
+         ([[], []], 0.5, np.zeros((0,)), {'axis': 0, 'keepdims': False}),
+         ([[], []], 0.5, np.zeros((1, 0)), {'axis': 0, 'keepdims': True}),
+         ([], [0.5, 0.6], np.full(2, np.nan), {}),
+         (np.arange(1, 28).reshape((3, 3, 3)), 0.5, [[[14.]]],
+          {'axis': None, 'keepdims': True}),
+         ([[1, 2], [3, 4]], [0.25, 0.5, 0.75], [[1.75, 2.5, 3.25]], 
+          {'axis': None, 'keepdims': True}),])
+    def test_edge_cases(self, x, p, ref, kwargs, xp):
+        default_dtype = xp_default_dtype(xp)
+        x, p, ref = xp.asarray(x), xp.asarray(p), xp.asarray(ref, dtype=default_dtype)
+        res = stats.quantile(x, p, **kwargs)
+        xp_assert_equal(res, ref)
+
+    @pytest.mark.parametrize('axis', [0, 1, 2])
+    @pytest.mark.parametrize('keepdims', [False, True])
+    def test_size_0(self, axis, keepdims, xp):
+        shape = [3, 4, 0]
+        out_shape = shape.copy()
+        if keepdims:
+            out_shape[axis] = 1
+        else:
+            out_shape.pop(axis)
+        res = stats.quantile(xp.zeros(tuple(shape)), 0.5, axis=axis, keepdims=keepdims)
+        assert res.shape == tuple(out_shape)
+
+    @pytest.mark.parametrize('method',
+        ['inverted_cdf', 'averaged_inverted_cdf', 'closest_observation'])
+    def test_transition(self, method, xp):
+        # test that values of discontinuous estimators are correct when
+        # p*n + m - 1 is integral.
+        if method == 'closest_observation' and np.__version__ < '2.0.1':
+            pytest.skip('Bug in np.quantile (numpy/numpy#26656) fixed in 2.0.1')
+        x = np.arange(8., dtype=np.float64)
+        p = np.arange(0, 1.0625, 0.0625)
+        res = stats.quantile(xp.asarray(x), xp.asarray(p), method=method)
+        ref = np.quantile(x, p, method=method)
+        xp_assert_equal(res, xp.asarray(ref, dtype=xp.float64))

scipy/stats/tests/test_rank.py

@@ -2,10 +2,10 @@ import numpy as np
 from numpy.testing import assert_equal, assert_array_equal
 import pytest
 
+from scipy import stats
 from scipy.conftest import skip_xp_invalid_arg
 from scipy.stats import rankdata, tiecorrect
-from scipy._lib._util import np_long
-
+from scipy._lib._array_api import xp_assert_equal, make_xp_test_case
 
 class TestTieCorrect:
 
@@ -73,63 +73,69 @@ class TestTieCorrect:
         assert_equal(out, 1.0 - k * (ntie**3 - ntie) / float(n**3 - n))
 
 
+@make_xp_test_case(stats.rankdata)
 class TestRankData:
 
-    def test_empty(self):
-        """stats.rankdata([]) should return an empty array."""
-        a = np.array([], dtype=int)
+    def desired_dtype(self, method='average', has_nans=False, *, xp):
+        if has_nans:
+            return xp.asarray(1.).dtype
+        return xp.asarray(1.).dtype if method=='average' else xp.asarray(1).dtype
+
+    def test_empty(self, xp):
+        """stats.rankdata of empty array should return an empty array."""
+        a = xp.asarray([], dtype=xp.int64)
         r = rankdata(a)
-        assert_array_equal(r, np.array([], dtype=np.float64))
+        xp_assert_equal(r, xp.asarray([], dtype=self.desired_dtype(xp=xp)))
+
+    def test_list(self):
+        # test that NumPy still accepts lists
         r = rankdata([])
-        assert_array_equal(r, np.array([], dtype=np.float64))
+        assert_array_equal(r, np.array([]))
+
+        r = rankdata([40, 10, 30, 10, 50])
+        assert_equal(r, [4.0, 1.5, 3.0, 1.5, 5.0])
 
     @pytest.mark.parametrize("shape", [(0, 1, 2)])
     @pytest.mark.parametrize("axis", [None, *range(3)])
-    def test_empty_multidim(self, shape, axis):
-        a = np.empty(shape, dtype=int)
+    def test_empty_multidim(self, shape, axis, xp):
+        a = xp.empty(shape, dtype=xp.int64)
         r = rankdata(a, axis=axis)
         expected_shape = (0,) if axis is None else shape
-        assert_equal(r.shape, expected_shape)
-        assert_equal(r.dtype, np.float64)
+        xp_assert_equal(r, xp.empty(expected_shape, dtype=self.desired_dtype(xp=xp)))
 
-    def test_one(self):
+    def test_one(self, xp):
         """Check stats.rankdata with an array of length 1."""
         data = [100]
-        a = np.array(data, dtype=int)
+        a = xp.asarray(data, dtype=xp.int64)
         r = rankdata(a)
-        assert_array_equal(r, np.array([1.0], dtype=np.float64))
-        r = rankdata(data)
-        assert_array_equal(r, np.array([1.0], dtype=np.float64))
+        xp_assert_equal(r, xp.asarray([1.0], dtype=self.desired_dtype(xp=xp)))
 
-    def test_basic(self):
+    def test_basic(self, xp):
         """Basic tests of stats.rankdata."""
+        desired_dtype = self.desired_dtype(xp=xp)
+
         data = [100, 10, 50]
-        expected = np.array([3.0, 1.0, 2.0], dtype=np.float64)
-        a = np.array(data, dtype=int)
+        expected = xp.asarray([3.0, 1.0, 2.0], dtype=desired_dtype)
+        a = xp.asarray(data, dtype=xp.int64)
         r = rankdata(a)
-        assert_array_equal(r, expected)
-        r = rankdata(data)
-        assert_array_equal(r, expected)
+        xp_assert_equal(r, expected)
 
         data = [40, 10, 30, 10, 50]
-        expected = np.array([4.0, 1.5, 3.0, 1.5, 5.0], dtype=np.float64)
-        a = np.array(data, dtype=int)
+        expected = xp.asarray([4.0, 1.5, 3.0, 1.5, 5.0], dtype=desired_dtype)
+        a = xp.asarray(data, dtype=xp.int64)
         r = rankdata(a)
-        assert_array_equal(r, expected)
-        r = rankdata(data)
-        assert_array_equal(r, expected)
+        xp_assert_equal(r, expected)
 
         data = [20, 20, 20, 10, 10, 10]
-        expected = np.array([5.0, 5.0, 5.0, 2.0, 2.0, 2.0], dtype=np.float64)
-        a = np.array(data, dtype=int)
+        expected = xp.asarray([5.0, 5.0, 5.0, 2.0, 2.0, 2.0], dtype=desired_dtype)
+        a = xp.asarray(data, dtype=xp.int64)
         r = rankdata(a)
-        assert_array_equal(r, expected)
-        r = rankdata(data)
-        assert_array_equal(r, expected)
-        # The docstring states explicitly that the argument is flattened.
-        a2d = a.reshape(2, 3)
+        xp_assert_equal(r, expected)
+
+        # # The docstring states explicitly that the argument is flattened.
+        a2d = xp.reshape(a, (2, 3))
         r = rankdata(a2d)
-        assert_array_equal(r, expected)
+        xp_assert_equal(r, expected)
 
     @skip_xp_invalid_arg
     def test_rankdata_object_string(self):
@@ -165,50 +171,51 @@ class TestRankData:
         val = np.array([0, 1, 2, 2.718, 3, 3.141], dtype='object')
         check_ranks(np.random.choice(val, 200).astype('object'))
 
-    def test_large_int(self):
-        data = np.array([2**60, 2**60+1], dtype=np.uint64)
+    def test_large_int(self, xp):
+        if hasattr(xp, 'uint64'):
+            data = xp.asarray([2**60, 2**60+1], dtype=xp.uint64)
+            r = rankdata(data)
+            xp_assert_equal(r, xp.asarray([1.0, 2.0], dtype=self.desired_dtype(xp=xp)))
+
+        data = xp.asarray([2**60, 2**60+1], dtype=xp.int64)
         r = rankdata(data)
-        assert_array_equal(r, [1.0, 2.0])
+        xp_assert_equal(r, xp.asarray([1.0, 2.0], dtype=self.desired_dtype(xp=xp)))
 
-        data = np.array([2**60, 2**60+1], dtype=np.int64)
+        data = xp.asarray([2**60, -2**60+1], dtype=xp.int64)
         r = rankdata(data)
-        assert_array_equal(r, [1.0, 2.0])
+        xp_assert_equal(r, xp.asarray([2.0, 1.0], dtype=self.desired_dtype(xp=xp)))
 
-        data = np.array([2**60, -2**60+1], dtype=np.int64)
+    @pytest.mark.parametrize('n', [10000, 100000, 1000000])
+    def test_big_tie(self, n, xp):
+        data = xp.ones(n)
         r = rankdata(data)
-        assert_array_equal(r, [2.0, 1.0])
+        expected_rank = 0.5 * (n + 1)
+        ref = xp.asarray(expected_rank * data, dtype=self.desired_dtype(xp=xp))
+        xp_assert_equal(r, ref)
 
-    def test_big_tie(self):
-        for n in [10000, 100000, 1000000]:
-            data = np.ones(n, dtype=int)
-            r = rankdata(data)
-            expected_rank = 0.5 * (n + 1)
-            assert_array_equal(r, expected_rank * data,
-                               "test failed with n=%d" % n)
-
-    def test_axis(self):
-        data = [[0, 2, 1],
-                [4, 2, 2]]
-        expected0 = [[1., 1.5, 1.],
-                     [2., 1.5, 2.]]
+    def test_axis(self, xp):
+        data = xp.asarray([[0, 2, 1], [4, 2, 2]])
+
+        expected0 = xp.asarray([[1., 1.5, 1.], [2., 1.5, 2.]])
         r0 = rankdata(data, axis=0)
-        assert_array_equal(r0, expected0)
-        expected1 = [[1., 3., 2.],
-                     [3., 1.5, 1.5]]
+        xp_assert_equal(r0, expected0)
+
+        expected1 = xp.asarray([[1., 3., 2.], [3., 1.5, 1.5]])
         r1 = rankdata(data, axis=1)
-        assert_array_equal(r1, expected1)
+        xp_assert_equal(r1, expected1)
 
-    methods = ["average", "min", "max", "dense", "ordinal"]
-    dtypes = [np.float64] + [np_long]*4
+    methods= ["average", "min", "max", "dense", "ordinal"]
 
     @pytest.mark.parametrize("axis", [0, 1])
-    @pytest.mark.parametrize("method, dtype", zip(methods, dtypes))
-    def test_size_0_axis(self, axis, method, dtype):
+    @pytest.mark.parametrize("method", methods)
+    def test_size_0_axis(self, axis, method, xp):
         shape = (3, 0)
-        data = np.zeros(shape)
+        desired_dtype = self.desired_dtype(method, xp=xp)
+        data = xp.zeros(shape)
         r = rankdata(data, method=method, axis=axis)
         assert_equal(r.shape, shape)
-        assert_equal(r.dtype, dtype)
+        assert_equal(r.dtype, desired_dtype)
+        xp_assert_equal(r, xp.empty(shape, dtype=desired_dtype))
 
     @pytest.mark.parametrize('axis', range(3))
     @pytest.mark.parametrize('method', methods)
@@ -289,50 +296,50 @@ class TestRankData:
                             [np.nan, np.nan, np.nan],
                             [1, 2.5, 2.5]])
 
-
-_cases = (
-    # values, method, expected
-    ([], 'average', []),
-    ([], 'min', []),
-    ([], 'max', []),
-    ([], 'dense', []),
-    ([], 'ordinal', []),
-    #
-    ([100], 'average', [1.0]),
-    ([100], 'min', [1.0]),
-    ([100], 'max', [1.0]),
-    ([100], 'dense', [1.0]),
-    ([100], 'ordinal', [1.0]),
-    #
-    ([100, 100, 100], 'average', [2.0, 2.0, 2.0]),
-    ([100, 100, 100], 'min', [1.0, 1.0, 1.0]),
-    ([100, 100, 100], 'max', [3.0, 3.0, 3.0]),
-    ([100, 100, 100], 'dense', [1.0, 1.0, 1.0]),
-    ([100, 100, 100], 'ordinal', [1.0, 2.0, 3.0]),
-    #
-    ([100, 300, 200], 'average', [1.0, 3.0, 2.0]),
-    ([100, 300, 200], 'min', [1.0, 3.0, 2.0]),
-    ([100, 300, 200], 'max', [1.0, 3.0, 2.0]),
-    ([100, 300, 200], 'dense', [1.0, 3.0, 2.0]),
-    ([100, 300, 200], 'ordinal', [1.0, 3.0, 2.0]),
-    #
-    ([100, 200, 300, 200], 'average', [1.0, 2.5, 4.0, 2.5]),
-    ([100, 200, 300, 200], 'min', [1.0, 2.0, 4.0, 2.0]),
-    ([100, 200, 300, 200], 'max', [1.0, 3.0, 4.0, 3.0]),
-    ([100, 200, 300, 200], 'dense', [1.0, 2.0, 3.0, 2.0]),
-    ([100, 200, 300, 200], 'ordinal', [1.0, 2.0, 4.0, 3.0]),
-    #
-    ([100, 200, 300, 200, 100], 'average', [1.5, 3.5, 5.0, 3.5, 1.5]),
-    ([100, 200, 300, 200, 100], 'min', [1.0, 3.0, 5.0, 3.0, 1.0]),
-    ([100, 200, 300, 200, 100], 'max', [2.0, 4.0, 5.0, 4.0, 2.0]),
-    ([100, 200, 300, 200, 100], 'dense', [1.0, 2.0, 3.0, 2.0, 1.0]),
-    ([100, 200, 300, 200, 100], 'ordinal', [1.0, 3.0, 5.0, 4.0, 2.0]),
-    #
-    ([10] * 30, 'ordinal', np.arange(1.0, 31.0)),
-)
-
-
-def test_cases():
-    for values, method, expected in _cases:
-        r = rankdata(values, method=method)
-        assert_array_equal(r, expected)
+    _rankdata_cases = (
+        # values, method, expected
+        ([], 'average', []),
+        ([], 'min', []),
+        ([], 'max', []),
+        ([], 'dense', []),
+        ([], 'ordinal', []),
+        #
+        ([100], 'average', [1.0]),
+        ([100], 'min', [1.0]),
+        ([100], 'max', [1.0]),
+        ([100], 'dense', [1.0]),
+        ([100], 'ordinal', [1.0]),
+        #
+        ([100, 100, 100], 'average', [2.0, 2.0, 2.0]),
+        ([100, 100, 100], 'min', [1.0, 1.0, 1.0]),
+        ([100, 100, 100], 'max', [3.0, 3.0, 3.0]),
+        ([100, 100, 100], 'dense', [1.0, 1.0, 1.0]),
+        ([100, 100, 100], 'ordinal', [1.0, 2.0, 3.0]),
+        #
+        ([100, 300, 200], 'average', [1.0, 3.0, 2.0]),
+        ([100, 300, 200], 'min', [1.0, 3.0, 2.0]),
+        ([100, 300, 200], 'max', [1.0, 3.0, 2.0]),
+        ([100, 300, 200], 'dense', [1.0, 3.0, 2.0]),
+        ([100, 300, 200], 'ordinal', [1.0, 3.0, 2.0]),
+        #
+        ([100, 200, 300, 200], 'average', [1.0, 2.5, 4.0, 2.5]),
+        ([100, 200, 300, 200], 'min', [1.0, 2.0, 4.0, 2.0]),
+        ([100, 200, 300, 200], 'max', [1.0, 3.0, 4.0, 3.0]),
+        ([100, 200, 300, 200], 'dense', [1.0, 2.0, 3.0, 2.0]),
+        ([100, 200, 300, 200], 'ordinal', [1.0, 2.0, 4.0, 3.0]),
+        #
+        ([100, 200, 300, 200, 100], 'average', [1.5, 3.5, 5.0, 3.5, 1.5]),
+        ([100, 200, 300, 200, 100], 'min', [1.0, 3.0, 5.0, 3.0, 1.0]),
+        ([100, 200, 300, 200, 100], 'max', [2.0, 4.0, 5.0, 4.0, 2.0]),
+        ([100, 200, 300, 200, 100], 'dense', [1.0, 2.0, 3.0, 2.0, 1.0]),
+        ([100, 200, 300, 200, 100], 'ordinal', [1.0, 3.0, 5.0, 4.0, 2.0]),
+        #
+        ([10] * 30, 'ordinal', np.arange(1.0, 31.0)),
+    )
+
+    @pytest.mark.parametrize('case', _rankdata_cases)
+    def test_cases(self, case, xp):
+        values, method, expected = case
+        r = rankdata(xp.asarray(values), method=method)
+        ref = xp.asarray(expected, dtype=self.desired_dtype(method, xp=xp))
+        xp_assert_equal(r, ref)