scipy 1.15.3__cp312-cp312-macosx_12_0_arm64.whl → 1.16.0rc2__cp312-cp312-macosx_12_0_arm64.whl

scipy/stats/tests/test_continuous_basic.py

@@ -121,19 +121,21 @@ def cases_test_cont_basic():
 
 @pytest.mark.parametrize('distname,arg', cases_test_cont_basic())
 @pytest.mark.parametrize('sn', [500])
-def test_cont_basic(distname, arg, sn):
+def test_cont_basic(distname, arg, sn, num_parallel_threads):
     try:
         distfn = getattr(stats, distname)
     except TypeError:
         distfn = distname
         distname = 'rv_histogram_instance'
 
-    rng = np.random.RandomState(765456)
+    rng = np.random.default_rng(7654565)
     rvs = distfn.rvs(size=sn, *arg, random_state=rng)
     m, v = distfn.stats(*arg)
 
     if distname not in {'laplace_asymmetric'}:
-        check_sample_meanvar_(m, v, rvs)
+        # TODO: multiple checks in this function are not robust, tweaking the
+        # seed above will make different distributions fail.
+        check_sample_meanvar_(m, v, rvs, rng)
     check_cdf_ppf(distfn, arg, distname)
     check_sf_isf(distfn, arg, distname)
     check_cdf_sf(distfn, arg, distname)
@@ -167,13 +169,14 @@ def test_cont_basic(distname, arg, sn):
         arg = (3,)
 
     check_named_args(distfn, x, arg, locscale_defaults, meths)
-    check_random_state_property(distfn, arg)
+    if num_parallel_threads == 1:
+        check_random_state_property(distfn, arg)
 
-    if distname in ['rel_breitwigner'] and _IS_32BIT:
-        # gh18414
-        pytest.skip("fails on Linux 32-bit")
-    else:
-        check_pickling(distfn, arg)
+        if distname in ['rel_breitwigner'] and _IS_32BIT:
+            # gh18414
+            pytest.skip("fails on Linux 32-bit")
+        else:
+            check_pickling(distfn, arg)
     check_freezing(distfn, arg)
 
     # Entropy
@@ -281,6 +284,7 @@ def test_rvs_scalar(distname, arg):
     assert np.isscalar(distfn.rvs(*arg, size=None))
 
 
+@pytest.mark.parallel_threads(1)
 def test_levy_stable_random_state_property():
     # levy_stable only implements rvs(), so it is skipped in the
     # main loop in test_cont_basic(). Here we apply just the test
@@ -581,11 +585,11 @@ def test_method_of_moments():
     npt.assert_almost_equal(loc+scale, b, decimal=4)
 
 
-def check_sample_meanvar_(popmean, popvar, sample):
+def check_sample_meanvar_(popmean, popvar, sample, rng):
     if np.isfinite(popmean):
         check_sample_mean(sample, popmean)
     if np.isfinite(popvar):
-        check_sample_var(sample, popvar)
+        check_sample_var(sample, popvar, rng)
 
 
 def check_sample_mean(sample, popmean):
@@ -594,7 +598,7 @@ def check_sample_mean(sample, popmean):
     assert prob > 0.01
 
 
-def check_sample_var(sample, popvar):
+def check_sample_var(sample, popvar, rng):
     # check that population mean lies within the CI bootstrapped from the
     # sample. This used to be a chi-squared test for variance, but there were
     # too many false positives
@@ -602,6 +606,7 @@ def check_sample_var(sample, popvar):
         (sample,),
         lambda x, axis: x.var(ddof=1, axis=axis),
         confidence_level=0.995,
+        rng=rng,
     )
     conf = res.confidence_interval
     low, high = conf.low, conf.high
@@ -986,6 +991,7 @@ def test_kappa4_array_gh13582():
     assert res2.shape == (4, 4, 3)
 
 
+@pytest.mark.parallel_threads(1)
 def test_frozen_attributes():
     # gh-14827 reported that all frozen distributions had both pmf and pdf
     # attributes; continuous should have pdf and discrete should have pmf.

