scipy 1.16.2__cp311-cp311-win_arm64.whl

scipy/stats/tests/test_survival.py

@@ -0,0 +1,466 @@
+import pytest
+import numpy as np
+from numpy.testing import assert_equal, assert_allclose
+from scipy import stats
+from scipy.stats import _survival
+
+
+def _kaplan_meier_reference(times, censored):
+    # This is a very straightforward implementation of the Kaplan-Meier
+    # estimator that does almost everything differently from the implementation
+    # in stats.ecdf.
+
+    # Begin by sorting the raw data. Note that the order of death and loss
+    # at a given time matters: death happens first. See [2] page 461:
+    # "These conventions may be paraphrased by saying that deaths recorded as
+    # of an age t are treated as if they occurred slightly before t, and losses
+    # recorded as of an age t are treated as occurring slightly after t."
+    # We implement this by sorting the data first by time, then by `censored`,
+    # (which is 0 when there is a death and 1 when there is only a loss).
+    dtype = [('time', float), ('censored', int)]
+    data = np.array([(t, d) for t, d in zip(times, censored)], dtype=dtype)
+    data = np.sort(data, order=('time', 'censored'))
+    times = data['time']
+    died = np.logical_not(data['censored'])
+
+    m = times.size
+    n = np.arange(m, 0, -1)  # number at risk
+    sf = np.cumprod((n - died) / n)
+
+    # Find the indices of the *last* occurrence of unique times. The
+    # corresponding entries of `times` and `sf` are what we want.
+    _, indices = np.unique(times[::-1], return_index=True)
+    ref_times = times[-indices - 1]
+    ref_sf = sf[-indices - 1]
+    return ref_times, ref_sf
+
+
+class TestSurvival:
+
+    @staticmethod
+    def get_random_sample(rng, n_unique):
+        # generate random sample
+        unique_times = rng.random(n_unique)
+        # convert to `np.int32` to resolve `np.repeat` failure in 32-bit CI
+        repeats = rng.integers(1, 4, n_unique).astype(np.int32)
+        times = rng.permuted(np.repeat(unique_times, repeats))
+        censored = rng.random(size=times.size) > rng.random()
+        sample = stats.CensoredData.right_censored(times, censored)
+        return sample, times, censored
+
+    def test_input_validation(self):
+        message = '`sample` must be a one-dimensional sequence.'
+        with pytest.raises(ValueError, match=message):
+            stats.ecdf([[1]])
+        with pytest.raises(ValueError, match=message):
+            stats.ecdf(1)
+
+        message = '`sample` must not contain nan'
+        with pytest.raises(ValueError, match=message):
+            stats.ecdf([np.nan])
+
+        message = 'Currently, only uncensored and right-censored data...'
+        with pytest.raises(NotImplementedError, match=message):
+            stats.ecdf(stats.CensoredData.left_censored([1], censored=[True]))
+
+        message = 'method` must be one of...'
+        res = stats.ecdf([1, 2, 3])
+        with pytest.raises(ValueError, match=message):
+            res.cdf.confidence_interval(method='ekki-ekki')
+        with pytest.raises(ValueError, match=message):
+            res.sf.confidence_interval(method='shrubbery')
+
+        message = 'confidence_level` must be a scalar between 0 and 1'
+        with pytest.raises(ValueError, match=message):
+            res.cdf.confidence_interval(-1)
+        with pytest.raises(ValueError, match=message):
+            res.sf.confidence_interval([0.5, 0.6])
+
+        message = 'The confidence interval is undefined at some observations.'
+        with pytest.warns(RuntimeWarning, match=message):
+            ci = res.cdf.confidence_interval()
+
+        message = 'Confidence interval bounds do not implement...'
+        with pytest.raises(NotImplementedError, match=message):
+            ci.low.confidence_interval()
+        with pytest.raises(NotImplementedError, match=message):
+            ci.high.confidence_interval()
+
+    def test_edge_cases(self):
+        res = stats.ecdf([])
+        assert_equal(res.cdf.quantiles, [])
+        assert_equal(res.cdf.probabilities, [])
+
+        res = stats.ecdf([1])
+        assert_equal(res.cdf.quantiles, [1])
+        assert_equal(res.cdf.probabilities, [1])
+
+    def test_unique(self):
+        # Example with unique observations; `stats.ecdf` ref. [1] page 80
+        sample = [6.23, 5.58, 7.06, 6.42, 5.20]
+        res = stats.ecdf(sample)
+        ref_x = np.sort(np.unique(sample))
+        ref_cdf = np.arange(1, 6) / 5
+        ref_sf = 1 - ref_cdf
+        assert_equal(res.cdf.quantiles, ref_x)
+        assert_equal(res.cdf.probabilities, ref_cdf)
+        assert_equal(res.sf.quantiles, ref_x)
+        assert_equal(res.sf.probabilities, ref_sf)
+
+    def test_nonunique(self):
+        # Example with non-unique observations; `stats.ecdf` ref. [1] page 82
+        sample = [0, 2, 1, 2, 3, 4]
+        res = stats.ecdf(sample)
+        ref_x = np.sort(np.unique(sample))
+        ref_cdf = np.array([1/6, 2/6, 4/6, 5/6, 1])
+        ref_sf = 1 - ref_cdf
+        assert_equal(res.cdf.quantiles, ref_x)
+        assert_equal(res.cdf.probabilities, ref_cdf)
+        assert_equal(res.sf.quantiles, ref_x)
+        assert_equal(res.sf.probabilities, ref_sf)
+
+    def test_evaluate_methods(self):
+        # Test CDF and SF `evaluate` methods
+        rng = np.random.default_rng(1162729143302572461)
+        sample, _, _ = self.get_random_sample(rng, 15)
+        res = stats.ecdf(sample)
+        x = res.cdf.quantiles
+        xr = x + np.diff(x, append=x[-1]+1)/2  # right shifted points
+
+        assert_equal(res.cdf.evaluate(x), res.cdf.probabilities)
+        assert_equal(res.cdf.evaluate(xr), res.cdf.probabilities)
+        assert_equal(res.cdf.evaluate(x[0]-1), 0)  # CDF starts at 0
+        assert_equal(res.cdf.evaluate([-np.inf, np.inf]), [0, 1])
+
+        assert_equal(res.sf.evaluate(x), res.sf.probabilities)
+        assert_equal(res.sf.evaluate(xr), res.sf.probabilities)
+        assert_equal(res.sf.evaluate(x[0]-1), 1)  # SF starts at 1
+        assert_equal(res.sf.evaluate([-np.inf, np.inf]), [1, 0])
+
+    # ref. [1] page 91
+    t1 = [37, 43, 47, 56, 60, 62, 71, 77, 80, 81]  # times
+    d1 = [0, 0, 1, 1, 0, 0, 0, 1, 1, 1]  # 1 means deaths (not censored)
+    r1 = [1, 1, 0.875, 0.75, 0.75, 0.75, 0.75, 0.5, 0.25, 0]  # reference SF
+
+    # https://sphweb.bumc.bu.edu/otlt/mph-modules/bs/bs704_survival/BS704_Survival5.html
+    t2 = [8, 12, 26, 14, 21, 27, 8, 32, 20, 40]
+    d2 = [1, 1, 1, 1, 1, 1, 0, 0, 0, 0]
+    r2 = [0.9, 0.788, 0.675, 0.675, 0.54, 0.405, 0.27, 0.27, 0.27]
+    t3 = [33, 28, 41, 48, 48, 25, 37, 48, 25, 43]
+    d3 = [1, 1, 1, 0, 0, 0, 0, 0, 0, 0]
+    r3 = [1, 0.875, 0.75, 0.75, 0.6, 0.6, 0.6]
+
+    # https://sphweb.bumc.bu.edu/otlt/mph-modules/bs/bs704_survival/bs704_survival4.html
+    t4 = [24, 3, 11, 19, 24, 13, 14, 2, 18, 17,
+          24, 21, 12, 1, 10, 23, 6, 5, 9, 17]
+    d4 = [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1]
+    r4 = [0.95, 0.95, 0.897, 0.844, 0.844, 0.844, 0.844, 0.844, 0.844,
+          0.844, 0.76, 0.676, 0.676, 0.676, 0.676, 0.507, 0.507]
+
+    # https://www.real-statistics.com/survival-analysis/kaplan-meier-procedure/confidence-interval-for-the-survival-function/
+    t5 = [3, 5, 8, 10, 5, 5, 8, 12, 15, 14, 2, 11, 10, 9, 12, 5, 8, 11]
+    d5 = [1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1]
+    r5 = [0.944, 0.889, 0.722, 0.542, 0.542, 0.542, 0.361, 0.181, 0.181, 0.181]
+
+    @pytest.mark.parametrize("case", [(t1, d1, r1), (t2, d2, r2), (t3, d3, r3),
+                                      (t4, d4, r4), (t5, d5, r5)])
+    def test_right_censored_against_examples(self, case):
+        # test `ecdf` against other implementations on example problems
+        times, died, ref = case
+        sample = stats.CensoredData.right_censored(times, np.logical_not(died))
+        res = stats.ecdf(sample)
+        assert_allclose(res.sf.probabilities, ref, atol=1e-3)
+        assert_equal(res.sf.quantiles, np.sort(np.unique(times)))
+
+        # test reference implementation against other implementations
+        res = _kaplan_meier_reference(times, np.logical_not(died))
+        assert_equal(res[0], np.sort(np.unique(times)))
+        assert_allclose(res[1], ref, atol=1e-3)
+
+    @pytest.mark.parametrize('seed', [182746786639392128, 737379171436494115,
+                                      576033618403180168, 308115465002673650])
+    def test_right_censored_against_reference_implementation(self, seed):
+        # test `ecdf` against reference implementation on random problems
+        rng = np.random.default_rng(seed)
+        n_unique = rng.integers(10, 100)
+        sample, times, censored = self.get_random_sample(rng, n_unique)
+        res = stats.ecdf(sample)
+        ref = _kaplan_meier_reference(times, censored)
+        assert_allclose(res.sf.quantiles, ref[0])
+        assert_allclose(res.sf.probabilities, ref[1])
+
+        # If all observations are uncensored, the KM estimate should match
+        # the usual estimate for uncensored data
+        sample = stats.CensoredData(uncensored=times)
+        res = _survival._ecdf_right_censored(sample)  # force Kaplan-Meier
+        ref = stats.ecdf(times)
+        assert_equal(res[0], ref.sf.quantiles)
+        assert_allclose(res[1], ref.cdf.probabilities, rtol=1e-14)
+        assert_allclose(res[2], ref.sf.probabilities, rtol=1e-14)
+
+    def test_right_censored_ci(self):
+        # test "greenwood" confidence interval against example 4 (URL above).
+        times, died = self.t4, self.d4
+        sample = stats.CensoredData.right_censored(times, np.logical_not(died))
+        res = stats.ecdf(sample)
+        ref_allowance = [0.096, 0.096, 0.135, 0.162, 0.162, 0.162, 0.162,
+                         0.162, 0.162, 0.162, 0.214, 0.246, 0.246, 0.246,
+                         0.246, 0.341, 0.341]
+
+        sf_ci = res.sf.confidence_interval()
+        cdf_ci = res.cdf.confidence_interval()
+        allowance = res.sf.probabilities - sf_ci.low.probabilities
+
+        assert_allclose(allowance, ref_allowance, atol=1e-3)
+        assert_allclose(sf_ci.low.probabilities,
+                        np.clip(res.sf.probabilities - allowance, 0, 1))
+        assert_allclose(sf_ci.high.probabilities,
+                        np.clip(res.sf.probabilities + allowance, 0, 1))
+        assert_allclose(cdf_ci.low.probabilities,
+                        np.clip(res.cdf.probabilities - allowance, 0, 1))
+        assert_allclose(cdf_ci.high.probabilities,
+                        np.clip(res.cdf.probabilities + allowance, 0, 1))
+
+        # test "log-log" confidence interval against Mathematica
+        # e = {24, 3, 11, 19, 24, 13, 14, 2, 18, 17, 24, 21, 12, 1, 10, 23, 6, 5,
+        #      9, 17}
+        # ci = {1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0}
+        # R = EventData[e, ci]
+        # S = SurvivalModelFit[R]
+        # S["PointwiseIntervals", ConfidenceLevel->0.95,
+        #   ConfidenceTransform->"LogLog"]
+
+        ref_low = [0.694743, 0.694743, 0.647529, 0.591142, 0.591142, 0.591142,
+                   0.591142, 0.591142, 0.591142, 0.591142, 0.464605, 0.370359,
+                   0.370359, 0.370359, 0.370359, 0.160489, 0.160489]
+        ref_high = [0.992802, 0.992802, 0.973299, 0.947073, 0.947073, 0.947073,
+                    0.947073, 0.947073, 0.947073, 0.947073, 0.906422, 0.856521,
+                    0.856521, 0.856521, 0.856521, 0.776724, 0.776724]
+        sf_ci = res.sf.confidence_interval(method='log-log')
+        assert_allclose(sf_ci.low.probabilities, ref_low, atol=1e-6)
+        assert_allclose(sf_ci.high.probabilities, ref_high, atol=1e-6)
+
+    def test_right_censored_ci_example_5(self):
+        # test "exponential greenwood" confidence interval against example 5
+        times, died = self.t5, self.d5
+        sample = stats.CensoredData.right_censored(times, np.logical_not(died))
+        res = stats.ecdf(sample)
+        lower = np.array([0.66639, 0.624174, 0.456179, 0.287822, 0.287822,
+                          0.287822, 0.128489, 0.030957, 0.030957, 0.030957])
+        upper = np.array([0.991983, 0.970995, 0.87378, 0.739467, 0.739467,
+                          0.739467, 0.603133, 0.430365, 0.430365, 0.430365])
+
+        sf_ci = res.sf.confidence_interval(method='log-log')
+        cdf_ci = res.cdf.confidence_interval(method='log-log')
+
+        assert_allclose(sf_ci.low.probabilities, lower, atol=1e-5)
+        assert_allclose(sf_ci.high.probabilities, upper, atol=1e-5)
+        assert_allclose(cdf_ci.low.probabilities, 1-upper, atol=1e-5)
+        assert_allclose(cdf_ci.high.probabilities, 1-lower, atol=1e-5)
+
+        # Test against R's `survival` library `survfit` function, 90%CI
+        # library(survival)
+        # options(digits=16)
+        # time = c(3, 5, 8, 10, 5, 5, 8, 12, 15, 14, 2, 11, 10, 9, 12, 5, 8, 11)
+        # status = c(1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1)
+        # res = survfit(Surv(time, status)
+        # ~1, conf.type = "log-log", conf.int = 0.90)
+        # res$time; res$lower; res$upper
+        low = [0.74366748406861172, 0.68582332289196246, 0.50596835651480121,
+               0.32913131413336727, 0.32913131413336727, 0.32913131413336727,
+               0.15986912028781664, 0.04499539918147757, 0.04499539918147757,
+               0.04499539918147757]
+        high = [0.9890291867238429, 0.9638835422144144, 0.8560366823086629,
+                0.7130167643978450, 0.7130167643978450, 0.7130167643978450,
+                0.5678602982997164, 0.3887616766886558, 0.3887616766886558,
+                0.3887616766886558]
+        sf_ci = res.sf.confidence_interval(method='log-log',
+                                           confidence_level=0.9)
+        assert_allclose(sf_ci.low.probabilities, low)
+        assert_allclose(sf_ci.high.probabilities, high)
+
+        # And with conf.type = "plain"
+        low = [0.8556383113628162, 0.7670478794850761, 0.5485720663578469,
+               0.3441515412527123, 0.3441515412527123, 0.3441515412527123,
+               0.1449184105424544, 0., 0., 0.]
+        high = [1., 1., 0.8958723780865975, 0.7391817920806210,
+                0.7391817920806210, 0.7391817920806210, 0.5773038116797676,
+                0.3642270254596720, 0.3642270254596720, 0.3642270254596720]
+        sf_ci = res.sf.confidence_interval(confidence_level=0.9)
+        assert_allclose(sf_ci.low.probabilities, low)
+        assert_allclose(sf_ci.high.probabilities, high)
+
+    def test_right_censored_ci_nans(self):
+        # test `ecdf` confidence interval on a problem that results in NaNs
+        times, died = self.t1, self.d1
+        sample = stats.CensoredData.right_censored(times, np.logical_not(died))
+        res = stats.ecdf(sample)
+
+        # Reference values generated with Matlab
+        # format long
+        # t = [37 43 47 56 60 62 71 77 80 81];
+        # d = [0 0 1 1 0 0 0 1 1 1];
+        # censored = ~d1;
+        # [f, x, flo, fup] = ecdf(t, 'Censoring', censored, 'Alpha', 0.05);
+        x = [37, 47, 56, 77, 80, 81]
+        flo = [np.nan, 0, 0, 0.052701464070711, 0.337611126231790, np.nan]
+        fup = [np.nan, 0.35417230377, 0.5500569798, 0.9472985359, 1.0, np.nan]
+        i = np.searchsorted(res.cdf.quantiles, x)
+
+        message = "The confidence interval is undefined at some observations"
+        with pytest.warns(RuntimeWarning, match=message):
+            ci = res.cdf.confidence_interval()
+
+        # Matlab gives NaN as the first element of the CIs. Mathematica agrees,
+        # but R's survfit does not. It makes some sense, but it's not what the
+        # formula gives, so skip that element.
+        assert_allclose(ci.low.probabilities[i][1:], flo[1:])
+        assert_allclose(ci.high.probabilities[i][1:], fup[1:])
+
+        # [f, x, flo, fup] = ecdf(t, 'Censoring', censored, 'Function',
+        #                        'survivor', 'Alpha', 0.05);
+        flo = [np.nan, 0.64582769623, 0.449943020228, 0.05270146407, 0, np.nan]
+        fup = [np.nan, 1.0, 1.0, 0.947298535929289, 0.662388873768210, np.nan]
+        i = np.searchsorted(res.cdf.quantiles, x)
+
+        with pytest.warns(RuntimeWarning, match=message):
+            ci = res.sf.confidence_interval()
+
+        assert_allclose(ci.low.probabilities[i][1:], flo[1:])
+        assert_allclose(ci.high.probabilities[i][1:], fup[1:])
+
+        # With the same data, R's `survival` library `survfit` function
+        # doesn't produce the leading NaN
+        # library(survival)
+        # options(digits=16)
+        # time = c(37, 43, 47, 56, 60, 62, 71, 77, 80, 81)
+        # status = c(0, 0, 1, 1, 0, 0, 0, 1, 1, 1)
+        # res = survfit(Surv(time, status)
+        # ~1, conf.type = "plain", conf.int = 0.95)
+        # res$time
+        # res$lower
+        # res$upper
+        low = [1., 1., 0.64582769623233816, 0.44994302022779326,
+               0.44994302022779326, 0.44994302022779326, 0.44994302022779326,
+               0.05270146407071086, 0., np.nan]
+        high = [1., 1., 1., 1., 1., 1., 1., 0.9472985359292891,
+                0.6623888737682101, np.nan]
+        assert_allclose(ci.low.probabilities, low)
+        assert_allclose(ci.high.probabilities, high)
+
+        # It does with conf.type="log-log", as do we
+        with pytest.warns(RuntimeWarning, match=message):
+            ci = res.sf.confidence_interval(method='log-log')
+        low = [np.nan, np.nan, 0.38700001403202522, 0.31480711370551911,
+               0.31480711370551911, 0.31480711370551911, 0.31480711370551911,
+               0.08048821148507734, 0.01049958986680601, np.nan]
+        high = [np.nan, np.nan, 0.9813929658789660, 0.9308983170906275,
+                0.9308983170906275, 0.9308983170906275, 0.9308983170906275,
+                0.8263946341076415, 0.6558775085110887, np.nan]
+        assert_allclose(ci.low.probabilities, low)
+        assert_allclose(ci.high.probabilities, high)
+
+    def test_right_censored_against_uncensored(self):
+        rng = np.random.default_rng(7463952748044886637)
+        sample = rng.integers(10, 100, size=1000)
+        censored = np.zeros_like(sample)
+        censored[np.argmax(sample)] = True
+        res = stats.ecdf(sample)
+        ref = stats.ecdf(stats.CensoredData.right_censored(sample, censored))
+        assert_equal(res.sf.quantiles, ref.sf.quantiles)
+        assert_equal(res.sf._n, ref.sf._n)
+        assert_equal(res.sf._d[:-1], ref.sf._d[:-1])  # difference @ [-1]
+        assert_allclose(res.sf._sf[:-1], ref.sf._sf[:-1], rtol=1e-14)
+
+    def test_plot_iv(self):
+        rng = np.random.default_rng(1769658657308472721)
+        n_unique = rng.integers(10, 100)
+        sample, _, _ = self.get_random_sample(rng, n_unique)
+        res = stats.ecdf(sample)
+
+        try:
+            import matplotlib.pyplot as plt  # noqa: F401
+            res.sf.plot()  # no other errors occur
+        except (ModuleNotFoundError, ImportError):
+            message = r"matplotlib must be installed to use method `plot`."
+            with pytest.raises(ModuleNotFoundError, match=message):
+                res.sf.plot()
+
+
+class TestLogRank:
+
+    @pytest.mark.parametrize(
+        "x, y, statistic, pvalue",
+        # Results validate with R
+        # library(survival)
+        # options(digits=16)
+        #
+        # futime_1 <- c(8, 12, 26, 14, 21, 27, 8, 32, 20, 40)
+        # fustat_1 <- c(1, 1, 1, 1, 1, 1, 0, 0, 0, 0)
+        # rx_1 <- c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+        #
+        # futime_2 <- c(33, 28, 41, 48, 48, 25, 37, 48, 25, 43)
+        # fustat_2 <- c(1, 1, 1, 0, 0, 0, 0, 0, 0, 0)
+        # rx_2 <- c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1)
+        #
+        # futime <- c(futime_1, futime_2)
+        # fustat <- c(fustat_1, fustat_2)
+        # rx <- c(rx_1, rx_2)
+        #
+        # survdiff(formula = Surv(futime, fustat) ~ rx)
+        #
+        # Also check against another library which handle alternatives
+        # library(nph)
+        # logrank.test(futime, fustat, rx, alternative = "two.sided")
+        # res["test"]
+        [(
+              # https://sphweb.bumc.bu.edu/otlt/mph-modules/bs/bs704_survival/BS704_Survival5.html
+              # uncensored, censored
+              [[8, 12, 26, 14, 21, 27], [8, 32, 20, 40]],
+              [[33, 28, 41], [48, 48, 25, 37, 48, 25, 43]],
+              # chi2, ["two-sided", "less", "greater"]
+              6.91598157449,
+              [0.008542873404, 0.9957285632979385, 0.004271436702061537]
+         ),
+         (
+              # https://sphweb.bumc.bu.edu/otlt/mph-modules/bs/bs704_survival/BS704_Survival5.html
+              [[19, 6, 5, 4], [20, 19, 17, 14]],
+              [[16, 21, 7], [21, 15, 18, 18, 5]],
+              0.835004855038,
+              [0.3608293039, 0.8195853480676912, 0.1804146519323088]
+         ),
+         (
+              # Bland, Altman, "The logrank test", BMJ, 2004
+              # https://www.bmj.com/content/328/7447/1073.short
+              [[6, 13, 21, 30, 37, 38, 49, 50, 63, 79, 86, 98, 202, 219],
+               [31, 47, 80, 82, 82, 149]],
+              [[10, 10, 12, 13, 14, 15, 16, 17, 18, 20, 24, 24, 25, 28, 30,
+                33, 35, 37, 40, 40, 46, 48, 76, 81, 82, 91, 112, 181],
+               [34, 40, 70]],
+              7.49659416854,
+              [0.006181578637, 0.003090789318730882, 0.9969092106812691]
+         )]
+    )
+    def test_log_rank(self, x, y, statistic, pvalue):
+        x = stats.CensoredData(uncensored=x[0], right=x[1])
+        y = stats.CensoredData(uncensored=y[0], right=y[1])
+
+        for i, alternative in enumerate(["two-sided", "less", "greater"]):
+            res = stats.logrank(x=x, y=y, alternative=alternative)
+
+            # we return z and use the normal distribution while other framework
+            # return z**2. The p-value are directly comparable, but we have to
+            # square the statistic
+            assert_allclose(res.statistic**2, statistic, atol=1e-10)
+            assert_allclose(res.pvalue, pvalue[i], atol=1e-10)
+
+    def test_raises(self):
+        sample = stats.CensoredData([1, 2])
+
+        msg = r"`y` must be"
+        with pytest.raises(ValueError, match=msg):
+            stats.logrank(x=sample, y=[[1, 2]])
+
+        msg = r"`x` must be"
+        with pytest.raises(ValueError, match=msg):
+            stats.logrank(x=[[1, 2]], y=sample)

