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

scipy/stats/tests/test_continuous.py

@@ -1,3 +1,4 @@
+import itertools as it
 import os
 import pickle
 from copy import deepcopy
@@ -9,24 +10,26 @@ from numpy.testing import assert_allclose, assert_equal
 from hypothesis import strategies, given, reproduce_failure, settings  # noqa: F401
 import hypothesis.extra.numpy as npst
 
+from scipy import special
 from scipy import stats
 from scipy.stats._fit import _kolmogorov_smirnov
 from scipy.stats._ksstats import kolmogn
 from scipy.stats import qmc
-from scipy.stats._distr_params import distcont
+from scipy.stats._distr_params import distcont, distdiscrete
 from scipy.stats._distribution_infrastructure import (
-    _Domain, _RealDomain, _Parameter, _Parameterization, _RealParameter,
+    _Domain, _RealInterval, _Parameter, _Parameterization, _RealParameter,
     ContinuousDistribution, ShiftedScaledDistribution, _fiinfo,
     _generate_domain_support, Mixture)
 from scipy.stats._new_distributions import StandardNormal, _LogUniform, _Gamma
-from scipy.stats import Normal, Uniform
+from scipy.stats._new_distributions import DiscreteDistribution
+from scipy.stats import Normal, Uniform, Binomial
 
 
-class Test_RealDomain:
+class Test_RealInterval:
     rng = np.random.default_rng(349849812549824)
 
     def test_iv(self):
-        domain = _RealDomain(endpoints=('a', 'b'))
+        domain = _RealInterval(endpoints=('a', 'b'))
         message = "The endpoints of the distribution are defined..."
         with pytest.raises(TypeError, match=message):
             domain.get_numerical_endpoints(dict)
@@ -37,7 +40,7 @@ class Test_RealDomain:
     def test_contains_simple(self, x):
         # Test `contains` when endpoints are defined by constants
         a, b = -np.inf, np.pi
-        domain = _RealDomain(endpoints=(a, b), inclusive=(False, True))
+        domain = _RealInterval(endpoints=(a, b), inclusive=(False, True))
         assert_equal(domain.contains(x), (a < x) & (x <= b))
 
     @pytest.mark.slow
@@ -45,6 +48,7 @@ class Test_RealDomain:
            inclusive_a=strategies.booleans(),
            inclusive_b=strategies.booleans(),
            data=strategies.data())
+    @pytest.mark.thread_unsafe
     def test_contains(self, shapes, inclusive_a, inclusive_b, data):
         # Test `contains` when endpoints are defined by parameters
         input_shapes, result_shape = shapes
@@ -67,10 +71,10 @@ class Test_RealDomain:
                             np.linspace(a, b, 10),
                             np.linspace(b, b+d, 10)])
         # Domain is defined by two parameters, 'a' and 'b'
-        domain = _RealDomain(endpoints=('a', 'b'),
+        domain = _RealInterval(endpoints=('a', 'b'),
                              inclusive=(inclusive_a, inclusive_b))
-        domain.define_parameters(_RealParameter('a', domain=_RealDomain()),
-                                 _RealParameter('b', domain=_RealDomain()))
+        domain.define_parameters(_RealParameter('a', domain=_RealInterval()),
+                                 _RealParameter('b', domain=_RealInterval()))
         # Check that domain and string evaluation give the same result
         res = domain.contains(x, dict(a=a, b=b))
 
@@ -85,12 +89,31 @@ class Test_RealDomain:
         ref = eval(f'(a {left_comparison} x) & (x {right_comparison} b)')
         assert_equal(res, ref)
 
+    @pytest.mark.parametrize("inclusive", list(it.product([True, False], repeat=2)))
+    @pytest.mark.parametrize("a,b", [(0, 1), (3, 1)])
+    def test_contains_function_endpoints(self, inclusive, a, b):
+        # Test `contains` when endpoints are defined by functions.
+        endpoints = (lambda a, b: (a - b) / 2, lambda a, b: (a + b) / 2)
+        domain = _RealInterval(endpoints=endpoints, inclusive=inclusive)
+        x = np.asarray([(a - 2*b)/2, (a - b)/2, a/2, (a + b)/2, (a + 2*b)/2])
+        res = domain.contains(x, dict(a=a, b=b))
+
+        numerical_endpoints = ((a - b) / 2, (a + b) / 2)
+        assert numerical_endpoints == domain.get_numerical_endpoints(dict(a=a, b=b))
+        alpha, beta = numerical_endpoints
+
+        above_left = alpha <= x if inclusive[0] else alpha < x
+        below_right = x <= beta if inclusive[1] else x < beta
+        ref = above_left & below_right
+        assert_equal(res, ref)
+
+
     @pytest.mark.parametrize('case', [
         (-np.inf, np.pi, False, True, r"(-\infty, \pi]"),
         ('a', 5, True, False, "[a, 5)")
     ])
     def test_str(self, case):
-        domain = _RealDomain(endpoints=case[:2], inclusive=case[2:4])
+        domain = _RealInterval(endpoints=case[:2], inclusive=case[2:4])
         assert str(domain) == case[4]
 
     @pytest.mark.slow
@@ -105,6 +128,7 @@ class Test_RealDomain:
            inclusive_a=strategies.booleans(),
            inclusive_b=strategies.booleans(),
            )