scipy/stats/tests/test_discrete_basic.py

@@ -36,14 +36,18 @@ def cases_test_discrete_basic():
 
 
 @pytest.mark.parametrize('distname,arg,first_case', cases_test_discrete_basic())
-def test_discrete_basic(distname, arg, first_case):
+def test_discrete_basic(distname, arg, first_case, num_parallel_threads):
+    if (isinstance(distname, str) and distname.startswith('nchypergeom')
+            and num_parallel_threads > 1):
+        pytest.skip(reason='nchypergeom has a global random generator')
+
     try:
         distfn = getattr(stats, distname)
     except TypeError:
         distfn = distname
         distname = 'sample distribution'
-    np.random.seed(9765456)
-    rvs = distfn.rvs(size=2000, *arg)
+    rng = np.random.RandomState(9765456)
+    rvs = distfn.rvs(*arg, size=2000, random_state=rng)
     supp = np.unique(rvs)
     m, v = distfn.stats(*arg)
     check_cdf_ppf(distfn, arg, supp, distname + ' cdf_ppf')
@@ -68,9 +72,10 @@ def test_discrete_basic(distname, arg, first_case):
         check_named_args(distfn, k, arg, locscale_defaults, meths)
         if distname != 'sample distribution':
             check_scale_docstring(distfn)
-        check_random_state_property(distfn, arg)
-        if distname not in {'poisson_binom'}:  # can't be pickled
-            check_pickling(distfn, arg)
+        if num_parallel_threads == 1:
+            check_random_state_property(distfn, arg)
+            if distname not in {'poisson_binom'}:  # can't be pickled
+                check_pickling(distfn, arg)
         check_freezing(distfn, arg)
 
         # Entropy
@@ -413,6 +418,7 @@ def test_integer_shapes(distname, shapename, shapes):
     assert not np.any(np.isnan(pmf[2, :]))
 
 
+@pytest.mark.parallel_threads(1)
 def test_frozen_attributes():
     # gh-14827 reported that all frozen distributions had both pmf and pdf
     # attributes; continuous should have pdf and discrete should have pmf.
@@ -564,11 +570,11 @@ def test_rv_sample():
 def test__pmf_float_input():
     # gh-21272
     # test that `rvs()` can be computed when `_pmf` requires float input
-    
+
     class rv_exponential(stats.rv_discrete):
         def _pmf(self, i):
             return (2/3)*3**(1 - i)
-    
+
     rv = rv_exponential(a=0.0, b=float('inf'))
     rvs = rv.rvs(random_state=42)  # should not crash due to integer input to `_pmf`
     assert_allclose(rvs, 0)

scipy/stats/tests/test_discrete_distns.py

@@ -109,10 +109,10 @@ def test_nhypergeom_rvs_shape():
 def test_nhypergeom_accuracy():
     # Check that nhypergeom.rvs post-gh-13431 gives the same values as
     # inverse transform sampling
-    np.random.seed(0)
-    x = nhypergeom.rvs(22, 7, 11, size=100)
-    np.random.seed(0)
-    p = np.random.uniform(size=100)
+    rng = np.random.RandomState(0)
+    x = nhypergeom.rvs(22, 7, 11, size=100, random_state=rng)
+    rng = np.random.RandomState(0)
+    p = rng.uniform(size=100)
     y = nhypergeom.ppf(p, 22, 7, 11)
     assert_equal(x, y)
 
@@ -305,10 +305,10 @@ class TestZipfian:
         # cdf <- pzipf(k, N = n, shape = a)
         # print(pmf)
         # print(cdf)
-        np.random.seed(0)
-        k = np.random.randint(1, 20, size=10)
-        a = np.random.rand(10)*10 + 1
-        n = np.random.randint(1, 100, size=10)
+        rng = np.random.RandomState(0)
+        k = rng.randint(1, 20, size=10)
+        a = rng.rand(10)*10 + 1
+        n = rng.randint(1, 100, size=10)
         pmf = [8.076972e-03, 2.950214e-05, 9.799333e-01, 3.216601e-06,
                3.158895e-04, 3.412497e-05, 4.350472e-10, 2.405773e-06,
                5.860662e-06, 1.053948e-04]
