Do not test invalid parameter combinations

Author: ricardoV94

tests/distributions/test_continuous.py

@@ -159,14 +159,6 @@ def laplace_asymmetric_logpdf(value, kappa, b, mu):
     return lPx
 
 
-def beta_mu_sigma(value, mu, sigma):
-    kappa = mu * (1 - mu) / sigma**2 - 1
-    if kappa > 0:
-        return st.beta.logpdf(value, mu * kappa, (1 - mu) * kappa)
-    else:
-        return -np.inf
-
-
 class TestMatchesScipy:
     def test_uniform(self):
         check_logp(
@@ -367,10 +359,18 @@ def test_beta_logp(self):
             {"alpha": Rplus, "beta": Rplus},
             lambda value, alpha, beta: st.beta.logpdf(value, alpha, beta),
         )
+
+        def beta_mu_sigma(value, mu, sigma):
+            kappa = mu * (1 - mu) / sigma**2 - 1
+            return st.beta.logpdf(value, mu * kappa, (1 - mu) * kappa)
+
+        # The mu/sigma parametrization is not always valid
+        safe_mu_domain = Domain([0, 0.3, 0.5, 0.8, 1])
+        safe_sigma_domain = Domain([0, 0.05, 0.1, np.inf])
         check_logp(
             pm.Beta,
             Unit,
-            {"mu": Unit, "sigma": Rplus},
+            {"mu": safe_mu_domain, "sigma": safe_sigma_domain},
             beta_mu_sigma,
         )
 

tests/distributions/test_discrete.py

@@ -145,13 +145,7 @@ def test_geometric(self):
         )
 
     def test_hypergeometric(self):
-        def modified_scipy_hypergeom_logpmf(value, N, k, n):
-            # Convert nan to -np.inf
-            original_res = st.hypergeom.logpmf(value, N, k, n)
-            return original_res if not np.isnan(original_res) else -np.inf
-
         def modified_scipy_hypergeom_logcdf(value, N, k, n):
-            # Convert nan to -np.inf
             original_res = st.hypergeom.logcdf(value, N, k, n)
 
             # Correct for scipy bug in logcdf method (see https://github.com/scipy/scipy/issues/13280)
@@ -160,24 +154,27 @@ def modified_scipy_hypergeom_logcdf(value, N, k, n):
                 if np.all(np.isnan(pmfs)):
                     original_res = np.nan
 
-            return original_res if not np.isnan(original_res) else -np.inf
+            return original_res
+
+        N_domain = Domain([0, 10, 20, 30, np.inf], dtype="int64")
+        n_domain = k_domain = Domain([0, 1, 2, 3, np.inf], dtype="int64")
 
         check_logp(
             pm.HyperGeometric,
             Nat,
-            {"N": NatSmall, "k": NatSmall, "n": NatSmall},
-            modified_scipy_hypergeom_logpmf,
+            {"N": N_domain, "k": k_domain, "n": n_domain},
+            lambda value, N, k, n: st.hypergeom.logpmf(value, N, k, n),
         )
         check_logcdf(
             pm.HyperGeometric,
             Nat,
-            {"N": NatSmall, "k": NatSmall, "n": NatSmall},
+            {"N": N_domain, "k": k_domain, "n": n_domain},
             modified_scipy_hypergeom_logcdf,
         )
         check_selfconsistency_discrete_logcdf(
             pm.HyperGeometric,
             Nat,
-            {"N": NatSmall, "k": NatSmall, "n": NatSmall},
+            {"N": N_domain, "k": k_domain, "n": n_domain},
         )
 
     @pytest.mark.xfail(
@@ -535,15 +532,17 @@ def test_categorical_p_not_normalized_symbolic(self):
 
     @pytest.mark.parametrize("n", [2, 3, 4])
     def test_orderedlogistic(self, n):
-        with warnings.catch_warnings():
-            warnings.filterwarnings("ignore", "invalid value encountered in log", RuntimeWarning)
-            warnings.filterwarnings("ignore", "divide by zero encountered in log", RuntimeWarning)
-            check_logp(
-                pm.OrderedLogistic,
-                Domain(range(n), dtype="int64", edges=(None, None)),
-                {"eta": R, "cutpoints": Vector(R, n - 1)},
-                lambda value, eta, cutpoints: orderedlogistic_logpdf(value, eta, cutpoints),
-            )
+        cutpoints_domain = Vector(R, n - 1)
+        # Filter out invalid non-monotonic values
+        cutpoints_domain.vals = [v for v in cutpoints_domain.vals if np.all(np.diff(v) > 0)]
+        assert len(cutpoints_domain.vals) > 0
+
+        check_logp(
+            pm.OrderedLogistic,
+            Domain(range(n), dtype="int64", edges=(None, None)),
+            {"eta": R, "cutpoints": cutpoints_domain},
+            lambda value, eta, cutpoints: orderedlogistic_logpdf(value, eta, cutpoints),
+        )
 
     @pytest.mark.parametrize("n", [2, 3, 4])
     def test_orderedprobit(self, n):