+    @pytest.mark.thread_unsafe
     def test_str2(self, a, b, inclusive_a, inclusive_b):
         # I wrote this independently from the implementation of __str__, but
         # I imagine it looks pretty similar to __str__.
@@ -112,7 +136,7 @@ class Test_RealDomain:
         b = _Domain.symbols.get(b, b)
         left_bracket = '[' if inclusive_a else '('
         right_bracket = ']' if inclusive_b else ')'
-        domain = _RealDomain(endpoints=(a, b),
+        domain = _RealInterval(endpoints=(a, b),
                              inclusive=(inclusive_a, inclusive_b))
         ref = f"{left_bracket}{a}, {b}{right_bracket}"
         assert str(domain) == ref
@@ -120,8 +144,8 @@ class Test_RealDomain:
     def test_symbols_gh22137(self):
         # `symbols` was accidentally shared between instances originally
         # Check that this is no longer the case
-        domain1 = _RealDomain(endpoints=(0, 1))
-        domain2 = _RealDomain(endpoints=(0, 1))
+        domain1 = _RealInterval(endpoints=(0, 1))
+        domain2 = _RealInterval(endpoints=(0, 1))
         assert domain1.symbols is not domain2.symbols
 
 
@@ -153,7 +177,7 @@ def draw_distribution_from_family(family, data, rng, proportions, min_side=0):
     y = dist._variable.draw(y_shape, parameter_values=dist._parameters,
                             proportions=proportions, rng=rng, region='typical')
     xy_result_shape = np.broadcast_shapes(y_shape, x_result_shape)
-    p_domain = _RealDomain((0, 1), (True, True))
+    p_domain = _RealInterval((0, 1), (True, True))
     p_var = _RealParameter('p', domain=p_domain)
     p = p_var.draw(x_shape, proportions=proportions, rng=rng)
     with np.errstate(divide='ignore', invalid='ignore'):
@@ -162,19 +186,26 @@ def draw_distribution_from_family(family, data, rng, proportions, min_side=0):
     return dist, x, y, p, logp, result_shape, x_result_shape, xy_result_shape
 
 
-families = [
+continuous_families = [
     StandardNormal,
     Normal,
     Uniform,
     _LogUniform
 ]
 
+discrete_families = [
+    Binomial,
+]
+
+families = continuous_families + discrete_families
+
 
 class TestDistributions:
     @pytest.mark.fail_slow(60)  # need to break up check_moment_funcs
     @settings(max_examples=20)
     @pytest.mark.parametrize('family', families)
     @given(data=strategies.data(), seed=strategies.integers(min_value=0))
+    @pytest.mark.thread_unsafe
     def test_support_moments_sample(self, family, data, seed):
         rng = np.random.default_rng(seed)
 
@@ -214,6 +245,7 @@ class TestDistributions:
                               ])
     @settings(max_examples=20)
     @given(data=strategies.data(), seed=strategies.integers(min_value=0))
+    @pytest.mark.thread_unsafe
     def test_funcs(self, family, data, seed, func, methods, arg):
         if family == Uniform and func == 'mode':
             pytest.skip("Mode is not unique; `method`s disagree.")
@@ -247,6 +279,7 @@ class TestDistributions:
                     check_ccdf2(dist, False, x, y, xy_result_shape, methods)
                     check_ccdf2(dist, True, x, y, xy_result_shape, methods)
 
+    @pytest.mark.thread_unsafe
     def test_plot(self):
         try:
             import matplotlib.pyplot as plt
@@ -300,6 +333,8 @@ class TestDistributions:
         # Safe subtraction is needed in special cases
         x = np.asarray([-1e-20, -1e-21, 1e-20, 1e-21, -1e-20])
         y = np.asarray([-1e-21, -1e-20, 1e-21, 1e-20, 1e-20])
+
+
         p0 = X.pdf(0)*(y-x)
         p1 = X.cdf(x, y, method='subtraction_safe')
         p2 = X.cdf(x, y, method='subtraction')
@@ -385,7 +420,11 @@ def check_sample_shape_NaNs(dist, fname, sample_shape, result_shape, rng):
 
         sample1 = sample_method(sample_shape, method=method, rng=42)
         sample2 = sample_method(sample_shape, method=method, rng=42)