@@ -318,9 +318,9 @@ class TestZipfian:
         assert_allclose(zipfian.pmf(k, a, n)[1:], pmf[1:], rtol=1e-6)
         assert_allclose(zipfian.cdf(k, a, n)[1:], cdf[1:], rtol=5e-5)
 
-    np.random.seed(0)
+    rng = np.random.RandomState(0)
     naive_tests = np.vstack((np.logspace(-2, 1, 10),
-                             np.random.randint(2, 40, 10))).T
+                             rng.randint(2, 40, 10))).T
 
     @pytest.mark.parametrize("a, n", naive_tests)
     def test_zipfian_naive(self, a, n):
@@ -424,17 +424,17 @@ class TestNCH:
     def test_nchypergeom_wallenius_naive(self):
         # test against a very simple implementation
 
-        np.random.seed(2)
+        rng = np.random.RandomState(2)
         shape = (2, 4, 3)
         max_m = 100
-        m1 = np.random.randint(1, max_m, size=shape)
-        m2 = np.random.randint(1, max_m, size=shape)
+        m1 = rng.randint(1, max_m, size=shape)
+        m2 = rng.randint(1, max_m, size=shape)
         N = m1 + m2
-        n = randint.rvs(0, N, size=N.shape)
+        n = randint.rvs(0, N, size=N.shape, random_state=rng)
         xl = np.maximum(0, n-m2)
         xu = np.minimum(n, m1)
-        x = randint.rvs(xl, xu, size=xl.shape)
-        w = np.random.rand(*x.shape)*2
+        x = randint.rvs(xl, xu, size=xl.shape, random_state=rng)
+        w = rng.rand(*x.shape)*2
 
         def support(N, m1, n, w):
             m2 = N - m1

scipy/stats/tests/test_distributions.py

@@ -5,6 +5,7 @@ import warnings
 import re
 import sys
 import pickle
+import threading
 from pathlib import Path
 import os
 import json
@@ -66,7 +67,7 @@ def test_distributions_submodule():
     continuous = [dist[0] for dist in distcont]    # continuous dist names
     discrete = [dist[0] for dist in distdiscrete]  # discrete dist names
     other = ['rv_discrete', 'rv_continuous', 'rv_histogram',
-             'entropy', 'trapz']
+             'entropy']
     expected = continuous + discrete + other
 
     # need to remove, e.g.,
@@ -1365,25 +1366,27 @@ class TestGennorm:
         assert_almost_equal(pdf1, pdf2)
 
     def test_rvs(self):
-        np.random.seed(0)
+        rng = np.random.RandomState(0)
         # 0 < beta < 1
         dist = stats.gennorm(0.5)
-        rvs = dist.rvs(size=1000)
+        rvs = dist.rvs(size=1000, random_state=rng)
         assert stats.kstest(rvs, dist.cdf).pvalue > 0.1
         # beta = 1
         dist = stats.gennorm(1)
-        rvs = dist.rvs(size=1000)
-        rvs_laplace = stats.laplace.rvs(size=1000)
+        rvs = dist.rvs(size=1000, random_state=rng)
+        rvs_laplace = stats.laplace.rvs(size=1000, random_state=rng)
         assert stats.ks_2samp(rvs, rvs_laplace).pvalue > 0.1
         # beta = 2
         dist = stats.gennorm(2)
-        rvs = dist.rvs(size=1000)
-        rvs_norm = stats.norm.rvs(scale=1/2**0.5, size=1000)
+        dist.random_state = rng
+        rvs = dist.rvs(size=1000, random_state=rng)
+        rvs_norm = stats.norm.rvs(scale=1/2**0.5, size=1000, random_state=rng)
         assert stats.ks_2samp(rvs, rvs_norm).pvalue > 0.1
 
     def test_rvs_broadcasting(self):
