scipy 1.16.2__cp313-cp313t-win_arm64.whl

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

@@ -0,0 +1,345 @@
+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._array_api import xp_assert_equal, make_xp_test_case
+
+class TestTieCorrect:
+
+    def test_empty(self):
+        """An empty array requires no correction, should return 1.0."""
+        ranks = np.array([], dtype=np.float64)
+        c = tiecorrect(ranks)
+        assert_equal(c, 1.0)
+
+    def test_one(self):
+        """A single element requires no correction, should return 1.0."""
+        ranks = np.array([1.0], dtype=np.float64)
+        c = tiecorrect(ranks)
+        assert_equal(c, 1.0)
+
+    def test_no_correction(self):
+        """Arrays with no ties require no correction."""
+        ranks = np.arange(2.0)
+        c = tiecorrect(ranks)
+        assert_equal(c, 1.0)
+        ranks = np.arange(3.0)
+        c = tiecorrect(ranks)
+        assert_equal(c, 1.0)
+
+    def test_basic(self):
+        """Check a few basic examples of the tie correction factor."""
+        # One tie of two elements
+        ranks = np.array([1.0, 2.5, 2.5])
+        c = tiecorrect(ranks)
+        T = 2.0
+        N = ranks.size
+        expected = 1.0 - (T**3 - T) / (N**3 - N)
+        assert_equal(c, expected)
+
+        # One tie of two elements (same as above, but tie is not at the end)
+        ranks = np.array([1.5, 1.5, 3.0])
+        c = tiecorrect(ranks)
+        T = 2.0
+        N = ranks.size
+        expected = 1.0 - (T**3 - T) / (N**3 - N)
+        assert_equal(c, expected)
+
+        # One tie of three elements
+        ranks = np.array([1.0, 3.0, 3.0, 3.0])
+        c = tiecorrect(ranks)
+        T = 3.0
+        N = ranks.size
+        expected = 1.0 - (T**3 - T) / (N**3 - N)
+        assert_equal(c, expected)
+
+        # Two ties, lengths 2 and 3.
+        ranks = np.array([1.5, 1.5, 4.0, 4.0, 4.0])
+        c = tiecorrect(ranks)
+        T1 = 2.0
+        T2 = 3.0
+        N = ranks.size
+        expected = 1.0 - ((T1**3 - T1) + (T2**3 - T2)) / (N**3 - N)
+        assert_equal(c, expected)
+
+    def test_overflow(self):
+        ntie, k = 2000, 5
+        a = np.repeat(np.arange(k), ntie)
+        n = a.size  # ntie * k
+        out = tiecorrect(rankdata(a))
+        assert_equal(out, 1.0 - k * (ntie**3 - ntie) / float(n**3 - n))
+
+
+@make_xp_test_case(stats.rankdata)
+class TestRankData:
+
+    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)
+        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([]))
+
+        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, xp):
+        a = xp.empty(shape, dtype=xp.int64)
+        r = rankdata(a, axis=axis)
+        expected_shape = (0,) if axis is None else shape
+        xp_assert_equal(r, xp.empty(expected_shape, dtype=self.desired_dtype(xp=xp)))
+
+    def test_one(self, xp):
+        """Check stats.rankdata with an array of length 1."""
+        data = [100]
+        a = xp.asarray(data, dtype=xp.int64)
+        r = rankdata(a)
+        xp_assert_equal(r, xp.asarray([1.0], dtype=self.desired_dtype(xp=xp)))
+
+    def test_basic(self, xp):
+        """Basic tests of stats.rankdata."""
+        desired_dtype = self.desired_dtype(xp=xp)
+
+        data = [100, 10, 50]
+        expected = xp.asarray([3.0, 1.0, 2.0], dtype=desired_dtype)
+        a = xp.asarray(data, dtype=xp.int64)
+        r = rankdata(a)
+        xp_assert_equal(r, expected)
+
+        data = [40, 10, 30, 10, 50]
+        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)
+        xp_assert_equal(r, expected)
+
+        data = [20, 20, 20, 10, 10, 10]
+        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)
+        xp_assert_equal(r, expected)
+
+        # # The docstring states explicitly that the argument is flattened.
+        a2d = xp.reshape(a, (2, 3))
+        r = rankdata(a2d)
+        xp_assert_equal(r, expected)
+
+    @skip_xp_invalid_arg
+    def test_rankdata_object_string(self):
+
+        def min_rank(a):
+            return [1 + sum(i < j for i in a) for j in a]
+
+        def max_rank(a):
+            return [sum(i <= j for i in a) for j in a]
+
+        def ordinal_rank(a):
+            return min_rank([(x, i) for i, x in enumerate(a)])
+
+        def average_rank(a):
+            return [(i + j) / 2.0 for i, j in zip(min_rank(a), max_rank(a))]
+
+        def dense_rank(a):
+            b = np.unique(a)
+            return [1 + sum(i < j for i in b) for j in a]
+
+        rankf = dict(min=min_rank, max=max_rank, ordinal=ordinal_rank,
+                     average=average_rank, dense=dense_rank)
+
+        def check_ranks(a):
+            for method in 'min', 'max', 'dense', 'ordinal', 'average':
+                out = rankdata(a, method=method)
+                assert_array_equal(out, rankf[method](a))
+
+        val = ['foo', 'bar', 'qux', 'xyz', 'abc', 'efg', 'ace', 'qwe', 'qaz']
+        check_ranks(np.random.choice(val, 200))
+        check_ranks(np.random.choice(val, 200).astype('object'))
+
+        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, 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)
+        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)
+        xp_assert_equal(r, xp.asarray([2.0, 1.0], dtype=self.desired_dtype(xp=xp)))
+
+    @pytest.mark.parametrize('n', [10000, 100000, 1000000])
+    def test_big_tie(self, n, xp):
+        data = xp.ones(n)
+        r = rankdata(data)
+        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_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)
+        xp_assert_equal(r0, expected0)
+
+        expected1 = xp.asarray([[1., 3., 2.], [3., 1.5, 1.5]])
+        r1 = rankdata(data, axis=1)
+        xp_assert_equal(r1, expected1)
+
+    methods= ["average", "min", "max", "dense", "ordinal"]
+
+    @pytest.mark.parametrize("axis", [0, 1])
+    @pytest.mark.parametrize("method", methods)
+    def test_size_0_axis(self, axis, method, xp):
+        shape = (3, 0)
+        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, desired_dtype)
+        xp_assert_equal(r, xp.empty(shape, dtype=desired_dtype))
+
+    @pytest.mark.parametrize('axis', range(3))
+    @pytest.mark.parametrize('method', methods)
+    def test_nan_policy_omit_3d(self, axis, method):
+        shape = (20, 21, 22)
+        rng = np.random.RandomState(23983242)
+
+        a = rng.random(size=shape)
+        i = rng.random(size=shape) < 0.4
+        j = rng.random(size=shape) < 0.1
+        k = rng.random(size=shape) < 0.1
+        a[i] = np.nan
+        a[j] = -np.inf
+        a[k] - np.inf
+
+        def rank_1d_omit(a, method):
+            out = np.zeros_like(a)
+            i = np.isnan(a)
+            a_compressed = a[~i]
+            res = rankdata(a_compressed, method)
+            out[~i] = res
+            out[i] = np.nan
+            return out
+
+        def rank_omit(a, method, axis):
+            return np.apply_along_axis(lambda a: rank_1d_omit(a, method),
+                                       axis, a)
+
+        res = rankdata(a, method, axis=axis, nan_policy='omit')
+        res0 = rank_omit(a, method, axis=axis)
+
+        assert_array_equal(res, res0)
+
+    def test_nan_policy_2d_axis_none(self):
+        # 2 2d-array test with axis=None
+        data = [[0, np.nan, 3],
+                [4, 2, np.nan],
+                [1, 2, 2]]
+        assert_array_equal(rankdata(data, axis=None, nan_policy='omit'),
+                           [1., np.nan, 6., 7., 4., np.nan, 2., 4., 4.])
+        assert_array_equal(rankdata(data, axis=None, nan_policy='propagate'),
+                           [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan,
+                            np.nan, np.nan, np.nan])
+
+    def test_nan_policy_raise(self):
+        # 1 1d-array test
+        data = [0, 2, 3, -2, np.nan, np.nan]
+        with pytest.raises(ValueError, match="The input contains nan"):
+            rankdata(data, nan_policy='raise')
+
+        # 2 2d-array test
+        data = [[0, np.nan, 3],
+                [4, 2, np.nan],
+                [np.nan, 2, 2]]
+
+        with pytest.raises(ValueError, match="The input contains nan"):
+            rankdata(data, axis=0, nan_policy="raise")
+
+        with pytest.raises(ValueError, match="The input contains nan"):
+            rankdata(data, axis=1, nan_policy="raise")
+
+    def test_nan_policy_propagate(self):
+        # 1 1d-array test
+        data = [0, 2, 3, -2, np.nan, np.nan]
+        assert_array_equal(rankdata(data, nan_policy='propagate'),
+                           [np.nan, np.nan, np.nan, np.nan, np.nan, np.nan])
+
+        # 2 2d-array test
+        data = [[0, np.nan, 3],
+                [4, 2, np.nan],
+                [1, 2, 2]]
+        assert_array_equal(rankdata(data, axis=0, nan_policy='propagate'),
+                           [[1, np.nan, np.nan],
+                            [3, np.nan, np.nan],
+                            [2, np.nan, np.nan]])
+        assert_array_equal(rankdata(data, axis=1, nan_policy='propagate'),
+                           [[np.nan, np.nan, np.nan],
+                            [np.nan, np.nan, np.nan],
+                            [1, 2.5, 2.5]])
+
+    _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)