-        assert not np.any(np.equal(res, sample1))
+        if not isinstance(dist, DiscreteDistribution):
+            # The idea is that it's very unlikely that the random sample
+            # for a randomly chosen seed will match that for seed 42,
+            # but it is not so unlikely if `dist` is a discrete distribution.
+            assert not np.any(np.equal(res, sample1))
         assert_equal(sample1, sample2)
 
 
@@ -485,6 +524,13 @@ def check_cdf2(dist, log, x, y, result_shape, methods):
         assert np.isscalar(ref)
 
     for method in methods:
+        if isinstance(dist, DiscreteDistribution):
+            message = ("Two argument cdf functions are currently only supported for "
+                       "continuous distributions.")
+            with pytest.raises(NotImplementedError, match=message):
+                res = (np.exp(dist.logcdf(x, y, method=method)) if log
+                       else dist.cdf(x, y, method=method))
+            continue
         res = (np.exp(dist.logcdf(x, y, method=method)) if log
                else dist.cdf(x, y, method=method))
         np.testing.assert_allclose(res, ref, atol=1e-14)
@@ -513,6 +559,13 @@ def check_ccdf2(dist, log, x, y, result_shape, methods):
         assert np.isscalar(ref)
 
     for method in methods:
+        message = ("Two argument cdf functions are currently only supported for "
+                   "continuous distributions.")
+        if isinstance(dist, DiscreteDistribution):
+            with pytest.raises(NotImplementedError, match=message):
+                res = (np.exp(dist.logccdf(x, y, method=method)) if log
+                       else dist.ccdf(x, y, method=method))
+            continue
         res = (np.exp(dist.logccdf(x, y, method=method)) if log
                else dist.ccdf(x, y, method=method))
         np.testing.assert_allclose(res, ref, atol=1e-14)
@@ -526,9 +579,9 @@ def check_nans_and_edges(dist, fname, arg, res):
 
     valid_parameters = get_valid_parameters(dist)
     if fname in {'icdf', 'iccdf'}:
-        arg_domain = _RealDomain(endpoints=(0, 1), inclusive=(True, True))
+        arg_domain = _RealInterval(endpoints=(0, 1), inclusive=(True, True))
     elif fname in {'ilogcdf', 'ilogccdf'}:
-        arg_domain = _RealDomain(endpoints=(-inf, 0), inclusive=(True, True))
+        arg_domain = _RealInterval(endpoints=(-inf, 0), inclusive=(True, True))
     else:
         arg_domain = dist._variable.domain
 
@@ -550,50 +603,65 @@ def check_nans_and_edges(dist, fname, arg, res):
     outside_arg_plus = (outside_arg == 1) & valid_parameters
     endpoint_arg_minus = (endpoint_arg == -1) & valid_parameters
     endpoint_arg_plus = (endpoint_arg == 1) & valid_parameters
+
+    is_discrete = isinstance(dist, DiscreteDistribution)
     # Writing this independently of how the are set in the distribution
     # infrastructure. That is very compact; this is very verbose.
     if fname in {'logpdf'}:
         assert_equal(res[outside_arg_minus], -np.inf)
         assert_equal(res[outside_arg_plus], -np.inf)
-        assert_equal(res[endpoint_arg_minus & ~valid_arg], -np.inf)
-        assert_equal(res[endpoint_arg_plus & ~valid_arg], -np.inf)
+        ref = -np.inf if not is_discrete else np.inf
+        assert_equal(res[endpoint_arg_minus & ~valid_arg], ref)
+        assert_equal(res[endpoint_arg_plus & ~valid_arg], ref)
     elif fname in {'pdf'}:
         assert_equal(res[outside_arg_minus], 0)
         assert_equal(res[outside_arg_plus], 0)
-        assert_equal(res[endpoint_arg_minus & ~valid_arg], 0)
-        assert_equal(res[endpoint_arg_plus & ~valid_arg], 0)
-    elif fname in {'logcdf'}:
+        ref = 0 if not is_discrete else np.inf
+        assert_equal(res[endpoint_arg_minus & ~valid_arg], ref)
+        assert_equal(res[endpoint_arg_plus & ~valid_arg], ref)
+    elif fname in {'logcdf'} and not is_discrete:
         assert_equal(res[outside_arg_minus], -inf)
         assert_equal(res[outside_arg_plus], 0)
         assert_equal(res[endpoint_arg_minus], -inf)
         assert_equal(res[endpoint_arg_plus], 0)
-    elif fname in {'cdf'}:
+    elif fname in {'cdf'} and not is_discrete:
         assert_equal(res[outside_arg_minus], 0)
         assert_equal(res[outside_arg_plus], 1)
         assert_equal(res[endpoint_arg_minus], 0)
         assert_equal(res[endpoint_arg_plus], 1)
-    elif fname in {'logccdf'}:
+    elif fname in {'logccdf'} and not is_discrete:
         assert_equal(res[outside_arg_minus], 0)
         assert_equal(res[outside_arg_plus], -inf)
         assert_equal(res[endpoint_arg_minus], 0)
         assert_equal(res[endpoint_arg_plus], -inf)