-        np.random.seed(0)
+        rng = np.random.default_rng(0)
         dist = stats.gennorm([[0.5, 1.], [2., 5.]])
+        dist.random_state = rng
         rvs = dist.rvs(size=[1000, 2, 2])
         assert stats.kstest(rvs[:, 0, 0], stats.gennorm(0.5).cdf)[1] > 0.1
         assert stats.kstest(rvs[:, 0, 1], stats.gennorm(1.0).cdf)[1] > 0.1
@@ -2601,16 +2604,13 @@ class TestPareto:
         expected = (scale/x)**b   # 2.25e-18
         assert_allclose(p, expected)
 
-    @pytest.fixture(scope='function')
-    def rng(self):
-        return np.random.default_rng(1234)
-
     @pytest.mark.filterwarnings("ignore:invalid value encountered in "
                                 "double_scalars")
     @pytest.mark.parametrize("rvs_shape", [1, 2])
     @pytest.mark.parametrize("rvs_loc", [0, 2])
     @pytest.mark.parametrize("rvs_scale", [1, 5])
-    def test_fit(self, rvs_shape, rvs_loc, rvs_scale, rng):
+    def test_fit(self, rvs_shape, rvs_loc, rvs_scale):
+        rng = np.random.default_rng(1234)
         data = stats.pareto.rvs(size=100, b=rvs_shape, scale=rvs_scale,
                                 loc=rvs_loc, random_state=rng)
 
@@ -2641,7 +2641,8 @@ class TestPareto:
                               if False in p])
     @np.errstate(invalid="ignore")
     def test_fit_MLE_comp_optimizer(self, rvs_shape, rvs_loc, rvs_scale,
-                                    fix_shape, fix_loc, fix_scale, rng):
+                                    fix_shape, fix_loc, fix_scale):
+        rng = np.random.default_rng(1234)
         data = stats.pareto.rvs(size=100, b=rvs_shape, scale=rvs_scale,
                                 loc=rvs_loc, random_state=rng)
 
@@ -2673,7 +2674,8 @@ class TestPareto:
         assert_raises(FitDataError, stats.pareto.fit, [5, 2, 3], floc=1,
                       fscale=3)
 
-    def test_negative_data(self, rng):
+    def test_negative_data(self):
+        rng = np.random.default_rng(1234)
         data = stats.pareto.rvs(loc=-130, b=1, size=100, random_state=rng)
         assert_array_less(data, 0)
         # The purpose of this test is to make sure that no runtime warnings are
@@ -3345,6 +3347,22 @@ class TestInvgauss:
     def test_entropy(self, mu, ref):
         assert_allclose(stats.invgauss.entropy(mu), ref, rtol=5e-14)
 
+    def test_mu_inf_gh13666(self):
+        # invgauss methods should return correct result when mu=inf
+        # invgauss as mu -> oo is invgamma with shape and scale 0.5;
+        # see gh-13666 and gh-22496
+        dist = stats.invgauss(mu=np.inf)
+        dist0 = stats.invgamma(0.5, scale=0.5)
+        x, p = 1., 0.5
+        assert_allclose(dist.logpdf(x), dist0.logpdf(x))
+        assert_allclose(dist.pdf(x), dist0.pdf(x))
+        assert_allclose(dist.logcdf(x), dist0.logcdf(x))
+        assert_allclose(dist.cdf(x), dist0.cdf(x))
+        assert_allclose(dist.logsf(x), dist0.logsf(x))
+        assert_allclose(dist.sf(x), dist0.sf(x))
+        assert_allclose(dist.ppf(p), dist0.ppf(p))
+        assert_allclose(dist.isf(p), dist0.isf(p))
+
 
 class TestLandau:
     @pytest.mark.parametrize('name', ['pdf', 'cdf', 'sf', 'ppf', 'isf'])