scipy/stats/tests/test_relative_risk.py

@@ -0,0 +1,95 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+from scipy.stats.contingency import relative_risk
+
+
+# Test just the calculation of the relative risk, including edge
+# cases that result in a relative risk of 0, inf or nan.
+@pytest.mark.parametrize(
+    'exposed_cases, exposed_total, control_cases, control_total, expected_rr',
+    [(1, 4, 3, 8, 0.25 / 0.375),
+     (0, 10, 5, 20, 0),
+     (0, 10, 0, 20, np.nan),
+     (5, 15, 0, 20, np.inf)]
+)
+def test_relative_risk(exposed_cases, exposed_total,
+                       control_cases, control_total, expected_rr):
+    result = relative_risk(exposed_cases, exposed_total,
+                           control_cases, control_total)
+    assert_allclose(result.relative_risk, expected_rr, rtol=1e-13)
+
+
+def test_relative_risk_confidence_interval():
+    result = relative_risk(exposed_cases=16, exposed_total=128,
+                           control_cases=24, control_total=256)
+    rr = result.relative_risk
+    ci = result.confidence_interval(confidence_level=0.95)
+    # The corresponding calculation in R using the epitools package.
+    #
+    # > library(epitools)
+    # > c <- matrix(c(232, 112, 24, 16), nrow=2)
+    # > result <- riskratio(c)
+    # > result$measure
+    #               risk ratio with 95% C.I.
+    # Predictor  estimate     lower    upper
+    #   Exposed1 1.000000        NA       NA
+    #   Exposed2 1.333333 0.7347317 2.419628
+    #
+    # The last line is the result that we want.
+    assert_allclose(rr, 4/3)
+    assert_allclose((ci.low, ci.high), (0.7347317, 2.419628), rtol=5e-7)
+
+
+def test_relative_risk_ci_conflevel0():
+    result = relative_risk(exposed_cases=4, exposed_total=12,
+                           control_cases=5, control_total=30)
+    rr = result.relative_risk
+    assert_allclose(rr, 2.0, rtol=1e-14)
+    ci = result.confidence_interval(0)
+    assert_allclose((ci.low, ci.high), (2.0, 2.0), rtol=1e-12)
+
+
+def test_relative_risk_ci_conflevel1():
+    result = relative_risk(exposed_cases=4, exposed_total=12,
+                           control_cases=5, control_total=30)
+    ci = result.confidence_interval(1)
+    assert_equal((ci.low, ci.high), (0, np.inf))
+
+
+def test_relative_risk_ci_edge_cases_00():
+    result = relative_risk(exposed_cases=0, exposed_total=12,
+                           control_cases=0, control_total=30)
+    assert_equal(result.relative_risk, np.nan)
+    ci = result.confidence_interval()
+    assert_equal((ci.low, ci.high), (np.nan, np.nan))
+
+
+def test_relative_risk_ci_edge_cases_01():
+    result = relative_risk(exposed_cases=0, exposed_total=12,
+                           control_cases=1, control_total=30)
+    assert_equal(result.relative_risk, 0)
+    ci = result.confidence_interval()
+    assert_equal((ci.low, ci.high), (0.0, np.nan))
+
+
+def test_relative_risk_ci_edge_cases_10():
+    result = relative_risk(exposed_cases=1, exposed_total=12,
+                           control_cases=0, control_total=30)
+    assert_equal(result.relative_risk, np.inf)
+    ci = result.confidence_interval()
+    assert_equal((ci.low, ci.high), (np.nan, np.inf))
+
+
+@pytest.mark.parametrize('ec, et, cc, ct', [(0, 0, 10, 20),
+                                            (-1, 10, 1, 5),
+                                            (1, 10, 0, 0),
+                                            (1, 10, -1, 4)])
+def test_relative_risk_bad_value(ec, et, cc, ct):
+    with pytest.raises(ValueError, match="must be an integer not less than"):
+        relative_risk(ec, et, cc, ct)
+
+
+def test_relative_risk_bad_type():
+    with pytest.raises(TypeError, match="must be an integer"):
+        relative_risk(1, 10, 2.0, 40)