-    elif fname in {'ccdf'}:
+    elif fname in {'ccdf'} and not is_discrete:
         assert_equal(res[outside_arg_minus], 1)
         assert_equal(res[outside_arg_plus], 0)
         assert_equal(res[endpoint_arg_minus], 1)
         assert_equal(res[endpoint_arg_plus], 0)
-    elif fname in {'ilogcdf', 'icdf'}:
+    elif fname in {'ilogcdf', 'icdf'} and not is_discrete:
         assert_equal(res[outside_arg == -1], np.nan)
         assert_equal(res[outside_arg == 1], np.nan)
         assert_equal(res[endpoint_arg == -1], a[endpoint_arg == -1])
         assert_equal(res[endpoint_arg == 1], b[endpoint_arg == 1])
-    elif fname in {'ilogccdf', 'iccdf'}:
+    elif fname in {'ilogccdf', 'iccdf'} and not is_discrete:
         assert_equal(res[outside_arg == -1], np.nan)
         assert_equal(res[outside_arg == 1], np.nan)
         assert_equal(res[endpoint_arg == -1], b[endpoint_arg == -1])
         assert_equal(res[endpoint_arg == 1], a[endpoint_arg == 1])
 
-    if fname not in {'logmean', 'mean', 'logskewness', 'skewness', 'support'}:
+    exclude = {'logmean', 'mean', 'logskewness', 'skewness', 'support'}
+    if isinstance(dist, DiscreteDistribution):
+        exclude.update({'pdf', 'logpdf'})
+
+    if (
+            fname not in exclude
+            and not (isinstance(dist, Binomial)
+                     and np.any((dist.n == 0) | (dist.p == 0) | (dist.p == 1)))):
+        # This can fail in degenerate case where Binomial distribution is a point
+        # distribution. Further on, we could factor out an is_degenerate function
+        # for the tests, or think about storing info about degeneracy in the
+        # instances.
         assert np.isfinite(res[all_valid & (endpoint_arg == 0)]).all()
 
 
@@ -623,7 +691,6 @@ def check_moment_funcs(dist, result_shape):
         orders = getattr(formula, 'orders', set(range(6)))
         return order in orders
 
-
     dist.reset_cache()
 
     ### Check Raw Moments ###
@@ -676,6 +743,7 @@ def check_moment_funcs(dist, result_shape):
             dist.moment(i, 'raw')
             check(i, 'central', 'transform', ref)
 
+    variance = dist.variance()
     dist.reset_cache()
 
     # If we have standard moment formulas, or if there are
@@ -686,9 +754,9 @@ def check_moment_funcs(dist, result_shape):
     for i in range(3, 6):
         ref = dist.moment(i, 'central', method='quadrature')
         check(i, 'central', 'normalize', ref,
-              success=has_formula(i, 'standardized'))
+              success=has_formula(i, 'standardized') and not np.any(variance == 0))
         dist.moment(i, 'standardized')  # build up the cache
-        check(i, 'central', 'normalize', ref)
+        check(i, 'central', 'normalize', ref, success=not np.any(variance == 0))
 
     ### Check Standardized Moments ###
 
@@ -701,7 +769,13 @@ def check_moment_funcs(dist, result_shape):
         assert ref.shape == result_shape
         check(i, 'standardized', 'formula', ref,
               success=has_formula(i, 'standardized'))
-        check(i, 'standardized', 'general', ref, success=i <= 2)
+        if not (
+                isinstance(dist, Binomial)
+                and np.any((dist.n == 0) | (dist.p == 0) | (dist.p == 1))
+        ):
+            # This test will fail for degenerate case where binomial distribution
+            # is a point distribution.
+            check(i, 'standardized', 'general', ref, success=i <= 2)
         check(i, 'standardized', 'normalize', ref)
 
     if isinstance(dist, ShiftedScaledDistribution):
@@ -827,7 +901,7 @@ def classify_arg(dist, arg, arg_domain):
 
 def test_input_validation():
     class Test(ContinuousDistribution):
-        _variable = _RealParameter('x', domain=_RealDomain())
+        _variable = _RealParameter('x', domain=_RealInterval())
 
     message = ("The `Test` distribution family does not accept parameters, "
                "but parameters `{'a'}` were provided.")
@@ -856,10 +930,10 @@ def test_input_validation():
         Test().moment(2, kind='coconut')
 
     class Test2(ContinuousDistribution):
-        _p1 = _RealParameter('c', domain=_RealDomain())
-        _p2 = _RealParameter('d', domain=_RealDomain())
+        _p1 = _RealParameter('c', domain=_RealInterval())
+        _p2 = _RealParameter('d', domain=_RealInterval())
         _parameterizations = [_Parameterization(_p1, _p2)]