@@ -4168,9 +4186,9 @@ class TestSkewCauchy:
         # qsgt(cdf, mu=0, lambda=lambda, sigma=1, q=1/2, mean.cent=FALSE,
         #      var.adj = sqrt(2))
 
-        np.random.seed(0)
-        a = np.random.rand(10) * 2 - 1
-        x = np.random.rand(10) * 10 - 5
+        rng = np.random.RandomState(0)
+        a = rng.rand(10) * 2 - 1
+        x = rng.rand(10) * 10 - 5
         pdf = [0.039473975217333909, 0.305829714049903223, 0.24140158118994162,
                0.019585772402693054, 0.021436553695989482, 0.00909817103867518,
                0.01658423410016873, 0.071083288030394126, 0.103250045941454524,
@@ -4284,22 +4302,24 @@ class TestSkewNorm:
                                   stats.norm.pdf(x))
 
     def test_rvs(self):
+        rng = check_random_state(1234)
         shape = (3, 4, 5)
-        x = stats.skewnorm.rvs(a=0.75, size=shape, random_state=self.rng)
+        x = stats.skewnorm.rvs(a=0.75, size=shape, random_state=rng)
         assert_equal(shape, x.shape)
 
-        x = stats.skewnorm.rvs(a=-3, size=shape, random_state=self.rng)
+        x = stats.skewnorm.rvs(a=-3, size=shape, random_state=rng)
         assert_equal(shape, x.shape)
 
     def test_moments(self):
+        rng = check_random_state(1234)
         X = stats.skewnorm.rvs(a=4, size=int(1e6), loc=5, scale=2,
-                               random_state=self.rng)
+                               random_state=rng)
         expected = [np.mean(X), np.var(X), stats.skew(X), stats.kurtosis(X)]
         computed = stats.skewnorm.stats(a=4, loc=5, scale=2, moments='mvsk')
         assert_array_almost_equal(computed, expected, decimal=2)
 
         X = stats.skewnorm.rvs(a=-4, size=int(1e6), loc=5, scale=2,
-                               random_state=self.rng)
+                               random_state=rng)
         expected = [np.mean(X), np.var(X), stats.skew(X), stats.kurtosis(X)]
         computed = stats.skewnorm.stats(a=-4, loc=5, scale=2, moments='mvsk')
         assert_array_almost_equal(computed, expected, decimal=2)
@@ -5145,8 +5165,8 @@ class TestBetaPrime:
         # Testing for gh-18634 revealed that `betaprime` raised a
         # NotImplementedError for higher moments. Check that this is
         # resolved. Parameters are arbitrary but lie on either side of the
-        # moment order (5) to test both branches of `_lazywhere`. Reference
-        # values produced with Mathematica, e.g.
+        # moment order (5) to test both branches of `xpx.apply_where`.
+        # Reference values produced with Mathematica, e.g.
         # `Moment[BetaPrimeDistribution[2,7],5]`
         ref = [np.inf, 0.867096912929055]
         res = stats.betaprime(2, [4.2, 7.1]).moment(5)
@@ -5742,6 +5762,7 @@ class TestLevyStable:
             ),
         ]
     )
+    @pytest.mark.thread_unsafe
     def test_pdf_nolan_samples(
             self, nolan_pdf_sample_data, pct_range, alpha_range, beta_range
     ):
@@ -5957,6 +5978,7 @@ class TestLevyStable:
             ),
         ]
     )
+    @pytest.mark.thread_unsafe
     def test_cdf_nolan_samples(
             self, nolan_cdf_sample_data, pct_range, alpha_range, beta_range
     ):
@@ -6307,7 +6329,11 @@ class TestLevyStable:
             expected,
         )
 
-    def test_frozen_parameterization_gh20821(self):
+    @pytest.fixture
+    def levy_stable_lock(self):
+        return threading.Lock()
+
+    def test_frozen_parameterization_gh20821(self, levy_stable_lock):
         # gh-20821 reported that frozen distributions ignore the parameterization.
         # Check that this is resolved and that the frozen distribution's
         # parameterization can be changed independently of stats.levy_stable