scipy/stats/tests/test_tukeylambda_stats.py

@@ -0,0 +1,85 @@
+import numpy as np
+from numpy.testing import assert_allclose, assert_equal
+
+from scipy.stats._tukeylambda_stats import (tukeylambda_variance,
+                                            tukeylambda_kurtosis)
+
+
+def test_tukeylambda_stats_known_exact():
+    """Compare results with some known exact formulas."""
+    # Some exact values of the Tukey Lambda variance and kurtosis:
+    # lambda   var      kurtosis
+    #   0     pi**2/3     6/5     (logistic distribution)
+    #  0.5    4 - pi    (5/3 - pi/2)/(pi/4 - 1)**2 - 3
+    #   1      1/3       -6/5     (uniform distribution on (-1,1))
+    #   2      1/12      -6/5     (uniform distribution on (-1/2, 1/2))
+
+    # lambda = 0
+    var = tukeylambda_variance(0)
+    assert_allclose(var, np.pi**2 / 3, atol=1e-12)
+    kurt = tukeylambda_kurtosis(0)
+    assert_allclose(kurt, 1.2, atol=1e-10)
+
+    # lambda = 0.5
+    var = tukeylambda_variance(0.5)
+    assert_allclose(var, 4 - np.pi, atol=1e-12)
+    kurt = tukeylambda_kurtosis(0.5)
+    desired = (5./3 - np.pi/2) / (np.pi/4 - 1)**2 - 3
+    assert_allclose(kurt, desired, atol=1e-10)
+
+    # lambda = 1
+    var = tukeylambda_variance(1)
+    assert_allclose(var, 1.0 / 3, atol=1e-12)
+    kurt = tukeylambda_kurtosis(1)
+    assert_allclose(kurt, -1.2, atol=1e-10)
+
+    # lambda = 2
+    var = tukeylambda_variance(2)
+    assert_allclose(var, 1.0 / 12, atol=1e-12)
+    kurt = tukeylambda_kurtosis(2)
+    assert_allclose(kurt, -1.2, atol=1e-10)
+
+
+def test_tukeylambda_stats_mpmath():
+    """Compare results with some values that were computed using mpmath."""
+    a10 = dict(atol=1e-10, rtol=0)
+    a12 = dict(atol=1e-12, rtol=0)
+    data = [
+        # lambda        variance              kurtosis
+        [-0.1, 4.78050217874253547, 3.78559520346454510],
+        [-0.0649, 4.16428023599895777, 2.52019675947435718],
+        [-0.05, 3.93672267890775277, 2.13129793057777277],
+        [-0.001, 3.30128380390964882, 1.21452460083542988],
+        [0.001, 3.27850775649572176, 1.18560634779287585],
+        [0.03125, 2.95927803254615800, 0.804487555161819980],
+        [0.05, 2.78281053405464501, 0.611604043886644327],
+        [0.0649, 2.65282386754100551, 0.476834119532774540],
+        [1.2, 0.242153920578588346, -1.23428047169049726],
+        [10.0, 0.00095237579757703597, 2.37810697355144933],
+        [20.0, 0.00012195121951131043, 7.37654321002709531],
+    ]
+
+    for lam, var_expected, kurt_expected in data:
+        var = tukeylambda_variance(lam)
+        assert_allclose(var, var_expected, **a12)
+        kurt = tukeylambda_kurtosis(lam)
+        assert_allclose(kurt, kurt_expected, **a10)
+
+    # Test with vector arguments (most of the other tests are for single
+    # values).
+    lam, var_expected, kurt_expected = zip(*data)
+    var = tukeylambda_variance(lam)
+    assert_allclose(var, var_expected, **a12)
+    kurt = tukeylambda_kurtosis(lam)
+    assert_allclose(kurt, kurt_expected, **a10)
+
+
+def test_tukeylambda_stats_invalid():
+    """Test values of lambda outside the domains of the functions."""
+    lam = [-1.0, -0.5]
+    var = tukeylambda_variance(lam)
+    assert_equal(var, np.array([np.nan, np.inf]))
+
+    lam = [-1.0, -0.25]
+    kurt = tukeylambda_kurtosis(lam)
+    assert_equal(kurt, np.array([np.nan, np.inf]))