-        _variable = _RealParameter('x', domain=_RealDomain())
+        _variable = _RealParameter('x', domain=_RealInterval())
 
     message = ("The provided parameters `{a}` do not match a supported "
                "parameterization of the `Test2` distribution family.")
@@ -1031,28 +1105,35 @@ class TestAttributes:
 
 
 class TestMakeDistribution:
-    @pytest.mark.parametrize('i, distdata', enumerate(distcont))
-    def test_make_distribution(self, i, distdata):
+    @pytest.mark.parametrize('i, distdata', enumerate(distcont + distdiscrete))
+    def test_rv_generic(self, i, distdata):
         distname = distdata[0]
 
         slow = {'argus', 'exponpow', 'exponweib', 'genexpon', 'gompertz', 'halfgennorm',
-                'johnsonsb', 'kappa4', 'ksone', 'kstwo', 'kstwobign', 'powerlognorm',
-                'powernorm', 'recipinvgauss', 'studentized_range', 'vonmises_line'}
+                'johnsonsb', 'kappa4', 'ksone', 'kstwo', 'kstwobign', 'norminvgauss',
+                'powerlognorm', 'powernorm', 'recipinvgauss', 'studentized_range',
+                'vonmises_line', # continuous
+                'betanbinom', 'logser', 'skellam', 'zipf'}  # discrete
         if not int(os.environ.get('SCIPY_XSLOW', '0')) and distname in slow:
             pytest.skip('Skipping as XSLOW')
 