@@ -6316,37 +6342,39 @@ class TestLevyStable:
         unfrozen = stats.levy_stable
         frozen = stats.levy_stable(**shapes)
 
-        unfrozen.parameterization = "S0"
-        frozen.parameterization = "S1"
-        unfrozen_a = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
-        frozen_a = frozen.rvs(size=10, random_state=rng(329823498))
-        assert not np.any(frozen_a == unfrozen_a)
-
-        unfrozen.parameterization = "S1"
-        frozen.parameterization = "S0"
-        unfrozen_b = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
-        frozen_b = frozen.rvs(size=10, random_state=rng(329823498))
-        assert_equal(frozen_b, unfrozen_a)
-        assert_equal(unfrozen_b, frozen_a)
-
-    def test_frozen_parameterization_gh20821b(self):
+        with levy_stable_lock:
+            unfrozen.parameterization = "S0"
+            frozen.parameterization = "S1"
+            unfrozen_a = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
+            frozen_a = frozen.rvs(size=10, random_state=rng(329823498))
+            assert not np.any(frozen_a == unfrozen_a)
+
+            unfrozen.parameterization = "S1"
+            frozen.parameterization = "S0"
+            unfrozen_b = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
+            frozen_b = frozen.rvs(size=10, random_state=rng(329823498))
+            assert_equal(frozen_b, unfrozen_a)
+            assert_equal(unfrozen_b, frozen_a)
+
+    def test_frozen_parameterization_gh20821b(self, levy_stable_lock):
         # Check that the parameterization of the frozen distribution is that of
         # the unfrozen distribution at the time of freezing
         rng = np.random.default_rng
         shapes = dict(alpha=1.9, beta=0.1, loc=0.0, scale=1.0)
         unfrozen = stats.levy_stable
 
-        unfrozen.parameterization = "S0"
-        frozen = stats.levy_stable(**shapes)
-        unfrozen_a = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
-        frozen_a = frozen.rvs(size=10, random_state=rng(329823498))
-        assert_equal(frozen_a, unfrozen_a)
+        with levy_stable_lock:
+            unfrozen.parameterization = "S0"
+            frozen = stats.levy_stable(**shapes)
+            unfrozen_a = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
+            frozen_a = frozen.rvs(size=10, random_state=rng(329823498))
+            assert_equal(frozen_a, unfrozen_a)
 
-        unfrozen.parameterization = "S1"
-        frozen = stats.levy_stable(**shapes)
-        unfrozen_b = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
-        frozen_b = frozen.rvs(size=10, random_state=rng(329823498))
-        assert_equal(frozen_b, unfrozen_b)
+            unfrozen.parameterization = "S1"
+            frozen = stats.levy_stable(**shapes)
+            unfrozen_b = unfrozen.rvs(**shapes, size=10, random_state=rng(329823498))
+            frozen_b = frozen.rvs(size=10, random_state=rng(329823498))
+            assert_equal(frozen_b, unfrozen_b)
 
 
 class TestArrayArgument:  # test for ticket:992
@@ -6994,6 +7022,7 @@ class TestExpect:
         assert_allclose(res,
                         sum(_ for _ in range(lo, hi)) / (hi - lo), atol=1e-15)
 
+    @pytest.mark.thread_unsafe
     def test_zipf(self):
         # Test that there is no infinite loop even if the sum diverges
         assert_warns(RuntimeWarning, stats.zipf.expect,
@@ -7921,24 +7950,6 @@ class TestTrapezoid:
 
         assert_allclose(v, res.T.reshape(v.shape), atol=1e-15)
 
-    def test_trapz(self):
-        # Basic test for alias
-        x = np.linspace(0, 1, 10)
-        with pytest.deprecated_call(match="`trapz.pdf` is deprecated"):
-            result = stats.trapz.pdf(x, 0, 1)
-        assert_almost_equal(result, stats.uniform.pdf(x))
-
-    @pytest.mark.parametrize('method', ['pdf', 'logpdf', 'cdf', 'logcdf',
-                                        'sf', 'logsf', 'ppf', 'isf'])
-    def test_trapz_deprecation(self, method):
-        c, d = 0.2, 0.8
-        expected = getattr(stats.trapezoid, method)(1, c, d)
-        with pytest.deprecated_call(
-            match=f"`trapz.{method}` is deprecated",
-        ):
-            result = getattr(stats.trapz, method)(1, c, d)
-        assert result == expected
-
 
 class TestTriang:
     def test_edge_cases(self):
@@ -8520,9 +8531,9 @@ def test_nan_arguments_gh_issue_1362():
 
 
 def test_frozen_fit_ticket_1536():
-    np.random.seed(5678)
+    rng = np.random.default_rng(5678)
     true = np.array([0.25, 0., 0.5])
-    x = stats.lognorm.rvs(true[0], true[1], true[2], size=100)
+    x = stats.lognorm.rvs(true[0], true[1], true[2], size=100, random_state=rng)
 
     with np.errstate(divide='ignore'):
         params = np.array(stats.lognorm.fit(x, floc=0.))
@@ -8538,10 +8549,10 @@ def test_frozen_fit_ticket_1536():
     params = np.array(stats.lognorm.fit(x, f0=0.25, floc=0))
     assert_almost_equal(params, true, decimal=2)
 
-    np.random.seed(5678)
+    rng = np.random.default_rng(5678)
     loc = 1
     floc = 0.9
-    x = stats.norm.rvs(loc, 2., size=100)
+    x = stats.norm.rvs(loc, 2., size=100, random_state=rng)
     params = np.array(stats.norm.fit(x, floc=floc))
     expected = np.array([floc, np.sqrt(((x-floc)**2).mean())])
     assert_almost_equal(params, expected, decimal=4)
@@ -8549,8 +8560,8 @@ def test_frozen_fit_ticket_1536():
 
 def test_regression_ticket_1530():
     # Check the starting value works for Cauchy distribution fit.
-    np.random.seed(654321)
-    rvs = stats.cauchy.rvs(size=100)
+    rng = np.random.default_rng(654321)
+    rvs = stats.cauchy.rvs(size=100, random_state=rng)
     params = stats.cauchy.fit(rvs)
     expected = (0.045, 1.142)
     assert_almost_equal(params, expected, decimal=1)
@@ -8558,8 +8569,8 @@ def test_regression_ticket_1530():
 
 def test_gh_pr_4806():
     # Check starting values for Cauchy distribution fit.
-    np.random.seed(1234)
-    x = np.random.randn(42)
+    rng = np.random.RandomState(1234)
+    x = rng.randn(42)
     for offset in 10000.0, 1222333444.0:
         loc, scale = stats.cauchy.fit(x + offset)
         assert_allclose(loc, offset, atol=1.0)
@@ -9940,6 +9951,15 @@ class TestWrapCauchy:
         assert_allclose(p[0], np.arctan(cr*np.tan(x1/2))/np.pi)
         assert_allclose(p[1], 1 - np.arctan(cr*np.tan(np.pi - x2/2))/np.pi)
 
+    @pytest.mark.parametrize('c', [1e-10, 1e-1])
+    @pytest.mark.parametrize('loc', [-100, -2*np.pi, -np.pi, 0, np.pi, 2*np.pi, 100])
+    @pytest.mark.parametrize('scale', [1e-10, 1, 1e10])
+    def test_rvs_lie_on_circle(self, c, loc, scale):
+        # Check that the random variates lie in range [0, 2*pi]
+        x = stats.wrapcauchy.rvs(c=c, loc=loc, scale=scale, size=1000)
+        assert np.all(x >= 0)
+        assert np.all(x <= 2 * np.pi)
+
 
 def test_rvs_no_size_error():
     # _rvs methods must have parameter `size`; see gh-11394