-        if distname in {  # skip these distributions
-            'levy_stable',  # private methods seem to require >= 1d args
-            'vonmises',  # circular distribution; shouldn't work
+        if distname in {              # skip these distributions
+            'levy_stable',            # private methods seem to require >= 1d args
+            'vonmises',               # circular distribution; shouldn't work
+            'poisson_binom',          # vector shape parameter
+            'hypergeom',              # distribution functions need interpolation
+            'nchypergeom_fisher',     # distribution functions need interpolation
+            'nchypergeom_wallenius',  # distribution functions need interpolation
         }:
             return
 
         # skip single test, mostly due to slight disagreement
         custom_tolerances = {'ksone': 1e-5, 'kstwo': 1e-5}  # discontinuous PDF
         skip_entropy = {'kstwobign', 'pearson3'}  # tolerance issue
-        skip_skewness = {'exponpow', 'ksone'}  # tolerance issue
-        skip_kurtosis = {'chi', 'exponpow', 'invgamma',  # tolerance issue
-                         'johnsonsb', 'ksone', 'kstwo'}  # tolerance issue
+        skip_skewness = {'exponpow', 'ksone', 'nchypergeom_wallenius'}  # tolerance
+        skip_kurtosis = {'chi', 'exponpow', 'invgamma',  # tolerance
+                         'johnsonsb', 'ksone', 'kstwo',  # tolerance
+                         'nchypergeom_wallenius'}  # tolerance
         skip_logccdf = {'arcsine', 'skewcauchy', 'trapezoid', 'triang'}  # tolerance
         skip_raw = {2: {'alpha', 'foldcauchy', 'halfcauchy', 'levy', 'levy_l'},
                     3: {'pareto'},  # stats.pareto is just wrong
@@ -1075,6 +1156,10 @@ class TestMakeDistribution:
             assert_allclose(X.support(), Y.support())
             if distname not in skip_entropy:
                 assert_allclose(X.entropy(), Y.entropy(), rtol=rtol)
+            if isinstance(Y, stats.rv_discrete):
+                # some continuous distributions have trouble with `logentropy` because
+                # it uses complex numbers
+                assert_allclose(np.exp(X.logentropy()), Y.entropy(), rtol=rtol)
             assert_allclose(X.median(), Y.median(), rtol=rtol)
             assert_allclose(X.mean(), m, rtol=rtol, atol=atol)
             assert_allclose(X.variance(), v, rtol=rtol, atol=atol)
@@ -1083,15 +1168,29 @@ class TestMakeDistribution:
             if distname not in skip_kurtosis:
                 assert_allclose(X.kurtosis(convention='excess'), k,
                                 rtol=rtol, atol=atol)
-            assert_allclose(X.logpdf(x), Y.logpdf(x), rtol=rtol)
-            assert_allclose(X.pdf(x), Y.pdf(x), rtol=rtol)
+            if isinstance(dist, stats.rv_continuous):
+                assert_allclose(X.logpdf(x), Y.logpdf(x), rtol=rtol)
+                assert_allclose(X.pdf(x), Y.pdf(x), rtol=rtol)
+            else:
+                assert_allclose(X.logpmf(x), Y.logpmf(x), rtol=rtol)
+                assert_allclose(X.pmf(x), Y.pmf(x), rtol=rtol)
             assert_allclose(X.logcdf(x), Y.logcdf(x), rtol=rtol)
             assert_allclose(X.cdf(x), Y.cdf(x), rtol=rtol)
             if distname not in skip_logccdf:
                 assert_allclose(X.logccdf(x), Y.logsf(x), rtol=rtol)
             assert_allclose(X.ccdf(x), Y.sf(x), rtol=rtol)
-            assert_allclose(X.icdf(p), Y.ppf(p), rtol=rtol)
-            assert_allclose(X.iccdf(p), Y.isf(p), rtol=rtol)
+
+            # old infrastructure convention for ppf(p=0) and isf(p=1) is different than
+            # new infrastructure. Adjust reference values accordingly.
+            a, _ = Y.support()
+            ref_ppf = Y.ppf(p)
+            ref_ppf[p == 0] = a
+            ref_isf = Y.isf(p)
+            ref_isf[p == 1] = a
+
+            assert_allclose(X.icdf(p), ref_ppf, rtol=rtol)
+            assert_allclose(X.iccdf(p), ref_isf, rtol=rtol)
+
             for order in range(5):
                 if distname not in skip_raw.get(order, {}):
                     assert_allclose(X.moment(order, kind='raw'),
@@ -1100,10 +1199,222 @@ class TestMakeDistribution:
                 if distname not in skip_standardized:
                     assert_allclose(X.moment(order, kind='standardized'),
                                     Y.stats('mvsk'[order-1]), rtol=rtol, atol=atol)
-            seed = 845298245687345
-            assert_allclose(X.sample(shape=10, rng=seed),
-                            Y.rvs(size=10, random_state=np.random.default_rng(seed)),
-                            rtol=rtol)
+            if isinstance(dist, stats.rv_continuous):
+                # For discrete distributions, these won't agree at the far left end
+                # of the support, and the new infrastructure is slow there (for now).
+                seed = 845298245687345
+                assert_allclose(X.sample(shape=10, rng=seed),
+                                Y.rvs(size=10,
+                                      random_state=np.random.default_rng(seed)),
+                                rtol=rtol)
+
+    def test_custom(self):
+        rng = np.random.default_rng(7548723590230982)
+
+        class MyLogUniform:
+            @property
+            def __make_distribution_version__(self):
+                return "1.16.0"
+
+            @property
+            def parameters(self):
+                return {'a': {'endpoints': (0, np.inf), 'inclusive': (False, False)},
+                        'b': {'endpoints': ('a', np.inf), 'inclusive': (False, False)}}
+
+            @property
+            def support(self):
+                return {'endpoints': ('a', 'b')}
+
+            def pdf(self, x, a, b):
+                return 1 / (x * (np.log(b) - np.log(a)))
+
+            def sample(self, shape, *, a, b, rng=None):
+                p = rng.uniform(size=shape)
+                return np.exp(np.log(a) + p * (np.log(b) - np.log(a)))
+
+            def moment(self, order, kind='raw', *, a, b):
+                if order == 1 and kind == 'raw':
+                    # quadrature is perfectly accurate here; add 1e-10 error so we
+                    # can tell the difference between the two
+                    return (b - a) / np.log(b/a) + 1e-10
+
+        LogUniform = stats.make_distribution(MyLogUniform())
+
+        X = LogUniform(a=np.exp(1), b=np.exp(3))
+        Y = stats.exp(Uniform(a=1., b=3.))
+        x = X.sample(shape=10, rng=rng)
+        p = X.cdf(x)
+
+        assert_allclose(X.support(), Y.support())
+        assert_allclose(X.entropy(), Y.entropy())
+        assert_allclose(X.median(), Y.median())
+        assert_allclose(X.logpdf(x), Y.logpdf(x))
+        assert_allclose(X.pdf(x), Y.pdf(x))
+        assert_allclose(X.logcdf(x), Y.logcdf(x))
+        assert_allclose(X.cdf(x), Y.cdf(x))
+        assert_allclose(X.logccdf(x), Y.logccdf(x))
+        assert_allclose(X.ccdf(x), Y.ccdf(x))
+        assert_allclose(X.icdf(p), Y.icdf(p))
+        assert_allclose(X.iccdf(p), Y.iccdf(p))
+        for kind in ['raw', 'central', 'standardized']:
+            for order in range(5):
+                assert_allclose(X.moment(order, kind=kind),
+                                Y.moment(order, kind=kind))
+
+        # Confirm that the `sample` and `moment` methods are overriden as expected
+        sample_formula = X.sample(shape=10, rng=0, method='formula')
+        sample_inverse = X.sample(shape=10, rng=0, method='inverse_transform')
+        assert_allclose(sample_formula, sample_inverse)
+        assert not np.all(sample_formula == sample_inverse)
+
+        assert_allclose(X.mean(method='formula'), X.mean(method='quadrature'))
+        assert not X.mean(method='formula') == X.mean(method='quadrature')
+
+    # pdf and cdf formulas below can warn on boundary of support in some cases.
+    # See https://github.com/scipy/scipy/pull/22560#discussion_r1962763840.
+    @pytest.mark.slow
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    @pytest.mark.parametrize("c", [-1, 0, 1, np.asarray([-2.1, -1., 0., 1., 2.1])])
+    def test_custom_variable_support(self, c):
+        rng = np.random.default_rng(7548723590230982)
+
+        class MyGenExtreme:
+            @property
+            def __make_distribution_version__(self):
+                return "1.16.0"
+
+            @property
+            def parameters(self):
+                return {
+                    'c': {'endpoints': (-np.inf, np.inf), 'inclusive': (False, False)},
+                    'mu': {'endpoints': (-np.inf, np.inf), 'inclusive': (False, False)},
+                    'sigma': {'endpoints': (0, np.inf), 'inclusive': (False, False)}
+                }
+
+            @property
+            def support(self):
+                def left(*, c, mu, sigma):
+                    c, mu, sigma = np.broadcast_arrays(c, mu, sigma)
+                    result = np.empty_like(c)
+                    result[c >= 0] = -np.inf
+                    result[c < 0] = mu[c < 0] + sigma[c < 0] / c[c < 0]
+                    return result[()]
+
+                def right(*, c, mu, sigma):
+                    c, mu, sigma = np.broadcast_arrays(c, mu, sigma)
+                    result = np.empty_like(c)
+                    result[c <= 0] = np.inf
+                    result[c > 0] = mu[c > 0] + sigma[c > 0] / c[c > 0]
+                    return result[()]
+
+                return {"endpoints": (left, right), "inclusive": (False, False)}
+
+            def pdf(self, x, *, c, mu, sigma):
+                x, c, mu, sigma = np.broadcast_arrays(x, c, mu, sigma)
+                t = np.empty_like(x)
+                mask = (c == 0)
+                t[mask] = np.exp(-(x[mask] - mu[mask])/sigma[mask])
+                t[~mask] = (
+                    1  - c[~mask]*(x[~mask] - mu[~mask])/sigma[~mask]
+                )**(1/c[~mask])
+                result = 1/sigma * t**(1 - c)*np.exp(-t)
+                return result[()]
+
+            def cdf(self, x, *, c, mu, sigma):
+                x, c, mu, sigma = np.broadcast_arrays(x, c, mu, sigma)
+                t = np.empty_like(x)
+                mask = (c == 0)
+                t[mask] = np.exp(-(x[mask] - mu[mask])/sigma[mask])
+                t[~mask] = (
+                    1  - c[~mask]*(x[~mask] - mu[~mask])/sigma[~mask]
+                )**(1/c[~mask])
+                return np.exp(-t)[()]
+
+        GenExtreme1 = stats.make_distribution(MyGenExtreme())
+        GenExtreme2 = stats.make_distribution(stats.genextreme)
+
+        X1 = GenExtreme1(c=c, mu=0, sigma=1)
+        X2 = GenExtreme2(c=c)
+
+        x = X1.sample(shape=10, rng=rng)
+        p = X1.cdf(x)
+
+        assert_allclose(X1.support(), X2.support())
+        assert_allclose(X1.entropy(), X2.entropy(), rtol=5e-6)
+        assert_allclose(X1.median(), X2.median())
+        assert_allclose(X1.logpdf(x), X2.logpdf(x))
+        assert_allclose(X1.pdf(x), X2.pdf(x))
+        assert_allclose(X1.logcdf(x), X2.logcdf(x))
+        assert_allclose(X1.cdf(x), X2.cdf(x))
+        assert_allclose(X1.logccdf(x), X2.logccdf(x))
+        assert_allclose(X1.ccdf(x), X2.ccdf(x))
+        assert_allclose(X1.icdf(p), X2.icdf(p))
+        assert_allclose(X1.iccdf(p), X2.iccdf(p))
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("a", [0.5, np.asarray([0.5, 1.0, 2.0, 4.0, 8.0])])
+    @pytest.mark.parametrize("b", [0.5, np.asarray([0.5, 1.0, 2.0, 4.0, 8.0])])
+    def test_custom_multiple_parameterizations(self, a, b):
+        rng = np.random.default_rng(7548723590230982)
+        class MyBeta:
+            @property
+            def __make_distribution_version__(self):
+                return "1.16.0"
+
+            @property
+            def parameters(self):
+                return (
+                    {"a": (0, np.inf), "b": (0, np.inf)},
+                    {"mu": (0, 1), "nu": (0, np.inf)},
+                )
+
+            def process_parameters(self, a=None, b=None, mu=None, nu=None):
+                if a is not None and b is not None and mu is None and nu is None:
+                    nu = a + b
+                    mu = a / nu
+                else:
+                    a = mu * nu
+                    b = nu - a
+                return {"a": a, "b": b, "mu": mu, "nu": nu}
+
+            @property
+            def support(self):
+                return {'endpoints': (0, 1)}
+
+            def pdf(self, x, a, b, mu, nu):
+                return special._ufuncs._beta_pdf(x, a, b)
+
+            def cdf(self, x, a, b, mu, nu):
+                return special.betainc(a, b, x)
+
+        Beta = stats.make_distribution(stats.beta)
+        MyBeta = stats.make_distribution(MyBeta())
+
+        mu = a / (a + b)
+        nu = a + b
+
+        X = MyBeta(a=a, b=b)
+        Y = MyBeta(mu=mu, nu=nu)
+        Z = Beta(a=a, b=b)
+
+        x = Z.sample(shape=10, rng=rng)
+        p = Z.cdf(x)
+
+        assert_allclose(X.support(), Z.support())
+        assert_allclose(X.median(), Z.median())
+        assert_allclose(X.pdf(x), Z.pdf(x))
+        assert_allclose(X.cdf(x), Z.cdf(x))
+        assert_allclose(X.ccdf(x), Z.ccdf(x))
+        assert_allclose(X.icdf(p), Z.icdf(p))
+        assert_allclose(X.iccdf(p), Z.iccdf(p))
+
+        assert_allclose(Y.support(), Z.support())
+        assert_allclose(Y.median(), Z.median())
+        assert_allclose(Y.pdf(x), Z.pdf(x))
+        assert_allclose(Y.cdf(x), Z.cdf(x))
+        assert_allclose(Y.ccdf(x), Z.ccdf(x))
+        assert_allclose(Y.icdf(p), Z.icdf(p))
+        assert_allclose(Y.iccdf(p), Z.iccdf(p))
 
     def test_input_validation(self):
         message = '`levy_stable` is not supported.'
@@ -1114,7 +1425,7 @@ class TestMakeDistribution:
         with pytest.raises(NotImplementedError, match=message):
             stats.make_distribution(stats.vonmises)
 
-        message = "The argument must be an instance of `rv_continuous`."
+        message = "The argument must be an instance of..."
         with pytest.raises(ValueError, match=message):
             stats.make_distribution(object())
 
@@ -1138,7 +1449,14 @@ class TestMakeDistribution:
 
 class TestTransforms:
 
-    # putting this at the top to hopefully avoid merge conflicts
+    def test_ContinuousDistribution_only(self):
+        X = stats.Binomial(n=10, p=0.5)
+        # This is applied at the top level TransformedDistribution,
+        # so testing one subclass is enough
+        message = "Transformations are currently only supported for continuous RVs."
+        with pytest.raises(NotImplementedError, match=message):
+            stats.exp(X)
+
     def test_truncate(self):
         rng = np.random.default_rng(81345982345826)
         lb = rng.random((3, 1))
@@ -1175,6 +1493,7 @@ class TestTransforms:
 
     @pytest.mark.fail_slow(10)
     @given(data=strategies.data(), seed=strategies.integers(min_value=0))
+    @pytest.mark.thread_unsafe
     def test_loc_scale(self, data, seed):
         # Need tests with negative scale
         rng = np.random.default_rng(seed)
@@ -1612,7 +1931,7 @@ class TestFullCoverage:
                               [(np.float16, np.float16),
                                (np.int16, np.float64)])
     def test_RealParameter_uncommon_dtypes(self, dtype_in, dtype_out):
-        domain = _RealDomain((-1, 1))
+        domain = _RealInterval((-1, 1))
         parameter = _RealParameter('x', domain=domain)
 
         x = np.asarray([0.5, 2.5], dtype=dtype_in)
@@ -1627,7 +1946,7 @@ class TestFullCoverage:
         # to return the right shape and dytpe, but this would need to be
         # configurable.
         class TestDist(ContinuousDistribution):
-            _variable = _RealParameter('x', domain=_RealDomain(endpoints=(0., 1.)))
+            _variable = _RealParameter('x', domain=_RealInterval(endpoints=(0., 1.)))
             def _logpdf_formula(self, x, *args, **kwargs):
                 return 0
 
@@ -1754,7 +2073,7 @@ class TestReprs:
 
 
 class MixedDist(ContinuousDistribution):
-    _variable = _RealParameter('x', domain=_RealDomain(endpoints=(-np.inf, np.inf)))
+    _variable = _RealParameter('x', domain=_RealInterval(endpoints=(-np.inf, np.inf)))
     def _pdf_formula(self, x, *args, **kwargs):
         return (0.4 * 1/(1.1 * np.sqrt(2*np.pi)) * np.exp(-0.5*((x+0.25)/1.1)**2)
                 + 0.6 * 1/(0.9 * np.sqrt(2*np.pi)) * np.exp(-0.5*((x-0.5)/0.9)**2))