From 64ebbfc41b778714733312ee303b8a0fcfcf406e Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Fri, 29 May 2026 11:13:11 -0700
Subject: [PATCH 01/30] Initial implementation with arcsine testing

---
 test/test_arcsine.cpp      |  65 +--------------------
 test/test_dist_helpers.hpp | 114 +++++++++++++++++++++++++++++++++++++
 2 files changed, 116 insertions(+), 63 deletions(-)
 create mode 100644 test/test_dist_helpers.hpp

diff --git a/test/test_arcsine.cpp b/test/test_arcsine.cpp
index dc2fba919e..9fd1a174d9 100644
--- a/test/test_arcsine.cpp
+++ b/test/test_arcsine.cpp
@@ -38,6 +38,7 @@ using boost::math::constants::one_div_root_two;
 #include <cmath>
 
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 using std::cout;
@@ -65,21 +66,6 @@ void test_ignore_policy(RealType)
     RealType nan = std::numeric_limits<RealType>::quiet_NaN();
 
     using boost::math::policies::policy;
-    // Types of error whose action can be altered by policies:.
-    //using boost::math::policies::evaluation_error;
-    //using boost::math::policies::domain_error;
-    //using boost::math::policies::overflow_error;
-    //using boost::math::policies::underflow_error;
-    //using boost::math::policies::domain_error;
-    //using boost::math::policies::pole_error;
-
-    //// Actions on error (in enum error_policy_type):
-    //using boost::math::policies::errno_on_error;
-    //using boost::math::policies::ignore_error;
-    //using boost::math::policies::throw_on_error;
-    //using boost::math::policies::denorm_error;
-    //using boost::math::policies::pole_error;
-    //using boost::math::policies::user_error;
 
     typedef policy<
       boost::math::policies::domain_error<boost::math::policies::ignore_error>,
@@ -105,39 +91,6 @@ void test_ignore_policy(RealType)
         //std::cout << "pdf(ignore_error_arcsine(-1, +1), std::numeric_limits<RealType>::infinity()) = " << pdf(ignore_error_arcsine(-1, +1), std::numeric_limits<RealType>::infinity()) << std::endl;
         //  Outputs:  pdf(ignore_error_arcsine(-1, +1), std::numeric_limits<RealType>::infinity()) = 1.#QNAN
       }
-      // PDF
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_arcsine(0, 1), std::numeric_limits<RealType>::infinity()))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_arcsine(-1, 1), std::numeric_limits<RealType>::infinity()))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_arcsine(0, 1), static_cast <RealType>(-2))));  // x < xmin
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_arcsine(-1, 1), static_cast <RealType>(-2))));  // x < xmin
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_arcsine(0, 1), static_cast <RealType>(+2))));  // x > x_max
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_arcsine(-1, 1), static_cast <RealType>(+2)))); // x > x_max
-
-      // Logpdf
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_arcsine(0, 1), std::numeric_limits<RealType>::infinity()))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_arcsine(-1, 1), std::numeric_limits<RealType>::infinity()))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_arcsine(0, 1), static_cast <RealType>(-2))));  // x < xmin
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_arcsine(-1, 1), static_cast <RealType>(-2))));  // x < xmin
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_arcsine(0, 1), static_cast <RealType>(+2))));  // x > x_max
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_arcsine(-1, 1), static_cast <RealType>(+2)))); // x > x_max
-
-      // CDF
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_arcsine(0, 1), std::numeric_limits<RealType>::infinity()))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_arcsine(-1, 1), std::numeric_limits<RealType>::infinity()))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_arcsine(0, 1), static_cast <RealType>(-2))));  // x < xmin
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_arcsine(-1, 1), static_cast <RealType>(-2))));  // x < xmin
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_arcsine(0, 1), static_cast <RealType>(+2))));  // x > x_max
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_arcsine(-1, 1), static_cast <RealType>(+2)))); // x > x_max
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_arcsine(0, 1), std::numeric_limits<RealType>::infinity())))); // x == infinity
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_arcsine(0, 1), static_cast <RealType>(-2)))));  // x < xmin
-
-      // Quantile
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_arcsine(0, 1), std::numeric_limits<RealType>::infinity()))); // p == infinity
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_arcsine(0, 1), static_cast<RealType>(-1)))); // p < 0
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_arcsine(0, 1), static_cast<RealType>(2)))); // p > 1
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_arcsine(0, 1), std::numeric_limits<RealType>::infinity())))); // q == infinity
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_arcsine(0, 1), static_cast<RealType>(-1))))); // q < 0
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_arcsine(0, 1), static_cast<RealType>(2))))); // q > 1
 
       // Mean
       BOOST_CHECK((boost::math::isnan)(mean(ignore_error_arcsine(-nan, 0))));
@@ -201,6 +154,7 @@ void test_ignore_policy(RealType)
     BOOST_CHECK(boost::math::isfinite(mean(ignore_error_arcsine(0, std::numeric_limits<RealType>::epsilon()))));
 
     check_support<arcsine_distribution<RealType> >(arcsine_distribution<RealType>(0, 1));
+    test_invalid_support<arcsine_distribution, RealType>();
   } // ordinary floats.
 } // template <class RealType> void test_ignore_policy(RealType)
 
@@ -363,7 +317,6 @@ void test_spots(RealType)
     BOOST_CHECK_CLOSE_FRACTION(cdf(complement(arcsine_01, 0.95)), static_cast<RealType>(0.14356629312870627075094188477505571882161519989741L), 8 * tolerance); // 2 for asin
     BOOST_CHECK_CLOSE_FRACTION(cdf(complement(arcsine_01, 0.999999)), static_cast<RealType>(1 - 0.99936338012152907551581622632042615133907872213939L), 1000000 * tolerance); // 10000 for asin, 1000000 for acos.
 
-    // Quantile.
 
     // Check 1st, 2nd and 3rd quartiles.
     BOOST_CHECK_CLOSE_FRACTION(quantile(arcsine_01, static_cast<RealType>(0.25L)), static_cast<RealType>(0.14644660940672624L), tolerance);
@@ -471,10 +424,6 @@ void test_spots(RealType)
     BOOST_CHECK_CLOSE_FRACTION(quantile(as_m2m1, static_cast<RealType>(0.85643370687129372924905811522494428117838480010259L)), -static_cast<RealType>(1.05L), 2 * tolerance); //
     BOOST_CHECK_CLOSE_FRACTION(quantile(as_m2m1, static_cast<RealType>(0.5L)), -static_cast<RealType>(1.5L), 2 * tolerance);                             //
     BOOST_CHECK_CLOSE_FRACTION(quantile(as_m2m1, static_cast<RealType>(0.14356629312870627075094188477505571882161519989741L)), -static_cast<RealType>(1.95L), 4 * tolerance);     //
-    BOOST_CHECK_EQUAL(quantile(as_m2m1, 1), 1);
-    BOOST_CHECK_EQUAL(quantile(as_m2m1, 0), 0); 
-    BOOST_CHECK_EQUAL(quantile(complement(as_m2m1, 1)), 0);
-    BOOST_CHECK_EQUAL(quantile(complement(as_m2m1, 0)), 1); 
 
     BOOST_CHECK_CLOSE_FRACTION(quantile(complement(as_m2m1, static_cast<RealType>(0.14356629312870627075094188477505571882161519989741L))), -static_cast<RealType>(1.05L), 2 * tolerance); //
     BOOST_CHECK_CLOSE_FRACTION(quantile(as_m2m1, static_cast<RealType>(0.5L)), -static_cast<RealType>(1.5L), 2 * tolerance);                             //
@@ -541,16 +490,6 @@ void test_spots(RealType)
     BOOST_CHECK_THROW(arcsine_distribution<RealType>(+1, -1), std::domain_error); // max < min.
     BOOST_CHECK_THROW(arcsine_distribution<RealType>(+1, 0), std::domain_error);  // max < min.
 
-    arcsine_distribution<> dist;
-    BOOST_CHECK_THROW(pdf(dist, -1), std::domain_error);
-    BOOST_CHECK_THROW(logpdf(dist, -1), std::domain_error);
-    BOOST_CHECK_THROW(cdf(dist, -1), std::domain_error);
-    BOOST_CHECK_THROW(cdf(complement(dist, -1)), std::domain_error);
-    BOOST_CHECK_THROW(quantile(dist, -1), std::domain_error);
-    BOOST_CHECK_THROW(quantile(complement(dist, -1)), std::domain_error);
-    BOOST_CHECK_THROW(quantile(dist, -1), std::domain_error);
-    BOOST_CHECK_THROW(quantile(complement(dist, -1)), std::domain_error);
-
     // Various combinations of bad constructor and member function parameters.
     BOOST_CHECK_THROW(pdf(boost::math::arcsine_distribution<RealType>(0, 1), -1), std::domain_error);
     BOOST_CHECK_THROW(pdf(boost::math::arcsine_distribution<RealType>(-1, 1), +2), std::domain_error);
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
new file mode 100644
index 0000000000..38e16c1d56
--- /dev/null
+++ b/test/test_dist_helpers.hpp
@@ -0,0 +1,114 @@
+#include <utility>
+#include <limits>
+#include <stdexcept>
+#include <boost/math/tools/precision.hpp>
+#include <boost/math/special_functions/next.hpp>
+#include <boost/test/unit_test.hpp>
+
+template <template <typename, typename> typename Distribution, class Real>
+void test_invalid_support()
+{
+    using boost::math::policies::policy;
+    typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+    > ignore_all_policy;
+
+    Distribution<Real, ignore_all_policy> ignore_error_dist;
+    Distribution<Real, policy<> > dist; 
+    
+    /* We will assume that std::numeric_limits<Distribution::value_type>::has_infinity */
+    std::pair<Real, Real> sup = support(dist);
+
+    // Test outside lower bound:
+    Real invalid = sup.first;
+    if (boost::math::isfinite(invalid))
+    {
+        if (invalid == -boost::math::tools::max_value<Real>())
+            invalid = -std::numeric_limits<Real>::infinity();
+        else
+            invalid = boost::math::float_prior(invalid);
+
+        // Test PDF/CDF
+        BOOST_MATH_CHECK_THROW(pdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(cdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
+
+        // Test log PDF/CDF
+        BOOST_MATH_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
+    }
+    // Test outside upper bound:
+    invalid = sup.second;
+    if (boost::math::isfinite(invalid))
+    {
+        if (invalid == boost::math::tools::max_value<Real>())
+            invalid = std::numeric_limits<Real>::infinity();
+        else
+            invalid = boost::math::float_next(invalid);
+        // Test PDF/CDF
+        BOOST_MATH_CHECK_THROW(pdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(cdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
+        // Test NaN handnling
+        BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
+
+        // Test log PDF/CDF
+        BOOST_MATH_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
+        BOOST_MATH_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
+        BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
+    }
+
+    // NaN checks for PDF/CDF
+    invalid = std::numeric_limits<Real>::quiet_NaN();
+    BOOST_MATH_CHECK_THROW(pdf(dist, invalid), std::domain_error);
+    BOOST_MATH_CHECK_THROW(cdf(dist, invalid), std::domain_error);
+    BOOST_MATH_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
+    BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
+    BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
+    BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
+
+    // NaN checks for log PDF/CDF
+    invalid = std::numeric_limits<Real>::quiet_NaN();
+    BOOST_MATH_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
+    BOOST_MATH_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
+    BOOST_MATH_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
+    BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_dist, invalid)));
+    BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
+    BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
+
+    // Quantile Checks
+    BOOST_MATH_CHECK_THROW(quantile(dist, std::numeric_limits<Real>::infinity()), std::domain_error); // p == infinity
+    BOOST_MATH_CHECK_THROW(quantile(dist, static_cast<Real>(-1)), std::domain_error); // p < 0
+    BOOST_MATH_CHECK_THROW(quantile(dist, static_cast<Real>(2)), std::domain_error); // p > 1
+    BOOST_MATH_CHECK_THROW(quantile(complement(dist, std::numeric_limits<Real>::infinity())), std::domain_error); // q == infinity
+    BOOST_MATH_CHECK_THROW(quantile(complement(dist, static_cast<Real>(-1))), std::domain_error); // q < 0
+    BOOST_MATH_CHECK_THROW(quantile(complement(dist, static_cast<Real>(2))), std::domain_error); // q > 1
+    BOOST_CHECK_EQUAL(quantile(dist, static_cast<Real>(1)), static_cast<Real>(1)); // p = 1
+    BOOST_CHECK_EQUAL(quantile(dist, static_cast<Real>(0)), static_cast<Real>(0)); // p = 0
+    BOOST_CHECK_EQUAL(quantile(complement(dist, static_cast<Real>(1))), static_cast<Real>(0)); // q = 1
+    BOOST_CHECK_EQUAL(quantile(complement(dist, static_cast<Real>(0))), static_cast<Real>(1)); // q = 0
+
+    BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_dist, std::numeric_limits<Real>::infinity()))); // p == infinity
+    BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_dist, static_cast<Real>(-1)))); // p < 0
+    BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_dist, static_cast<Real>(2)))); // p > 1
+    BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, std::numeric_limits<Real>::infinity())))); // q == infinity
+    BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, static_cast<Real>(-1))))); // q < 0
+    BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, static_cast<Real>(2))))); // q > 1
+}
\ No newline at end of file

From 4a08e16bd5117e83549d146a4876a531d44fa780 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Fri, 29 May 2026 12:33:49 -0700
Subject: [PATCH 02/30] Deleted bernoulli tests

---
 test/test_bernoulli.cpp | 38 ++------------------------------------
 1 file changed, 2 insertions(+), 36 deletions(-)

diff --git a/test/test_bernoulli.cpp b/test/test_bernoulli.cpp
index 256a897783..3cb62ed717 100644
--- a/test/test_bernoulli.cpp
+++ b/test/test_bernoulli.cpp
@@ -35,6 +35,7 @@ using boost::math::bernoulli_distribution;
 #define BOOST_TEST_MAIN
 #include <boost/test/unit_test.hpp> // for test_main
 #include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION, BOOST_CHECK_EQUAL...
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 using std::cout;
@@ -285,45 +286,10 @@ void test_spots(RealType)
      BOOST_MATH_CHECK_THROW(quantile(complement(w, +inf)), std::domain_error); // p = + inf
    } // has_infinity
    #endif
-   
-   using boost::math::policies::policy;
-   typedef policy<
-      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-    > ignore_all_policy;
-
-   typedef bernoulli_distribution<RealType, ignore_all_policy> ignore_error_bernoulli;
 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
     {
-      // PDF
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_bernoulli(0.5), std::numeric_limits<RealType>::infinity()))); // k == infinity
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_bernoulli(0.5), 2))); // k > 1
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_bernoulli(0.5), static_cast<RealType>(0.5)))); // k != 0, 1
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_bernoulli(0.5), static_cast<RealType>(-0.5)))); // k != 0, 1
-
-      // CDF
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_bernoulli(0.5), std::numeric_limits<RealType>::infinity()))); // k == infinity
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_bernoulli(0.5), 2))); // k > 1
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_bernoulli(0.5), static_cast<RealType>(0.5)))); // k != 0, 1
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_bernoulli(0.5), static_cast<RealType>(-0.5)))); // k != 0, 1
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_bernoulli(0.5), std::numeric_limits<RealType>::infinity())))); // k == infinity
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_bernoulli(0.5), 2)))); // k > 1
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_bernoulli(0.5), static_cast<RealType>(0.5))))); // k != 0, 1
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_bernoulli(0.5), static_cast<RealType>(-0.5))))); // k != 0, 1
-
-      // // Quantile
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_bernoulli(0.5), std::numeric_limits<RealType>::infinity()))); // p == infinity
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_bernoulli(0.5), static_cast<RealType>(-1)))); // p < 0
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_bernoulli(0.5), static_cast<RealType>(2)))); // p > 1
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_bernoulli(0.5), std::numeric_limits<RealType>::infinity())))); // q == infinity
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_bernoulli(0.5), static_cast<RealType>(-1))))); // q < 0
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_bernoulli(0.5), static_cast<RealType>(2))))); // q > 1
-
+      test_invalid_support<bernoulli_distribution, RealType>();
     } // has_quiet_NaN
 } // template <class RealType>void test_spots(RealType)
 

From 4ab9190486f7668e3d44e64a1399c08eec0b49e5 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Fri, 29 May 2026 19:32:23 -0700
Subject: [PATCH 03/30] Fixed bugs in test_dist_helpers and arcsine
 distribution

---
 include/boost/math/distributions/arcsine.hpp |  9 ++-
 test/test_arcsine.cpp                        | 30 +++-----
 test/test_bernoulli.cpp                      | 11 +--
 test/test_cauchy.cpp                         | 15 ++++
 test/test_dist_helpers.hpp                   | 78 ++++++++++++--------
 5 files changed, 86 insertions(+), 57 deletions(-)

diff --git a/include/boost/math/distributions/arcsine.hpp b/include/boost/math/distributions/arcsine.hpp
index 4fe3c7d751..6cf31b263e 100644
--- a/include/boost/math/distributions/arcsine.hpp
+++ b/include/boost/math/distributions/arcsine.hpp
@@ -229,11 +229,11 @@ namespace boost
         // Special cases:
         if (p == 0)
         {
-          return 0;
+          return x_min;
         }
         if (p == 1)
         {
-          return 1;
+          return x_max;
         }
         using boost::math::constants::half_pi;
         RealType sin2hpip = sin(half_pi<RealType>() * p);
@@ -247,11 +247,11 @@ namespace boost
         // Special cases:
         if (q == 1)
         {
-          return 0;
+          return x_min;
         }
         if (q == 0)
         {
-          return 1;
+          return x_max;
         }
         // Naive RealType p = 1 - q; result = sin(half_pi<RealType>() * p); loses accuracy, so use a cos alternative instead.
         //result = cos(half_pi<RealType>() * q); // for arcsine(0,1)
@@ -281,6 +281,7 @@ namespace boost
           m_x_max,
           &result, Policy());
       } // arcsine_distribution constructor.
+      BOOST_MATH_GPU_ENABLED arcsine_distribution(std::vector<RealType> params) : arcsine_distribution(params[0], params[1]) {}
       // Accessor functions:
       BOOST_MATH_GPU_ENABLED RealType x_min() const
       {
diff --git a/test/test_arcsine.cpp b/test/test_arcsine.cpp
index 9fd1a174d9..77ec3d2a42 100644
--- a/test/test_arcsine.cpp
+++ b/test/test_arcsine.cpp
@@ -454,11 +454,6 @@ void test_spots(RealType)
       arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(1)), // equal constructor parameters.
       static_cast<RealType>(-1)), std::domain_error);
 
-    BOOST_CHECK_THROW(
-      pdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(0), static_cast<RealType>(1)), // bad x > 1.
-      static_cast<RealType>(999)), std::domain_error);
-
     BOOST_CHECK_THROW( // For various bad arguments.
       logpdf(
       arcsine_distribution<RealType>(static_cast<RealType>(+1), static_cast<RealType>(-1)), // min_x > max_x
@@ -483,20 +478,10 @@ void test_spots(RealType)
       logpdf(
       arcsine_distribution<RealType>(static_cast<RealType>(0), static_cast<RealType>(1)), // bad x > 1.
       static_cast<RealType>(999)), std::domain_error);
-
-    // Checks on things that are errors.
-
-    // Construction with 'bad' parameters.
-    BOOST_CHECK_THROW(arcsine_distribution<RealType>(+1, -1), std::domain_error); // max < min.
-    BOOST_CHECK_THROW(arcsine_distribution<RealType>(+1, 0), std::domain_error);  // max < min.
-
-    // Various combinations of bad constructor and member function parameters.
-    BOOST_CHECK_THROW(pdf(boost::math::arcsine_distribution<RealType>(0, 1), -1), std::domain_error);
-    BOOST_CHECK_THROW(pdf(boost::math::arcsine_distribution<RealType>(-1, 1), +2), std::domain_error);
-    BOOST_CHECK_THROW(logpdf(boost::math::arcsine_distribution<RealType>(0, 1), -1), std::domain_error);
-    BOOST_CHECK_THROW(logpdf(boost::math::arcsine_distribution<RealType>(-1, 1), +2), std::domain_error);
-    BOOST_CHECK_THROW(quantile(boost::math::arcsine_distribution<RealType>(1, 1), -1), std::domain_error);
-    BOOST_CHECK_THROW(quantile(boost::math::arcsine_distribution<RealType>(1, 1), 2), std::domain_error);
+    
+    // std::vector<std::vector<RealType> > invalid_params = {{1, 0}, // x_min > x_max
+    //                                                       {1, -1}}; 
+    // test_invalid_parameters<arcsine_distribution, RealType>(invalid_params);
 
     // No longer allow any parameter to be NaN or inf, so all these tests should throw.
     if (std::numeric_limits<RealType>::has_quiet_NaN)
@@ -551,6 +536,13 @@ void test_spots(RealType)
       BOOST_CHECK_THROW(quantile(complement(w, +inf)), std::domain_error); // p = + inf
     } // has_infinity
 
+    // Quantile should return x_min and x_max
+    arcsine_distribution<RealType> dist(0, 1);
+    BOOST_CHECK_EQUAL(quantile(dist, static_cast<RealType>(1)), static_cast<RealType>(1)); // p = 1
+    BOOST_CHECK_EQUAL(quantile(dist, static_cast<RealType>(0)), static_cast<RealType>(0)); // p = 0
+    BOOST_CHECK_EQUAL(quantile(complement(dist, static_cast<RealType>(1))), static_cast<RealType>(0)); // q = 1
+    BOOST_CHECK_EQUAL(quantile(complement(dist, static_cast<RealType>(0))), static_cast<RealType>(1)); // q = 0
+
     // Error handling checks:
     check_out_of_range<boost::math::arcsine_distribution<RealType> >(-1, +1); // (All) valid constructor parameter values.
     // and range and non-finite.
diff --git a/test/test_bernoulli.cpp b/test/test_bernoulli.cpp
index 3cb62ed717..2f3fc76c6a 100644
--- a/test/test_bernoulli.cpp
+++ b/test/test_bernoulli.cpp
@@ -279,14 +279,15 @@ void test_spots(RealType)
 #else
      BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType>(inf), std::domain_error);
 #endif
-     BOOST_MATH_CHECK_THROW(pdf(w, +inf), std::domain_error); // x = inf
-     BOOST_MATH_CHECK_THROW(cdf(w, +inf), std::domain_error); // x = inf
-     BOOST_MATH_CHECK_THROW(cdf(complement(w, +inf)), std::domain_error); // x = + inf
-     BOOST_MATH_CHECK_THROW(quantile(w, +inf), std::domain_error); // p = + inf
-     BOOST_MATH_CHECK_THROW(quantile(complement(w, +inf)), std::domain_error); // p = + inf
    } // has_infinity
    #endif
 
+   bernoulli_distribution<RealType> fair_dist(0.5);
+   BOOST_CHECK_EQUAL(quantile(fair_dist, static_cast<RealType>(1)), static_cast<RealType>(1)); // p = 1
+   BOOST_CHECK_EQUAL(quantile(fair_dist, static_cast<RealType>(0)), static_cast<RealType>(0)); // p = 0
+   BOOST_CHECK_EQUAL(quantile(complement(fair_dist, static_cast<RealType>(1))), static_cast<RealType>(0)); // q = 1
+   BOOST_CHECK_EQUAL(quantile(complement(fair_dist, static_cast<RealType>(0))), static_cast<RealType>(1)); // q = 0
+   
    if (std::numeric_limits<RealType>::has_quiet_NaN)
     {
       test_invalid_support<bernoulli_distribution, RealType>();
diff --git a/test/test_cauchy.cpp b/test/test_cauchy.cpp
index 4e8286c60e..cd217c71a2 100644
--- a/test/test_cauchy.cpp
+++ b/test/test_cauchy.cpp
@@ -26,6 +26,7 @@
 // To compile even if Cauchy mean is used.
 #include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/distributions/cauchy.hpp>
+#include <boost/math/distributions/arcsine.hpp>
     using boost::math::cauchy_distribution;
 
 #define BOOST_TEST_MAIN
@@ -33,10 +34,18 @@
 #include <boost/test/tools/floating_point_comparison.hpp>
 
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
+
+#if defined(BOOST_CHECK_THROW) && defined(BOOST_MATH_NO_EXCEPTIONS)
+#  undef BOOST_CHECK_THROW
+#  define BOOST_CHECK_THROW(x, y)
+#endif
 
 #include <iostream>
    using std::cout;
    using std::endl;
+#include <limits>
+using std::numeric_limits;
 
 template <class RealType>
 void test_spots(RealType T)
@@ -798,6 +807,12 @@ void test_spots(RealType T)
       BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(-1)), static_cast<RealType>(0.25))));
       BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_error_cauchy(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), static_cast<RealType>(0.25))));
       BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(1)), static_cast<RealType>(-0.25))));
+   
+      if (std::numeric_limits<RealType>::has_quiet_NaN)
+      {
+         test_invalid_support<boost::math::cauchy_distribution, RealType>();
+      }
+      
    }
 
 } // template <class RealType>void test_spots(RealType)
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 38e16c1d56..9d23f2ca56 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -1,14 +1,20 @@
+#ifndef BOOST_MATH_TEST_DIST_HELPERS_HPP
+#define BOOST_MATH_TEST_DIST_HELPERS_HPP
+
 #include <utility>
 #include <limits>
 #include <stdexcept>
 #include <boost/math/tools/precision.hpp>
 #include <boost/math/special_functions/next.hpp>
 #include <boost/test/unit_test.hpp>
+#include <boost/test/tools/floating_point_comparison.hpp>
 
 template <template <typename, typename> typename Distribution, class Real>
 void test_invalid_support()
 {
     using boost::math::policies::policy;
+    using namespace boost::math;
+
     typedef policy<
       boost::math::policies::domain_error<boost::math::policies::ignore_error>,
       boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
@@ -34,17 +40,17 @@ void test_invalid_support()
             invalid = boost::math::float_prior(invalid);
 
         // Test PDF/CDF
-        BOOST_MATH_CHECK_THROW(pdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(cdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK_THROW(pdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(cdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
         BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
 
         // Test log PDF/CDF
-        BOOST_MATH_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
         BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
@@ -58,18 +64,18 @@ void test_invalid_support()
         else
             invalid = boost::math::float_next(invalid);
         // Test PDF/CDF
-        BOOST_MATH_CHECK_THROW(pdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(cdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK_THROW(pdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(cdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
         // Test NaN handnling
         BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
 
         // Test log PDF/CDF
-        BOOST_MATH_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
-        BOOST_MATH_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
+        BOOST_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
+        BOOST_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
         BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
@@ -77,33 +83,29 @@ void test_invalid_support()
 
     // NaN checks for PDF/CDF
     invalid = std::numeric_limits<Real>::quiet_NaN();
-    BOOST_MATH_CHECK_THROW(pdf(dist, invalid), std::domain_error);
-    BOOST_MATH_CHECK_THROW(cdf(dist, invalid), std::domain_error);
-    BOOST_MATH_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
+    BOOST_CHECK_THROW(pdf(dist, invalid), std::domain_error);
+    BOOST_CHECK_THROW(cdf(dist, invalid), std::domain_error);
+    BOOST_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
     BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
     BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
     BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
 
     // NaN checks for log PDF/CDF
     invalid = std::numeric_limits<Real>::quiet_NaN();
-    BOOST_MATH_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
-    BOOST_MATH_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
-    BOOST_MATH_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
+    BOOST_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
+    BOOST_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
+    BOOST_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
     BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_dist, invalid)));
     BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
     BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
 
     // Quantile Checks
-    BOOST_MATH_CHECK_THROW(quantile(dist, std::numeric_limits<Real>::infinity()), std::domain_error); // p == infinity
-    BOOST_MATH_CHECK_THROW(quantile(dist, static_cast<Real>(-1)), std::domain_error); // p < 0
-    BOOST_MATH_CHECK_THROW(quantile(dist, static_cast<Real>(2)), std::domain_error); // p > 1
-    BOOST_MATH_CHECK_THROW(quantile(complement(dist, std::numeric_limits<Real>::infinity())), std::domain_error); // q == infinity
-    BOOST_MATH_CHECK_THROW(quantile(complement(dist, static_cast<Real>(-1))), std::domain_error); // q < 0
-    BOOST_MATH_CHECK_THROW(quantile(complement(dist, static_cast<Real>(2))), std::domain_error); // q > 1
-    BOOST_CHECK_EQUAL(quantile(dist, static_cast<Real>(1)), static_cast<Real>(1)); // p = 1
-    BOOST_CHECK_EQUAL(quantile(dist, static_cast<Real>(0)), static_cast<Real>(0)); // p = 0
-    BOOST_CHECK_EQUAL(quantile(complement(dist, static_cast<Real>(1))), static_cast<Real>(0)); // q = 1
-    BOOST_CHECK_EQUAL(quantile(complement(dist, static_cast<Real>(0))), static_cast<Real>(1)); // q = 0
+    BOOST_CHECK_THROW(quantile(dist, std::numeric_limits<Real>::infinity()), std::domain_error); // p == infinity
+    BOOST_CHECK_THROW(quantile(dist, static_cast<Real>(-1)), std::domain_error); // p < 0
+    BOOST_CHECK_THROW(quantile(dist, static_cast<Real>(2)), std::domain_error); // p > 1
+    BOOST_CHECK_THROW(quantile(complement(dist, std::numeric_limits<Real>::infinity())), std::domain_error); // q == infinity
+    BOOST_CHECK_THROW(quantile(complement(dist, static_cast<Real>(-1))), std::domain_error); // q < 0
+    BOOST_CHECK_THROW(quantile(complement(dist, static_cast<Real>(2))), std::domain_error); // q > 1
 
     BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_dist, std::numeric_limits<Real>::infinity()))); // p == infinity
     BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_dist, static_cast<Real>(-1)))); // p < 0
@@ -111,4 +113,22 @@ void test_invalid_support()
     BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, std::numeric_limits<Real>::infinity())))); // q == infinity
     BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, static_cast<Real>(-1))))); // q < 0
     BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, static_cast<Real>(2))))); // q > 1
-}
\ No newline at end of file
+}
+
+
+// template <template <typename...> typename Distribution, class Real>
+// void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
+// {
+//     typedef Distribution<Real> dist;
+
+//     std::vector<Real> params;
+//     for (unsigned i=0; i<invalid_parameters.size(); i++)
+//     {
+//         params = invalid_parameters[i];
+//         BOOST_CHECK_THROW(dist(params), std::domain_error);
+//         BOOST_CHECK_THROW(dist x(params), std::domain_error);
+//         BOOST_CHECK_THROW(boost::math::pdf(dist(params), 0.5), std::domain_error);
+//     }
+// }
+
+#endif // BOOST_MATH_TEST_DIST_HELPERS_HPP
\ No newline at end of file

From 9c77ea6e425b96da64931936d63a5fd03f3c90c4 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 30 May 2026 13:46:23 -0700
Subject: [PATCH 04/30] Added invalid parameter construction function

---
 include/boost/math/distributions/arcsine.hpp |   1 -
 test/test_arcsine.cpp                        | 126 +++++--------------
 test/test_dist_helpers.hpp                   |  75 ++++++++---
 3 files changed, 93 insertions(+), 109 deletions(-)

diff --git a/include/boost/math/distributions/arcsine.hpp b/include/boost/math/distributions/arcsine.hpp
index 6cf31b263e..cd3bbaaa9d 100644
--- a/include/boost/math/distributions/arcsine.hpp
+++ b/include/boost/math/distributions/arcsine.hpp
@@ -281,7 +281,6 @@ namespace boost
           m_x_max,
           &result, Policy());
       } // arcsine_distribution constructor.
-      BOOST_MATH_GPU_ENABLED arcsine_distribution(std::vector<RealType> params) : arcsine_distribution(params[0], params[1]) {}
       // Accessor functions:
       BOOST_MATH_GPU_ENABLED RealType x_min() const
       {
diff --git a/test/test_arcsine.cpp b/test/test_arcsine.cpp
index 77ec3d2a42..17ee3c8e24 100644
--- a/test/test_arcsine.cpp
+++ b/test/test_arcsine.cpp
@@ -433,107 +433,47 @@ void test_spots(RealType)
     BOOST_CHECK_THROW(mode(arcsine_distribution<RealType>(static_cast<RealType>(0), static_cast<RealType>(1))), std::domain_error);
     // mode is undefined, and must throw domain_error!
 
+    using boost::math::policies::policy;
 
-    BOOST_CHECK_THROW( // For various bad arguments.
-      pdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(+1), static_cast<RealType>(-1)), // min_x > max_x
-      static_cast<RealType>(1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      pdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(0)), // bad constructor parameters.
-      static_cast<RealType>(1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      pdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(-1)), // bad constructor parameters.
-      static_cast<RealType>(1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      pdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(1)), // equal constructor parameters.
-      static_cast<RealType>(-1)), std::domain_error);
-
-    BOOST_CHECK_THROW( // For various bad arguments.
-      logpdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(+1), static_cast<RealType>(-1)), // min_x > max_x
-      static_cast<RealType>(1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      logpdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(0)), // bad constructor parameters.
-      static_cast<RealType>(1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      logpdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(-1)), // bad constructor parameters.
-      static_cast<RealType>(1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      logpdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(1), static_cast<RealType>(1)), // equal constructor parameters.
-      static_cast<RealType>(-1)), std::domain_error);
-
-    BOOST_CHECK_THROW(
-      logpdf(
-      arcsine_distribution<RealType>(static_cast<RealType>(0), static_cast<RealType>(1)), // bad x > 1.
-      static_cast<RealType>(999)), std::domain_error);
-    
-    // std::vector<std::vector<RealType> > invalid_params = {{1, 0}, // x_min > x_max
-    //                                                       {1, -1}}; 
-    // test_invalid_parameters<arcsine_distribution, RealType>(invalid_params);
-
-    // No longer allow any parameter to be NaN or inf, so all these tests should throw.
-    if (std::numeric_limits<RealType>::has_quiet_NaN)
-    {
+    typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+    > ignore_all_policy;
+
+    std::vector<std::vector<RealType> > invalid_params = {{1, 0}, // x_min > x_max
+                                                          {1, -1},
+                                                          {1, 1}};
+    test_invalid_parameters<arcsine_distribution<RealType, boost::math::policies::policy<> >, 
+                            arcsine_distribution<RealType, ignore_all_policy>, 
+                            RealType>(invalid_params);
+
+    // Check constructing with NaNs
+    if (std::numeric_limits<RealType>::has_quiet_NaN){
       // Attempt to construct from non-finite parameters should throw.
       RealType nan = std::numeric_limits<RealType>::quiet_NaN();
-#ifndef BOOST_NO_EXCEPTIONS
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(nan), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(1, nan), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(nan, 1), std::domain_error);
-#else
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(nan), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(1, nan), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(nan, 1), std::domain_error);
-#endif
-
-      arcsine_distribution<RealType> w(RealType(-1), RealType(+1));
-      // NaN parameters to member functions should throw.
-      BOOST_CHECK_THROW(pdf(w, +nan), std::domain_error); // x = NaN
-      BOOST_CHECK_THROW(logpdf(w, +nan), std::domain_error); // x = NaN
-      BOOST_CHECK_THROW(cdf(w, +nan), std::domain_error); // x = NaN
-      BOOST_CHECK_THROW(cdf(complement(w, +nan)), std::domain_error); // x = + nan
-      BOOST_CHECK_THROW(quantile(w, +nan), std::domain_error); // p = + nan
-      BOOST_CHECK_THROW(quantile(complement(w, +nan)), std::domain_error); // p = + nan
-    } // has_quiet_NaN
+      invalid_params = {{nan},
+                        {1, nan}, // x_min > x_max
+                        {nan, 1}};
+      test_invalid_parameters<arcsine_distribution<RealType, boost::math::policies::policy<> >, 
+                              arcsine_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+    }
 
+    // Check construcing with Infinity
     if (std::numeric_limits<RealType>::has_infinity)
     {
       // Attempt to construct from non-finite should throw.
       RealType inf = std::numeric_limits<RealType>::infinity();
-#ifndef BOOST_NO_EXCEPTIONS
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(inf), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(1, inf), std::domain_error);
-#else
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(inf), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(1, inf), std::domain_error);
-#endif
-      // Infinite parameters to member functions should throw.
-      arcsine_distribution<RealType> w(RealType(0), RealType(1));
-#ifndef BOOST_NO_EXCEPTIONS
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(inf), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType> w(1, inf), std::domain_error);
-#else
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(inf), std::domain_error);
-      BOOST_CHECK_THROW(arcsine_distribution<RealType>(1, inf), std::domain_error);
-#endif
-      BOOST_CHECK_THROW(pdf(w, +inf), std::domain_error); // x = inf
-      BOOST_CHECK_THROW(logpdf(w, +inf), std::domain_error); // x = inf
-      BOOST_CHECK_THROW(cdf(w, +inf), std::domain_error); // x = inf
-      BOOST_CHECK_THROW(cdf(complement(w, +inf)), std::domain_error); // x = + inf
-      BOOST_CHECK_THROW(quantile(w, +inf), std::domain_error); // p = + inf
-      BOOST_CHECK_THROW(quantile(complement(w, +inf)), std::domain_error); // p = + inf
+      invalid_params = {{inf},
+                        {1, inf}, // x_min > x_max
+                        {inf, 1}};
+      test_invalid_parameters<arcsine_distribution<RealType, boost::math::policies::policy<> >, 
+                              arcsine_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
     } // has_infinity
 
     // Quantile should return x_min and x_max
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 9d23f2ca56..f89efbe82b 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -7,6 +7,7 @@
 #include <boost/math/tools/precision.hpp>
 #include <boost/math/special_functions/next.hpp>
 #include <boost/test/unit_test.hpp>
+#include <boost/math/policies/policy.hpp>
 #include <boost/test/tools/floating_point_comparison.hpp>
 
 template <template <typename, typename> typename Distribution, class Real>
@@ -91,7 +92,6 @@ void test_invalid_support()
     BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
 
     // NaN checks for log PDF/CDF
-    invalid = std::numeric_limits<Real>::quiet_NaN();
     BOOST_CHECK_THROW(logpdf(dist, invalid), std::domain_error);
     BOOST_CHECK_THROW(logcdf(dist, invalid), std::domain_error);
     BOOST_CHECK_THROW(logcdf(complement(dist, invalid)), std::domain_error);
@@ -115,20 +115,65 @@ void test_invalid_support()
     BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, static_cast<Real>(2))))); // q > 1
 }
 
+template <class Dist, class Container>
+Dist make_distribution(const Container& c)
+{
+    using value_type = typename Dist::value_type;
+    if constexpr (std::is_constructible_v<Dist, value_type, value_type, value_type>)
+    {
+        if (c.size() >= 3)
+            return Dist(c.data()[0], c.data()[1], c.data()[2]);
+    }
+    if constexpr (std::is_constructible_v<Dist, value_type, value_type>)
+    {
+        if (c.size() >= 2)
+            return Dist(c.data()[0], c.data()[1]);
+    }
+    if constexpr (std::is_constructible_v<Dist, value_type>)
+    {
+        if (c.size() >= 1)
+            return Dist(c.data()[0]);
+    }
+    return Dist();
+}
 
-// template <template <typename...> typename Distribution, class Real>
-// void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
-// {
-//     typedef Distribution<Real> dist;
-
-//     std::vector<Real> params;
-//     for (unsigned i=0; i<invalid_parameters.size(); i++)
-//     {
-//         params = invalid_parameters[i];
-//         BOOST_CHECK_THROW(dist(params), std::domain_error);
-//         BOOST_CHECK_THROW(dist x(params), std::domain_error);
-//         BOOST_CHECK_THROW(boost::math::pdf(dist(params), 0.5), std::domain_error);
-//     }
-// }
+template <class Dist, class V>
+Dist make_distribution(const std::initializer_list<V>& c)
+{
+    return make_distribution<Dist, std::initializer_list<V>>(c);
+}
+
+template <class Dist, class Ignore_Error_Dist, class Real>
+void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
+{
+    std::vector<Real> params;
+    for (unsigned i=0; i<invalid_parameters.size(); i++)
+    {
+        params = invalid_parameters[i];
+
+        // Check functions throw with bad constructors
+        BOOST_CHECK_THROW(make_distribution<Dist>(params), std::domain_error);
+        BOOST_CHECK_THROW(pdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
+        BOOST_CHECK_THROW(logpdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
+        BOOST_CHECK_THROW(cdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
+        BOOST_CHECK_THROW(cdf(complement(make_distribution<Dist>(params), static_cast<Real>(0))), std::domain_error);
+        BOOST_CHECK_THROW(logcdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
+        BOOST_CHECK_THROW(logcdf(complement(make_distribution<Dist>(params), static_cast<Real>(0))), std::domain_error);
+        BOOST_CHECK_THROW(quantile(make_distribution<Dist>(params), static_cast<Real>(0.5)), std::domain_error);
+        BOOST_CHECK_THROW(quantile(complement(make_distribution<Dist>(params), static_cast<Real>(0.5))), std::domain_error);
+
+        // Check return NaN
+        if (std::numeric_limits<Real>::has_quiet_NaN)
+        {
+            BOOST_CHECK((boost::math::isnan)(pdf(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0))));
+            BOOST_CHECK((boost::math::isnan)(logpdf(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0))));
+            BOOST_CHECK((boost::math::isnan)(cdf(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0))));
+            BOOST_CHECK((boost::math::isnan)(cdf(complement(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0)))));
+            BOOST_CHECK((boost::math::isnan)(logcdf(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0))));
+            BOOST_CHECK((boost::math::isnan)(logcdf(complement(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0)))));
+        }
+
+    }
+}
 
 #endif // BOOST_MATH_TEST_DIST_HELPERS_HPP
\ No newline at end of file

From 4775d3491abdf657586c6b5b284cf8b821066684 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 30 May 2026 17:18:58 -0700
Subject: [PATCH 05/30] Added bernoulli distribution

---
 test/test_bernoulli.cpp    | 89 +++++++++++++++++---------------------
 test/test_dist_helpers.hpp |  1 -
 2 files changed, 39 insertions(+), 51 deletions(-)

diff --git a/test/test_bernoulli.cpp b/test/test_bernoulli.cpp
index 2f3fc76c6a..9e720c0ada 100644
--- a/test/test_bernoulli.cpp
+++ b/test/test_bernoulli.cpp
@@ -51,6 +51,8 @@ using std::setprecision;
 #include <limits>
 using std::numeric_limits;
 
+#include <vector>
+
 template <class RealType> // Any floating-point type RealType.
 void test_spots(RealType)
 { // Parameter only provides the type, float, double... value ignored.
@@ -231,56 +233,43 @@ void test_spots(RealType)
      );
 
    // Checks for 'bad' parameters.
-   // Construction.
-   #ifndef BOOST_MATH_NO_EXCEPTIONS
-   BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType>(-1), std::domain_error); // p outside 0 to 1.
-   BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType>(+2), std::domain_error); // p outside 0 to 1.
-
-   // Parameters.
-   bernoulli_distribution<RealType> dist(RealType(1)); 
-   BOOST_MATH_CHECK_THROW(pdf(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(cdf(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(cdf(complement(dist, -1)), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(dist, 2), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(complement(dist, -1)), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(complement(dist, -1)), std::domain_error);
-     
-   // No longer allow any parameter to be NaN or inf, so all these tests should throw.
-   if (std::numeric_limits<RealType>::has_quiet_NaN)
-   { 
-    // Attempt to construct from non-finite should throw.
-     RealType nan = std::numeric_limits<RealType>::quiet_NaN();
-#ifndef BOOST_NO_EXCEPTIONS
-     BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType> b(nan), std::domain_error);
-#else
-     BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType>(nan), std::domain_error);
-#endif
-    // Non-finite parameters should throw.
-     bernoulli_distribution<RealType> b(RealType(1)); 
-     BOOST_MATH_CHECK_THROW(pdf(b, +nan), std::domain_error); // x = NaN
-     BOOST_MATH_CHECK_THROW(cdf(b, +nan), std::domain_error); // x = NaN
-     BOOST_MATH_CHECK_THROW(cdf(complement(b, +nan)), std::domain_error); // x = + nan
-     BOOST_MATH_CHECK_THROW(quantile(b, +nan), std::domain_error); // p = + nan
-     BOOST_MATH_CHECK_THROW(quantile(complement(b, +nan)), std::domain_error); // p = + nan
-  } // has_quiet_NaN
-
-  if (std::numeric_limits<RealType>::has_infinity)
-  {
-     RealType inf = std::numeric_limits<RealType>::infinity(); 
-#ifndef BOOST_NO_EXCEPTIONS
-     BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType> w(inf), std::domain_error);
-#else
-     BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType>(inf), std::domain_error);
-#endif
-     bernoulli_distribution<RealType> w(RealType(1)); 
-#ifndef BOOST_NO_EXCEPTIONS
-     BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType> w(inf), std::domain_error);
-#else
-     BOOST_MATH_CHECK_THROW(bernoulli_distribution<RealType>(inf), std::domain_error);
-#endif
-   } // has_infinity
-   #endif
+   using boost::math::policies::policy;
+
+    typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+    > ignore_all_policy;
+
+    std::vector<std::vector<RealType> > invalid_params = {{-1}, // x_min > x_max
+                                                          {2}};
+    test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
+                            bernoulli_distribution<RealType, ignore_all_policy>, 
+                            RealType>(invalid_params);
+
+    // Check constructing with NaNs
+    if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan}};
+      test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
+                              bernoulli_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+    }
+
+    // Check construcing with Infinity
+    if (std::numeric_limits<RealType>::has_infinity)
+    {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf}};
+      test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
+                              bernoulli_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+    } // has_infinity  
 
    bernoulli_distribution<RealType> fair_dist(0.5);
    BOOST_CHECK_EQUAL(quantile(fair_dist, static_cast<RealType>(1)), static_cast<RealType>(1)); // p = 1
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index f89efbe82b..8802a1284d 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -172,7 +172,6 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
             BOOST_CHECK((boost::math::isnan)(logcdf(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0))));
             BOOST_CHECK((boost::math::isnan)(logcdf(complement(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0)))));
         }
-
     }
 }
 

From a93758bac41a3fd2abd7dbcf392eb09b0b8e46e7 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 30 May 2026 17:36:13 -0700
Subject: [PATCH 06/30] Added beta distribution

---
 test/test_bernoulli.cpp    |  32 ++++-----
 test/test_beta_dist.cpp    | 133 ++++++++++++++-----------------------
 test/test_dist_helpers.hpp |   2 +
 3 files changed, 68 insertions(+), 99 deletions(-)

diff --git a/test/test_bernoulli.cpp b/test/test_bernoulli.cpp
index 9e720c0ada..3b97b41f46 100644
--- a/test/test_bernoulli.cpp
+++ b/test/test_bernoulli.cpp
@@ -235,41 +235,41 @@ void test_spots(RealType)
    // Checks for 'bad' parameters.
    using boost::math::policies::policy;
 
-    typedef policy<
+   typedef policy<
       boost::math::policies::domain_error<boost::math::policies::ignore_error>,
       boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
       boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
       boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
       boost::math::policies::pole_error<boost::math::policies::ignore_error>,
       boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-    > ignore_all_policy;
+   > ignore_all_policy;
 
-    std::vector<std::vector<RealType> > invalid_params = {{-1}, // x_min > x_max
-                                                          {2}};
-    test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
-                            bernoulli_distribution<RealType, ignore_all_policy>, 
-                            RealType>(invalid_params);
+   std::vector<std::vector<RealType> > invalid_params = {{-1}, // x_min > x_max
+                                                         {2}};
+   test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
+                           bernoulli_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
 
-    // Check constructing with NaNs
-    if (std::numeric_limits<RealType>::has_quiet_NaN){
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
       // Attempt to construct from non-finite parameters should throw.
       RealType nan = std::numeric_limits<RealType>::quiet_NaN();
       invalid_params = {{nan}};
       test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
                               bernoulli_distribution<RealType, ignore_all_policy>, 
                               RealType>(invalid_params);
-    }
+   }
 
-    // Check construcing with Infinity
-    if (std::numeric_limits<RealType>::has_infinity)
-    {
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
       // Attempt to construct from non-finite should throw.
       RealType inf = std::numeric_limits<RealType>::infinity();
       invalid_params = {{inf}};
       test_invalid_parameters<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
                               bernoulli_distribution<RealType, ignore_all_policy>, 
                               RealType>(invalid_params);
-    } // has_infinity  
+   } // has_infinity  
 
    bernoulli_distribution<RealType> fair_dist(0.5);
    BOOST_CHECK_EQUAL(quantile(fair_dist, static_cast<RealType>(1)), static_cast<RealType>(1)); // p = 1
@@ -278,9 +278,9 @@ void test_spots(RealType)
    BOOST_CHECK_EQUAL(quantile(complement(fair_dist, static_cast<RealType>(0))), static_cast<RealType>(1)); // q = 0
    
    if (std::numeric_limits<RealType>::has_quiet_NaN)
-    {
+   {
       test_invalid_support<bernoulli_distribution, RealType>();
-    } // has_quiet_NaN
+   } // has_quiet_NaN
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_beta_dist.cpp b/test/test_beta_dist.cpp
index 3983f526ff..ea585e4da7 100644
--- a/test/test_beta_dist.cpp
+++ b/test/test_beta_dist.cpp
@@ -54,12 +54,14 @@ using boost::math::beta;
 #include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION
 
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 using std::cout;
 using std::endl;
 #include <limits>
 using std::numeric_limits;
+#include <vector>
 
 #if __has_include(<stdfloat>)
 # include <stdfloat>
@@ -494,23 +496,57 @@ void test_spots(RealType)
      static_cast<RealType>(1-0.5545844446520295253493059553548880128511L),  // Complement of CDF Q = 1 - P
      tolerance); // Test tolerance.
 
-    //
+   //
    // Error checks:
    // Construction with 'bad' parameters.
-   BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(1, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(-1, 1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(1, 0), std::domain_error);
-   BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(0, 1), std::domain_error);
-
-   beta_distribution<> dist;
-   BOOST_MATH_CHECK_THROW(pdf(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(cdf(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(cdf(complement(dist, -1)), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(complement(dist, -1)), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(dist, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(complement(dist, -1)), std::domain_error);
+   using boost::math::policies::policy;
 
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{1, -1},
+                                                         {-1, 1},
+                                                         {1, 0},
+                                                         {0, 1}};
+   test_invalid_parameters<beta_distribution<RealType, boost::math::policies::policy<> >, 
+                           beta_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan},
+                        {1, nan}};
+      test_invalid_parameters<beta_distribution<RealType, boost::math::policies::policy<> >, 
+                              beta_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf},
+                        {1, inf}};
+      test_invalid_parameters<beta_distribution<RealType, boost::math::policies::policy<> >, 
+                              beta_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   } // has_infinity  
+
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<beta_distribution, RealType>();
+   } // has_quiet_NaN
+   
+   // PDF not defind for alpha < 1, x = 0 and beta < 1, x = 1
    BOOST_MATH_CHECK_THROW(pdf(beta_distribution<RealType>(static_cast<RealType>(0.5), static_cast<RealType>(1.5)), static_cast<RealType>(0)), std::overflow_error); // alpha < 1, x = 0
    BOOST_MATH_CHECK_THROW(pdf(beta_distribution<RealType>(static_cast<RealType>(1.5), static_cast<RealType>(0.5)), static_cast<RealType>(1)), std::overflow_error); // beta < 1, x = 1
 
@@ -523,72 +559,16 @@ void test_spots(RealType)
    test_find_alpha_beta(static_cast<RealType>(1), static_cast<RealType>(1.5), static_cast<RealType>(0.5)); // x > 0
    test_find_alpha_beta(static_cast<RealType>(1), static_cast<RealType>(-0.5), static_cast<RealType>(0.5)); // x < 0
 
-   // No longer allow any parameter to be NaN or inf, so all these tests should throw.
-   if (std::numeric_limits<RealType>::has_quiet_NaN)
-   { 
-    // Attempt to construct from non-finite should throw.
-     RealType nan = std::numeric_limits<RealType>::quiet_NaN();
-#ifndef BOOST_NO_EXCEPTIONS
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType> w(nan), std::domain_error);
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType> w(1, nan), std::domain_error);
-#else
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(nan), std::domain_error);
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(1, nan), std::domain_error);
-#endif
-     
-    // Non-finite parameters should throw.
-     beta_distribution<RealType> w(RealType(1)); 
-     BOOST_MATH_CHECK_THROW(pdf(w, +nan), std::domain_error); // x = NaN
-     BOOST_MATH_CHECK_THROW(cdf(w, +nan), std::domain_error); // x = NaN
-     BOOST_MATH_CHECK_THROW(cdf(complement(w, +nan)), std::domain_error); // x = + nan
-     BOOST_MATH_CHECK_THROW(quantile(w, +nan), std::domain_error); // p = + nan
-     BOOST_MATH_CHECK_THROW(quantile(complement(w, +nan)), std::domain_error); // p = + nan
-  } // has_quiet_NaN
-
   if (std::numeric_limits<RealType>::has_infinity)
   {
      // Attempt to construct from non-finite should throw.
      RealType inf = std::numeric_limits<RealType>::infinity(); 
-#ifndef BOOST_NO_EXCEPTIONS
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType> w(inf), std::domain_error);
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType> w(1, inf), std::domain_error);
-#else
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(inf), std::domain_error);
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(1, inf), std::domain_error);
-#endif
-
-    // Non-finite parameters should throw.
-     beta_distribution<RealType> w(RealType(1)); 
-#ifndef BOOST_NO_EXCEPTIONS
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType> w(inf), std::domain_error);
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType> w(1, inf), std::domain_error);
-#else
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(inf), std::domain_error);
-     BOOST_MATH_CHECK_THROW(beta_distribution<RealType>(1, inf), std::domain_error);
-#endif
-     BOOST_MATH_CHECK_THROW(pdf(w, +inf), std::domain_error); // x = inf
-     BOOST_MATH_CHECK_THROW(cdf(w, +inf), std::domain_error); // x = inf
-     BOOST_MATH_CHECK_THROW(cdf(complement(w, +inf)), std::domain_error); // x = + inf
-     BOOST_MATH_CHECK_THROW(quantile(w, +inf), std::domain_error); // p = + inf
-     BOOST_MATH_CHECK_THROW(quantile(complement(w, +inf)), std::domain_error); // p = + inf
 
      test_find_alpha_beta(static_cast<RealType>(1), static_cast<RealType>(0.5), inf); // p = inf
      test_find_alpha_beta(inf, static_cast<RealType>(0.5)); // mean = inf
      test_find_alpha_beta(static_cast<RealType>(0.5), inf); // var = inf
      test_find_alpha_beta(static_cast<RealType>(1), inf, static_cast<RealType>(0.5)); // x = inf
 
-     // Check isnan policies
-     using boost::math::policies::policy;
-    
-     typedef policy<
-      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-     > ignore_all_policy;
-
      typedef beta_distribution<RealType, ignore_all_policy> ignore_error_beta;
 
      BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_alpha(inf, static_cast<RealType>(0.5)))); // mean = inf
@@ -597,11 +577,6 @@ void test_spots(RealType)
      BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_beta(inf, static_cast<RealType>(0.5), static_cast<RealType>(0.5)))); // alpha = inf
      BOOST_CHECK((boost::math::isnan)(mode(ignore_error_beta(static_cast<RealType>(2), static_cast<RealType>(1))))); // beta = 1
      BOOST_CHECK((boost::math::isnan)(mode(ignore_error_beta(static_cast<RealType>(1), static_cast<RealType>(2))))); // alpha = 1
-     BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_beta(static_cast<RealType>(1), static_cast<RealType>(1)), 2))); // x > 1
-     BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_beta(static_cast<RealType>(1), static_cast<RealType>(1)), 2))); // x > 1
-     BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_beta(static_cast<RealType>(1), static_cast<RealType>(1)), 2)))); // x > 1
-     BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_beta(static_cast<RealType>(1), static_cast<RealType>(1)), 2))); // p > 1
-     BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_beta(static_cast<RealType>(1), static_cast<RealType>(1)), 2)))); // p > 1
    } // has_infinity
 
    // Error handling checks:
@@ -614,14 +589,6 @@ void test_spots(RealType)
    check_out_of_range<boost::math::beta_distribution<RealType> >(1, 1); // (All) valid constructor parameter values.
    #endif
    // and range and non-finite.
-
-   // Not needed??????
-   BOOST_MATH_CHECK_THROW(pdf(boost::math::beta_distribution<RealType>(0, 1), 0), std::domain_error);
-   BOOST_MATH_CHECK_THROW(pdf(boost::math::beta_distribution<RealType>(-1, 1), 0), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(boost::math::beta_distribution<RealType>(1, 1), -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(boost::math::beta_distribution<RealType>(1, 1), 2), std::domain_error);
-
-
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 8802a1284d..05c6af5e7b 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -171,6 +171,8 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
             BOOST_CHECK((boost::math::isnan)(cdf(complement(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0)))));
             BOOST_CHECK((boost::math::isnan)(logcdf(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0))));
             BOOST_CHECK((boost::math::isnan)(logcdf(complement(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0)))));
+            BOOST_CHECK((boost::math::isnan)(quantile(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0.5))));
+            BOOST_CHECK((boost::math::isnan)(quantile(complement(make_distribution<Ignore_Error_Dist>(params), static_cast<Real>(0.5)))));
         }
     }
 }

From caaf876327793bb3852e63909adac4e4dc12e7c8 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 30 May 2026 17:45:54 -0700
Subject: [PATCH 07/30] Added binomial distribution

---
 test/test_binomial.cpp | 155 +++++++++++++++++------------------------
 1 file changed, 65 insertions(+), 90 deletions(-)

diff --git a/test/test_binomial.cpp b/test/test_binomial.cpp
index b76c8e03e4..792ade96f5 100644
--- a/test/test_binomial.cpp
+++ b/test/test_binomial.cpp
@@ -39,12 +39,14 @@ using boost::math::binomial_distribution;
 #include "table_type.hpp"
 
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 using std::cout;
 using std::endl;
 #include <limits>
 using std::numeric_limits;
+#include <vector>
 
 template <class RealType>
 void test_spot(
@@ -521,69 +523,12 @@ void test_spots(RealType T)
           binomial_distribution<RealType>(static_cast<RealType>(0), static_cast<RealType>(0.25)),
           static_cast<RealType>(0)), static_cast<RealType>(1)
        );
-    BOOST_CHECK_THROW(
-       pdf(
-          binomial_distribution<RealType>(static_cast<RealType>(-1), static_cast<RealType>(0.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       pdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(-0.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       pdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(1.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       pdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(0.25)),
-          static_cast<RealType>(-1)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       pdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(0.25)),
-          static_cast<RealType>(9)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       cdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(0.25)),
-          static_cast<RealType>(-1)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       cdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(0.25)),
-          static_cast<RealType>(9)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       cdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(-0.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       cdf(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(1.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       quantile(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(-0.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-    BOOST_CHECK_THROW(
-       quantile(
-          binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(1.25)),
-          static_cast<RealType>(0)), std::domain_error
-       );
-
     BOOST_CHECK_EQUAL(
        quantile(
           binomial_distribution<RealType>(static_cast<RealType>(16), static_cast<RealType>(0.25)),
           static_cast<RealType>(0.01)), // Less than cdf == pdf(binomial_distribution<RealType>(16, 0.25), 0)
           static_cast<RealType>(0) // so expect zero as best approximation.
        );
-
     BOOST_CHECK_EQUAL(
        cdf(
           binomial_distribution<RealType>(static_cast<RealType>(8), static_cast<RealType>(0.25)),
@@ -610,6 +555,54 @@ void test_spots(RealType T)
           static_cast<RealType>(7))), static_cast<RealType>(1)
        );
 
+   using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{-1, 0.25},
+                                                         {8, -0.25},
+                                                         {8, 1.25}};
+   test_invalid_parameters<binomial_distribution<RealType, boost::math::policies::policy<> >, 
+                           binomial_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan},
+                        {8, nan},
+                        {nan, 8}};
+      test_invalid_parameters<binomial_distribution<RealType, boost::math::policies::policy<> >, 
+                              binomial_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf},
+                        {1, inf},
+                        {inf, 1}};
+      test_invalid_parameters<binomial_distribution<RealType, boost::math::policies::policy<> >, 
+                              binomial_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   } // has_infinity  
+
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<binomial_distribution, RealType>();
+   } // has_quiet_NaN
+
      // Check Error handling and edge cases
      BOOST_CHECK_EQUAL(binomial_distribution<RealType>::find_lower_bound_on_p(static_cast<RealType>(5),
                                                                               static_cast<RealType>(0),
@@ -670,39 +663,21 @@ void test_spots(RealType T)
 
      if (std::numeric_limits<RealType>::has_infinity)
      {
-     // Check isnan policies
-     using boost::math::policies::policy;
-    
-     typedef policy<
-      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-     > ignore_all_policy;
-
-     typedef binomial_distribution<RealType, ignore_all_policy> ignore_error_binomial;
-
-     BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_lower_bound_on_p(static_cast<RealType>(5),
-                                                                                             static_cast<RealType>(2),
-                                                                                             static_cast<RealType>(-0.5)))); // probability < 0
-     BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_upper_bound_on_p(static_cast<RealType>(5),
-                                                                                             static_cast<RealType>(2),
-                                                                                             static_cast<RealType>(-0.5)))); // probability < 0
-     BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_minimum_number_of_trials(static_cast<RealType>(10),
-                                                                                                     static_cast<RealType>(-1),
-                                                                                                     static_cast<RealType>(0.05)))); // probability < 0
-     BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_maximum_number_of_trials(static_cast<RealType>(10),
-                                                                                                     static_cast<RealType>(-1),
-                                                                                                     static_cast<RealType>(0.05)))); // probability < 0
-     
-     BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_binomial(static_cast<RealType>(-8), static_cast<RealType>(0.25)), static_cast<RealType>(8)))); 
-     BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_binomial(static_cast<RealType>(8), static_cast<RealType>(-0.25)), static_cast<RealType>(8))));                                                                                                                                                                                                         
-     BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_binomial(static_cast<RealType>(8), static_cast<RealType>(0.25)), static_cast<RealType>(9))));
-     BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_binomial(static_cast<RealType>(8), static_cast<RealType>(0.25)), static_cast<RealType>(9))));
-     BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_binomial(static_cast<RealType>(8), static_cast<RealType>(0.25)), static_cast<RealType>(9)))));
-     BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_binomial(static_cast<RealType>(8), static_cast<RealType>(0.25)), static_cast<RealType>(-1))));
+      // Check isnan policies
+      typedef binomial_distribution<RealType, ignore_all_policy> ignore_error_binomial;
+
+      BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_lower_bound_on_p(static_cast<RealType>(5),
+                                                                                                static_cast<RealType>(2),
+                                                                                                static_cast<RealType>(-0.5)))); // probability < 0
+      BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_upper_bound_on_p(static_cast<RealType>(5),
+                                                                                                static_cast<RealType>(2),
+                                                                                                static_cast<RealType>(-0.5)))); // probability < 0
+      BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_minimum_number_of_trials(static_cast<RealType>(10),
+                                                                                                      static_cast<RealType>(-1),
+                                                                                                      static_cast<RealType>(0.05)))); // probability < 0
+      BOOST_CHECK((boost::math::isnan)(ignore_error_binomial::find_maximum_number_of_trials(static_cast<RealType>(10),
+                                                                                                      static_cast<RealType>(-1),
+                                                                                                      static_cast<RealType>(0.05)))); // probability < 0
    }
 #endif
 

From 89895bf1777bff0b444499a82f58ca96765e338f Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 30 May 2026 18:07:15 -0700
Subject: [PATCH 08/30] Added infinite support and cauchy dist

---
 test/test_cauchy.cpp       | 106 ++++++++++++++++---------------------
 test/test_dist_helpers.hpp |  12 +++++
 2 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/test/test_cauchy.cpp b/test/test_cauchy.cpp
index cd217c71a2..dd6f2f03b4 100644
--- a/test/test_cauchy.cpp
+++ b/test/test_cauchy.cpp
@@ -680,6 +680,12 @@ void test_spots(RealType T)
          static_cast<RealType>(1-0.039583424160566))),              // x
          static_cast<RealType>(3),  // probability.
          tolerance); // %
+   BOOST_CHECK_EQUAL(
+      ::boost::math::quantile(
+         cauchy_distribution<RealType>(-2, 0.25),
+         static_cast<RealType>(0.5)), // p
+         static_cast<RealType>(-2) // location
+      );
    /*
    BOOST_CHECK_CLOSE(
       ::boost::math::quantile(
@@ -753,68 +759,50 @@ void test_spots(RealType T)
 
    check_out_of_range<boost::math::cauchy_distribution<RealType> >(0, 1); // (All) valid constructor parameter values.
 
+   using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{0, -1}};
+   test_invalid_parameters<cauchy_distribution<RealType, boost::math::policies::policy<> >, 
+                           cauchy_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan},
+                        {0, nan},
+                        {nan, 1}};
+      test_invalid_parameters<cauchy_distribution<RealType, boost::math::policies::policy<> >, 
+                              cauchy_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
    if (std::numeric_limits<RealType>::has_infinity)
    {
-      BOOST_CHECK_EQUAL(
-         boost::math::pdf(
-            cauchy_distribution<RealType>(-2, 0.25),
-            std::numeric_limits<RealType>::infinity()), // x
-            static_cast<RealType>(0) // probability
-         );
-      BOOST_CHECK_EQUAL(
-         boost::math::cdf(
-            cauchy_distribution<RealType>(-2, 0.25),
-            std::numeric_limits<RealType>::infinity()), // x
-            static_cast<RealType>(1) // probability
-         );
-      BOOST_CHECK_EQUAL(
-         boost::math::cdf(
-            cauchy_distribution<RealType>(-2, 0.25),
-            -std::numeric_limits<RealType>::infinity()), // x
-            static_cast<RealType>(0) // probability
-         );
-      BOOST_CHECK_EQUAL(
-         boost::math::quantile(
-            cauchy_distribution<RealType>(-2, 0.25),
-            static_cast<RealType>(0.5)), // p
-            static_cast<RealType>(-2) // location
-         );
-
-      using boost::math::policies::policy;
-
-      typedef policy<
-         boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-         boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-         boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-         boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-         boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-         boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-      > ignore_all_policy;
-
-      typedef boost::math::cauchy_distribution<RealType, ignore_all_policy> ignore_error_cauchy;
-      
-      // PDF
-      BOOST_CHECK((boost::math::isnan)(boost::math::pdf(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(-1)), static_cast<RealType>(0))));
-      BOOST_CHECK((boost::math::isnan)(boost::math::pdf(ignore_error_cauchy(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), static_cast<RealType>(0))));
-      BOOST_CHECK((boost::math::isnan)(boost::math::pdf(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(1)), std::numeric_limits<RealType>::quiet_NaN())));
-   
-      // CDF
-      BOOST_CHECK((boost::math::isnan)(boost::math::cdf(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(-1)), static_cast<RealType>(0))));
-      BOOST_CHECK((boost::math::isnan)(boost::math::cdf(ignore_error_cauchy(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), static_cast<RealType>(0))));
-      BOOST_CHECK((boost::math::isnan)(boost::math::cdf(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(1)), std::numeric_limits<RealType>::quiet_NaN())));
-
-      // Quantile 
-      BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(-1)), static_cast<RealType>(0.25))));
-      BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_error_cauchy(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), static_cast<RealType>(0.25))));
-      BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_error_cauchy(static_cast<RealType>(0), static_cast<RealType>(1)), static_cast<RealType>(-0.25))));
-   
-      if (std::numeric_limits<RealType>::has_quiet_NaN)
-      {
-         test_invalid_support<boost::math::cauchy_distribution, RealType>();
-      }
-      
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf},
+                        {0, inf},
+                        {inf, 1}};
+      test_invalid_parameters<cauchy_distribution<RealType, boost::math::policies::policy<> >, 
+                              cauchy_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<boost::math::cauchy_distribution, RealType>();
    }
-
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE(test_main)
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 05c6af5e7b..dd65859dfe 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -56,6 +56,12 @@ void test_invalid_support()
         BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
     }
+    else // lower bound is -infinity
+    {
+        BOOST_CHECK_EQUAL(pdf(ignore_error_dist, invalid), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(cdf(ignore_error_dist, invalid), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(cdf(complement(ignore_error_dist, invalid)), static_cast<Real>(1));
+    }
     // Test outside upper bound:
     invalid = sup.second;
     if (boost::math::isfinite(invalid))
@@ -81,6 +87,12 @@ void test_invalid_support()
         BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_dist, invalid))));
     }
+    else // upper bound is +infinity
+    {
+        BOOST_CHECK_EQUAL(pdf(ignore_error_dist, invalid), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(cdf(ignore_error_dist, invalid), static_cast<Real>(1));
+        BOOST_CHECK_EQUAL(cdf(complement(ignore_error_dist, invalid)), static_cast<Real>(0));
+    }
 
     // NaN checks for PDF/CDF
     invalid = std::numeric_limits<Real>::quiet_NaN();

From 422439fd77ed013cffc19a738041f7a67b90939a Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 30 May 2026 18:48:29 -0700
Subject: [PATCH 09/30] Added exponential distribution

---
 .../boost/math/distributions/exponential.hpp  |  13 +-
 test/test_dist_helpers.hpp                    |  24 ++--
 test/test_exponential_dist.cpp                | 115 +++++++-----------
 3 files changed, 70 insertions(+), 82 deletions(-)

diff --git a/include/boost/math/distributions/exponential.hpp b/include/boost/math/distributions/exponential.hpp
index 9d45ac4933..badcb2fd3d 100644
--- a/include/boost/math/distributions/exponential.hpp
+++ b/include/boost/math/distributions/exponential.hpp
@@ -109,10 +109,15 @@ template <class RealType, class Policy>
 BOOST_MATH_GPU_ENABLED inline boost::math::pair<RealType, RealType> support(const exponential_distribution<RealType, Policy>& /*dist*/)
 { // Range of supported values for random variable x.
    // This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
-   using boost::math::tools::max_value;
-   using boost::math::tools::min_value;
-   return boost::math::pair<RealType, RealType>(min_value<RealType>(),  max_value<RealType>());
-   // min_value<RealType>() to avoid a discontinuity at x = 0.
+   BOOST_MATH_IF_CONSTEXPR (boost::math::numeric_limits<RealType>::has_infinity)
+   { 
+      return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), boost::math::numeric_limits<RealType>::infinity()); // - to + infinity.
+   }
+   else
+   { // Can only use max_value.
+      using boost::math::tools::max_value;
+      return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>()); // - to + max.
+   }
 }
 
 template <class RealType, class Policy>
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index dd65859dfe..30458f5e6b 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -37,6 +37,10 @@ void test_invalid_support()
     {
         if (invalid == -boost::math::tools::max_value<Real>())
             invalid = -std::numeric_limits<Real>::infinity();
+        else if (invalid == boost::math::tools::min_value<Real>())
+        {
+            invalid = -boost::math::tools::min_value<Real>();
+        }
         else
             invalid = boost::math::float_prior(invalid);
 
@@ -58,9 +62,11 @@ void test_invalid_support()
     }
     else // lower bound is -infinity
     {
-        BOOST_CHECK_EQUAL(pdf(ignore_error_dist, invalid), static_cast<Real>(0));
-        BOOST_CHECK_EQUAL(cdf(ignore_error_dist, invalid), static_cast<Real>(0));
-        BOOST_CHECK_EQUAL(cdf(complement(ignore_error_dist, invalid)), static_cast<Real>(1));
+        BOOST_CHECK_THROW(quantile(dist, static_cast<Real>(0.0)), std::overflow_error);
+        BOOST_CHECK_THROW(quantile(complement(dist, static_cast<Real>(1.0))), std::overflow_error);
+        BOOST_CHECK_EQUAL(pdf(dist, invalid), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(cdf(dist, invalid), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(cdf(complement(dist, invalid)), static_cast<Real>(1));
     }
     // Test outside upper bound:
     invalid = sup.second;
@@ -74,7 +80,7 @@ void test_invalid_support()
         BOOST_CHECK_THROW(pdf(dist, invalid), std::domain_error);
         BOOST_CHECK_THROW(cdf(dist, invalid), std::domain_error);
         BOOST_CHECK_THROW(cdf(complement(dist, invalid)), std::domain_error);
-        // Test NaN handnling
+        // Test NaN handling
         BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_dist, invalid)));
         BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_dist, invalid))));
@@ -89,9 +95,13 @@ void test_invalid_support()
     }
     else // upper bound is +infinity
     {
-        BOOST_CHECK_EQUAL(pdf(ignore_error_dist, invalid), static_cast<Real>(0));
-        BOOST_CHECK_EQUAL(cdf(ignore_error_dist, invalid), static_cast<Real>(1));
-        BOOST_CHECK_EQUAL(cdf(complement(ignore_error_dist, invalid)), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(pdf(dist, invalid), static_cast<Real>(0));
+        BOOST_CHECK_EQUAL(cdf(dist, invalid), static_cast<Real>(1));
+        BOOST_CHECK_EQUAL(cdf(complement(dist, invalid)), static_cast<Real>(0));
+
+        // If support is infinite quantile will throw overflow error
+        BOOST_CHECK_THROW(quantile(dist, static_cast<Real>(1.0)), std::overflow_error);
+        BOOST_CHECK_THROW(quantile(complement(dist, static_cast<Real>(0.0))), std::overflow_error);
     }
 
     // NaN checks for PDF/CDF
diff --git a/test/test_exponential_dist.cpp b/test/test_exponential_dist.cpp
index ecf5106d01..0971d6e079 100644
--- a/test/test_exponential_dist.cpp
+++ b/test/test_exponential_dist.cpp
@@ -21,6 +21,7 @@
 #include <boost/test/unit_test.hpp> // Boost.Test
 #include <boost/test/tools/floating_point_comparison.hpp>
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <cmath>
 #include <type_traits>
@@ -29,7 +30,7 @@
    using std::endl;
    using std::setprecision;
    using std::log;
-
+#include <vector>
 #if __has_include(<stdfloat>)
 #  include <stdfloat>
 #endif
@@ -330,80 +331,52 @@ void test_spots(RealType T)
    //
    // Things that are errors:
    //
-   exponential_distribution<RealType> dist(0.5);
-   BOOST_MATH_CHECK_THROW(
-       quantile(dist, RealType(1.0)),
-       std::overflow_error);
-   BOOST_MATH_CHECK_THROW(
-       quantile(complement(dist, RealType(0.0))),
-       std::overflow_error);
-   BOOST_MATH_CHECK_THROW(
-       pdf(dist, RealType(-1)),
-       std::domain_error);
-   BOOST_MATH_CHECK_THROW(
-       cdf(dist, RealType(-1)),
-       std::domain_error);
-   BOOST_MATH_CHECK_THROW(
-       cdf(exponential_distribution<RealType>(-1), RealType(1)),
-       std::domain_error);
-   BOOST_MATH_CHECK_THROW(
-       quantile(dist, RealType(-1)),
-       std::domain_error);
-   BOOST_MATH_CHECK_THROW(
-       quantile(dist, RealType(2)),
-       std::domain_error);
-
    check_out_of_range<exponential_distribution<RealType> >(2);
-   BOOST_MATH_CHECK_THROW(exponential_distribution<RealType>(0), std::domain_error);
-   BOOST_MATH_CHECK_THROW(exponential_distribution<RealType>(-1), std::domain_error);
-   if(std::numeric_limits<RealType>::has_infinity)
+   
+   using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{-1}, 
+                                                         {0}};
+   test_invalid_parameters<exponential_distribution<RealType, boost::math::policies::policy<> >, 
+                           exponential_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan}};
+      test_invalid_parameters<exponential_distribution<RealType, boost::math::policies::policy<> >, 
+                              exponential_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+      BOOST_CHECK((boost::math::isnan)(mean(exponential_distribution<RealType, ignore_all_policy>(static_cast<RealType>(-1)))));
+      BOOST_CHECK((boost::math::isnan)(standard_deviation(exponential_distribution<RealType, ignore_all_policy>(static_cast<RealType>(-1)))));
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
    {
+      // Attempt to construct from non-finite should throw.
       RealType inf = std::numeric_limits<RealType>::infinity();
-      BOOST_CHECK_EQUAL(pdf(exponential_distribution<RealType>(2), inf), 0);
-      BOOST_CHECK_EQUAL(cdf(exponential_distribution<RealType>(2), inf), 1);
-      BOOST_CHECK_EQUAL(cdf(complement(exponential_distribution<RealType>(2), inf)), 0);
-
-      // Test NaN policies
-      using boost::math::policies::policy;
+      invalid_params = {{inf}};
+      test_invalid_parameters<exponential_distribution<RealType, boost::math::policies::policy<> >, 
+                              exponential_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
 
-      typedef policy<
-         boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-         boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-         boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-         boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-         boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-         boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-      > ignore_all_policy;
-
-      typedef boost::math::exponential_distribution<RealType, ignore_all_policy> ignore_error_exponential;
-
-      // PDF
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(1))));
-      BOOST_CHECK((boost::math::isnan)(pdf(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-1))));
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(1))));
-      BOOST_CHECK((boost::math::isnan)(logpdf(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-1))));
-
-      // CDF
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(1))));
-      BOOST_CHECK((boost::math::isnan)(cdf(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-1))));
-      BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(1))));
-      BOOST_CHECK((boost::math::isnan)(logcdf(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-1))));
-      
-      // Complement CDF
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(1)))));
-      BOOST_CHECK((boost::math::isnan)(cdf(complement(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-1)))));
-      BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(1)))));
-      BOOST_CHECK((boost::math::isnan)(logcdf(complement(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-1)))));
-
-      // Quantile
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(0.5))));
-      BOOST_CHECK((boost::math::isnan)(quantile(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-0.5))));
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_exponential(static_cast<RealType>(-1)), static_cast<RealType>(0.5)))));
-      BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_exponential(static_cast<RealType>(1)), static_cast<RealType>(-0.5)))));
-
-      // Mean and Standard Deviation
-      BOOST_CHECK((boost::math::isnan)(mean(ignore_error_exponential(static_cast<RealType>(-1)))));
-      BOOST_CHECK((boost::math::isnan)(standard_deviation(ignore_error_exponential(static_cast<RealType>(-1)))));
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<boost::math::exponential_distribution, RealType>();
    }
 } // template <class RealType>void test_spots(RealType)
 

From b0c77e74f23dcea84517c8e73fdf19b49e0c26d1 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sun, 31 May 2026 08:35:51 -0700
Subject: [PATCH 10/30] Changed signature of test_invalid_support; added f
 distribution

---
 .../boost/math/distributions/exponential.hpp  |   9 --
 include/boost/math/distributions/fisher_f.hpp |  28 ++---
 test/test_arcsine.cpp                         |   4 +-
 test/test_bernoulli.cpp                       |   4 +-
 test/test_beta_dist.cpp                       |   6 +-
 test/test_binomial.cpp                        |   4 +-
 test/test_cauchy.cpp                          |   4 +-
 test/test_dist_helpers.hpp                    |  78 +++++-------
 test/test_exponential_dist.cpp                |   4 +-
 test/test_fisher_f.cpp                        | 117 ++++++++----------
 10 files changed, 120 insertions(+), 138 deletions(-)

diff --git a/include/boost/math/distributions/exponential.hpp b/include/boost/math/distributions/exponential.hpp
index badcb2fd3d..1022e5a8a8 100644
--- a/include/boost/math/distributions/exponential.hpp
+++ b/include/boost/math/distributions/exponential.hpp
@@ -133,9 +133,6 @@ BOOST_MATH_GPU_ENABLED inline RealType pdf(const exponential_distribution<RealTy
       return result;
    if(0 == detail::verify_exp_x(function, x, &result, Policy()))
       return result;
-   // Workaround for VC11/12 bug:
-   if ((boost::math::isinf)(x))
-      return 0;
    result = lambda * exp(-lambda * x);
    return result;
 } // pdf
@@ -230,9 +227,6 @@ BOOST_MATH_GPU_ENABLED inline RealType cdf(const complemented2_type<exponential_
       return result;
    if(0 == detail::verify_exp_x(function, c.param, &result, Policy()))
       return result;
-   // Workaround for VC11/12 bug:
-   if (c.param >= tools::max_value<RealType>())
-      return 0;
    result = exp(-c.param * lambda);
 
    return result;
@@ -251,9 +245,6 @@ BOOST_MATH_GPU_ENABLED inline RealType logcdf(const complemented2_type<exponenti
       return result;
    if(0 == detail::verify_exp_x(function, c.param, &result, Policy()))
       return result;
-   // Workaround for VC11/12 bug:
-   if (c.param >= tools::max_value<RealType>())
-      return 0;
    result = -c.param * lambda;
 
    return result;
diff --git a/include/boost/math/distributions/fisher_f.hpp b/include/boost/math/distributions/fisher_f.hpp
index 56b288d88e..09d89a24aa 100644
--- a/include/boost/math/distributions/fisher_f.hpp
+++ b/include/boost/math/distributions/fisher_f.hpp
@@ -140,10 +140,10 @@ BOOST_MATH_GPU_ENABLED inline RealType cdf(const fisher_f_distribution<RealType,
    RealType df2 = dist.degrees_of_freedom2();
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
          function, df1, &error_result, Policy())
          && detail::check_df(
-         function, df2, &error_result, Policy()))
+         function, df2, &error_result, Policy())))
       return error_result;
 
    if((x < 0) || !(boost::math::isfinite)(x))
@@ -201,10 +201,10 @@ BOOST_MATH_GPU_ENABLED inline RealType cdf(const complemented2_type<fisher_f_dis
    RealType x = c.param;
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
          function, df1, &error_result, Policy())
          && detail::check_df(
-         function, df2, &error_result, Policy()))
+         function, df2, &error_result, Policy())))
       return error_result;
 
    if((x < 0) || !(boost::math::isfinite)(x))
@@ -260,10 +260,10 @@ BOOST_MATH_GPU_ENABLED inline RealType mean(const fisher_f_distribution<RealType
    RealType df2 = dist.degrees_of_freedom2();
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
             function, df1, &error_result, Policy())
          && detail::check_df(
-            function, df2, &error_result, Policy()))
+            function, df2, &error_result, Policy())))
       return error_result;
    if(df2 <= 2)
    {
@@ -281,10 +281,10 @@ BOOST_MATH_GPU_ENABLED inline RealType variance(const fisher_f_distribution<Real
    RealType df2 = dist.degrees_of_freedom2();
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
             function, df1, &error_result, Policy())
          && detail::check_df(
-            function, df2, &error_result, Policy()))
+            function, df2, &error_result, Policy())))
       return error_result;
    if(df2 <= 4)
    {
@@ -302,10 +302,10 @@ BOOST_MATH_GPU_ENABLED inline RealType mode(const fisher_f_distribution<RealType
    RealType df2 = dist.degrees_of_freedom2();
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
             function, df1, &error_result, Policy())
          && detail::check_df(
-            function, df2, &error_result, Policy()))
+            function, df2, &error_result, Policy())))
       return error_result;
    if(df1 <= 2)
    {
@@ -333,10 +333,10 @@ BOOST_MATH_GPU_ENABLED inline RealType skewness(const fisher_f_distribution<Real
    RealType df2 = dist.degrees_of_freedom2();
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
             function, df1, &error_result, Policy())
          && detail::check_df(
-            function, df2, &error_result, Policy()))
+            function, df2, &error_result, Policy())))
       return error_result;
    if(df2 <= 6)
    {
@@ -364,10 +364,10 @@ BOOST_MATH_GPU_ENABLED inline RealType kurtosis_excess(const fisher_f_distributi
    RealType df2 = dist.degrees_of_freedom2();
    // Error check:
    RealType error_result = 0;
-   if(false == detail::check_df(
+   if(false == (detail::check_df(
             function, df1, &error_result, Policy())
          && detail::check_df(
-            function, df2, &error_result, Policy()))
+            function, df2, &error_result, Policy())))
       return error_result;
    if(df2 <= 8)
    {
diff --git a/test/test_arcsine.cpp b/test/test_arcsine.cpp
index 17ee3c8e24..070a94c6a9 100644
--- a/test/test_arcsine.cpp
+++ b/test/test_arcsine.cpp
@@ -154,7 +154,9 @@ void test_ignore_policy(RealType)
     BOOST_CHECK(boost::math::isfinite(mean(ignore_error_arcsine(0, std::numeric_limits<RealType>::epsilon()))));
 
     check_support<arcsine_distribution<RealType> >(arcsine_distribution<RealType>(0, 1));
-    test_invalid_support<arcsine_distribution, RealType>();
+    test_invalid_support<arcsine_distribution<RealType, boost::math::policies::policy<> >, 
+                         arcsine_distribution<RealType, ignore_all_policy>,
+                         RealType>({0, 1});
   } // ordinary floats.
 } // template <class RealType> void test_ignore_policy(RealType)
 
diff --git a/test/test_bernoulli.cpp b/test/test_bernoulli.cpp
index 3b97b41f46..5257fa0ee5 100644
--- a/test/test_bernoulli.cpp
+++ b/test/test_bernoulli.cpp
@@ -279,7 +279,9 @@ void test_spots(RealType)
    
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<bernoulli_distribution, RealType>();
+      test_invalid_support<bernoulli_distribution<RealType, boost::math::policies::policy<> >, 
+                           bernoulli_distribution<RealType, ignore_all_policy>,
+                           RealType>({0.5});
    } // has_quiet_NaN
 } // template <class RealType>void test_spots(RealType)
 
diff --git a/test/test_beta_dist.cpp b/test/test_beta_dist.cpp
index ea585e4da7..8764038a89 100644
--- a/test/test_beta_dist.cpp
+++ b/test/test_beta_dist.cpp
@@ -543,7 +543,9 @@ void test_spots(RealType)
 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<beta_distribution, RealType>();
+      test_invalid_support<beta_distribution<RealType, boost::math::policies::policy<> >, 
+                           beta_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1, 1});
    } // has_quiet_NaN
    
    // PDF not defind for alpha < 1, x = 0 and beta < 1, x = 1
@@ -573,6 +575,8 @@ void test_spots(RealType)
 
      BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_alpha(inf, static_cast<RealType>(0.5)))); // mean = inf
      BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_beta(inf, static_cast<RealType>(0.5)))); // mean = inf
+     BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_alpha(static_cast<RealType>(0.5), inf))); // var = inf
+     BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_beta(static_cast<RealType>(0.5), inf))); // var = inf
      BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_alpha(inf, static_cast<RealType>(0.5), static_cast<RealType>(0.5)))); // beta = inf
      BOOST_CHECK((boost::math::isnan)(ignore_error_beta::find_beta(inf, static_cast<RealType>(0.5), static_cast<RealType>(0.5)))); // alpha = inf
      BOOST_CHECK((boost::math::isnan)(mode(ignore_error_beta(static_cast<RealType>(2), static_cast<RealType>(1))))); // beta = 1
diff --git a/test/test_binomial.cpp b/test/test_binomial.cpp
index 792ade96f5..9ec3934f76 100644
--- a/test/test_binomial.cpp
+++ b/test/test_binomial.cpp
@@ -600,7 +600,9 @@ void test_spots(RealType T)
 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<binomial_distribution, RealType>();
+      test_invalid_support<binomial_distribution<RealType, boost::math::policies::policy<> >, 
+                           binomial_distribution<RealType, ignore_all_policy>, 
+                           RealType>({10, 0.5});
    } // has_quiet_NaN
 
      // Check Error handling and edge cases
diff --git a/test/test_cauchy.cpp b/test/test_cauchy.cpp
index dd6f2f03b4..711efa57f5 100644
--- a/test/test_cauchy.cpp
+++ b/test/test_cauchy.cpp
@@ -801,7 +801,9 @@ void test_spots(RealType T)
    } // has_infinity 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<boost::math::cauchy_distribution, RealType>();
+      test_invalid_support<cauchy_distribution<RealType, boost::math::policies::policy<> >, 
+                           cauchy_distribution<RealType, ignore_all_policy>, 
+                           RealType>({0, 1});
    }
 } // template <class RealType>void test_spots(RealType)
 
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 30458f5e6b..d8c45ca5e7 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -10,23 +10,41 @@
 #include <boost/math/policies/policy.hpp>
 #include <boost/test/tools/floating_point_comparison.hpp>
 
-template <template <typename, typename> typename Distribution, class Real>
-void test_invalid_support()
+template <class Dist, class Container>
+Dist make_distribution(const Container& c)
 {
-    using boost::math::policies::policy;
-    using namespace boost::math;
+    using value_type = typename Dist::value_type;
+    if constexpr (std::is_constructible_v<Dist, value_type, value_type, value_type>)
+    {
+        if (c.size() >= 3)
+            return Dist(c.data()[0], c.data()[1], c.data()[2]);
+    }
+    if constexpr (std::is_constructible_v<Dist, value_type, value_type>)
+    {
+        if (c.size() >= 2)
+            return Dist(c.data()[0], c.data()[1]);
+    }
+    if constexpr (std::is_constructible_v<Dist, value_type>)
+    {
+        if (c.size() >= 1)
+            return Dist(c.data()[0]);
+    }
+    throw std::domain_error("Object not initialized!");
+}
+
+template <class Dist, class V>
+Dist make_distribution(const std::initializer_list<V>& c)
+{
+    return make_distribution<Dist, std::initializer_list<V>>(c);
+}
 
-    typedef policy<
-      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-    > ignore_all_policy;
-
-    Distribution<Real, ignore_all_policy> ignore_error_dist;
-    Distribution<Real, policy<> > dist; 
+template <class Dist, class Ignore_Error_Dist, class Real>
+void test_invalid_support(std::vector<Real> params)
+{
+    using namespace boost::math;
+    
+    Dist dist = make_distribution<Dist>(params); 
+    Ignore_Error_Dist ignore_error_dist = make_distribution<Ignore_Error_Dist>(params);
     
     /* We will assume that std::numeric_limits<Distribution::value_type>::has_infinity */
     std::pair<Real, Real> sup = support(dist);
@@ -137,34 +155,6 @@ void test_invalid_support()
     BOOST_CHECK((boost::math::isnan)(quantile(complement(ignore_error_dist, static_cast<Real>(2))))); // q > 1
 }
 
-template <class Dist, class Container>
-Dist make_distribution(const Container& c)
-{
-    using value_type = typename Dist::value_type;
-    if constexpr (std::is_constructible_v<Dist, value_type, value_type, value_type>)
-    {
-        if (c.size() >= 3)
-            return Dist(c.data()[0], c.data()[1], c.data()[2]);
-    }
-    if constexpr (std::is_constructible_v<Dist, value_type, value_type>)
-    {
-        if (c.size() >= 2)
-            return Dist(c.data()[0], c.data()[1]);
-    }
-    if constexpr (std::is_constructible_v<Dist, value_type>)
-    {
-        if (c.size() >= 1)
-            return Dist(c.data()[0]);
-    }
-    return Dist();
-}
-
-template <class Dist, class V>
-Dist make_distribution(const std::initializer_list<V>& c)
-{
-    return make_distribution<Dist, std::initializer_list<V>>(c);
-}
-
 template <class Dist, class Ignore_Error_Dist, class Real>
 void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
 {
@@ -172,7 +162,7 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
     for (unsigned i=0; i<invalid_parameters.size(); i++)
     {
         params = invalid_parameters[i];
-
+        std::cout << params[0] << "," << params[1] << std::endl;
         // Check functions throw with bad constructors
         BOOST_CHECK_THROW(make_distribution<Dist>(params), std::domain_error);
         BOOST_CHECK_THROW(pdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
diff --git a/test/test_exponential_dist.cpp b/test/test_exponential_dist.cpp
index 0971d6e079..3c1a034202 100644
--- a/test/test_exponential_dist.cpp
+++ b/test/test_exponential_dist.cpp
@@ -376,7 +376,9 @@ void test_spots(RealType T)
    } // has_infinity 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<boost::math::exponential_distribution, RealType>();
+      test_invalid_support<exponential_distribution<RealType, boost::math::policies::policy<> >, 
+                           exponential_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1});
    }
 } // template <class RealType>void test_spots(RealType)
 
diff --git a/test/test_fisher_f.cpp b/test/test_fisher_f.cpp
index 0739dfbda2..30985f3d71 100644
--- a/test/test_fisher_f.cpp
+++ b/test/test_fisher_f.cpp
@@ -27,12 +27,14 @@ using boost::math::fisher_f_distribution;
 #include <boost/test/unit_test.hpp> // for test_main
 #include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 using std::cout;
 using std::endl;
 #include <limits>
 using std::numeric_limits;
+#include <vector>
 
 template <class RealType>
 RealType naive_pdf(RealType df1, RealType df2, RealType x)
@@ -444,72 +446,57 @@ void test_spots(RealType)
        cdf(complement(fisher_f_distribution<RealType>(3, 3), static_cast<RealType>(0)))
        , static_cast<RealType>(1));
 
-    BOOST_MATH_CHECK_THROW(
-       pdf(
-          fisher_f_distribution<RealType>(-1, 2),
-          static_cast<RealType>(1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       pdf(
-          fisher_f_distribution<RealType>(1, -1),
-          static_cast<RealType>(1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       pdf(
-          fisher_f_distribution<RealType>(8, 2),
-          static_cast<RealType>(-1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       cdf(
-          fisher_f_distribution<RealType>(-1, 1),
-          static_cast<RealType>(1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       cdf(
-          fisher_f_distribution<RealType>(8, 4),
-          static_cast<RealType>(-1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       cdf(complement(
-          fisher_f_distribution<RealType>(-1, 2),
-          static_cast<RealType>(1))), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       cdf(complement(
-          fisher_f_distribution<RealType>(8, 4),
-          static_cast<RealType>(-1))), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       quantile(
-          fisher_f_distribution<RealType>(-1, 2),
-          static_cast<RealType>(0.5)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       quantile(
-          fisher_f_distribution<RealType>(8, 8),
-          static_cast<RealType>(-1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       quantile(
-          fisher_f_distribution<RealType>(8, 8),
-          static_cast<RealType>(1.1)), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       quantile(complement(
-          fisher_f_distribution<RealType>(2, -1),
-          static_cast<RealType>(0.5))), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       quantile(complement(
-          fisher_f_distribution<RealType>(8, 8),
-          static_cast<RealType>(-1))), std::domain_error
-       );
-    BOOST_MATH_CHECK_THROW(
-       quantile(complement(
-          fisher_f_distribution<RealType>(8, 8),
-          static_cast<RealType>(1.1))), std::domain_error
-       );
    check_out_of_range<fisher_f_distribution<RealType> >(2, 3);
+
+   using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{-1, 1}, 
+                                                         {0, 1},
+                                                         {1, -1},
+                                                         {1, 0}};
+   test_invalid_parameters<fisher_f_distribution<RealType, boost::math::policies::policy<> >, 
+                           fisher_f_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan, 1},
+                        {1, nan}};
+      test_invalid_parameters<fisher_f_distribution<RealType, boost::math::policies::policy<> >, 
+                              fisher_f_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf, 1},
+                        {1, inf}};
+      test_invalid_parameters<fisher_f_distribution<RealType, boost::math::policies::policy<> >, 
+                              fisher_f_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<fisher_f_distribution<RealType, boost::math::policies::policy<> >, 
+                           fisher_f_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1, 1});
+   }
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )

From 02c102b5ebce84ab13a2ca8e578ab61ba947933f Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sun, 31 May 2026 09:07:42 -0700
Subject: [PATCH 11/30] Added more tests for fisher distribution

---
 test/test_fisher_f.cpp | 31 ++++++++++++++++++++++++++++++-
 1 file changed, 30 insertions(+), 1 deletion(-)

diff --git a/test/test_fisher_f.cpp b/test/test_fisher_f.cpp
index 30985f3d71..f71a1c6cfb 100644
--- a/test/test_fisher_f.cpp
+++ b/test/test_fisher_f.cpp
@@ -476,7 +476,36 @@ void test_spots(RealType)
       test_invalid_parameters<fisher_f_distribution<RealType, boost::math::policies::policy<> >, 
                               fisher_f_distribution<RealType, ignore_all_policy>, 
                               RealType>(invalid_params);
-
+      
+      // Check moment function for bad constructors
+      BOOST_CHECK_THROW(mean(fisher_f_distribution<RealType, boost::math::policies::policy<> >(-1, 1)), std::domain_error);
+      BOOST_CHECK_THROW(mean(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, -1)), std::domain_error);
+      BOOST_CHECK_THROW(variance(fisher_f_distribution<RealType, boost::math::policies::policy<> >(-1, 1)), std::domain_error);
+      BOOST_CHECK_THROW(variance(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, -1)), std::domain_error);
+      BOOST_CHECK_THROW(mode(fisher_f_distribution<RealType, boost::math::policies::policy<> >(-1, 1)), std::domain_error);
+      BOOST_CHECK_THROW(mode(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, -1)), std::domain_error);
+      BOOST_CHECK_THROW(skewness(fisher_f_distribution<RealType, boost::math::policies::policy<> >(-1, 1)), std::domain_error);
+      BOOST_CHECK_THROW(skewness(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, -1)), std::domain_error);
+      BOOST_CHECK_THROW(kurtosis_excess(fisher_f_distribution<RealType, boost::math::policies::policy<> >(-1, 1)), std::domain_error);
+      BOOST_CHECK_THROW(kurtosis_excess(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, -1)), std::domain_error);
+      
+      BOOST_CHECK((boost::math::isnan)(mean(fisher_f_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(mean(fisher_f_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(variance(fisher_f_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(variance(fisher_f_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(mode(fisher_f_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(mode(fisher_f_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(skewness(fisher_f_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(skewness(fisher_f_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(kurtosis_excess(fisher_f_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(kurtosis_excess(fisher_f_distribution<RealType, ignore_all_policy>(1, -1))));
+
+      // Check undefined moments
+      BOOST_CHECK_THROW(mean(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, 2)), std::domain_error);
+      BOOST_CHECK_THROW(variance(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, 4)), std::domain_error);
+      BOOST_CHECK_THROW(mode(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, 2)), std::domain_error);
+      BOOST_CHECK_THROW(skewness(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, 6)), std::domain_error);
+      BOOST_CHECK_THROW(kurtosis_excess(fisher_f_distribution<RealType, boost::math::policies::policy<> >(1, 8)), std::domain_error);
    }
 
    // Check construcing with Infinity

From 9d85b799bbe1df1a645b08bc7476e801912f5fa2 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sun, 31 May 2026 09:24:31 -0700
Subject: [PATCH 12/30] Added gamma distribution

---
 test/test_gamma_dist.cpp | 54 +++++++++++++++++++++++++++++++++++++---
 1 file changed, 50 insertions(+), 4 deletions(-)

diff --git a/test/test_gamma_dist.cpp b/test/test_gamma_dist.cpp
index f1abbfd995..7001d0a11c 100644
--- a/test/test_gamma_dist.cpp
+++ b/test/test_gamma_dist.cpp
@@ -35,6 +35,7 @@
     using boost::math::gamma_distribution;
 #include "../include_private/boost/math/tools/test.hpp"
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 #include <iomanip>
@@ -241,10 +242,55 @@ void test_spots(RealType)
 
    // error tests
    check_out_of_range<boost::math::gamma_distribution<RealType> >(1, 1);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(0, 1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(-1, 1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(1, 0), std::domain_error);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(1, -1), std::domain_error);
+
+   using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{-1, 1}, 
+                                                         {0, 1},
+                                                         {1, -1},
+                                                         {1, 0}};
+   test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                           gamma_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan, 1},
+                        {1, nan}};
+      test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                              gamma_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf, 1},
+                        {1, inf}};
+      test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                              gamma_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                           gamma_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1, 1});
+   }
 
 } // template <class RealType>void test_spots(RealType)
 

From 3309790b52ffaa17a7707603f984b58d2933676e Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sun, 31 May 2026 09:39:49 -0700
Subject: [PATCH 13/30] Added geometric distribution

---
 .../boost/math/distributions/geometric.hpp    |  4 +-
 test/test_dist_helpers.hpp                    |  1 -
 test/test_geometric.cpp                       | 48 ++++++++++++++++++-
 3 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/include/boost/math/distributions/geometric.hpp b/include/boost/math/distributions/geometric.hpp
index 0a7b383c24..22f70a4dbd 100644
--- a/include/boost/math/distributions/geometric.hpp
+++ b/include/boost/math/distributions/geometric.hpp
@@ -396,7 +396,7 @@ namespace boost
         k,
         &result, Policy()))
       {
-        return -boost::math::numeric_limits<RealType>::infinity();
+        return result;
       }
       if(k == 0)
       {
@@ -452,7 +452,7 @@ namespace boost
         k,
         &result, Policy()))
       {
-        return -boost::math::numeric_limits<RealType>::infinity();
+        return result;
       }
 
       return boost::math::log1p(-p, Policy()) * (k+1);
diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index d8c45ca5e7..bc69154b6c 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -162,7 +162,6 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
     for (unsigned i=0; i<invalid_parameters.size(); i++)
     {
         params = invalid_parameters[i];
-        std::cout << params[0] << "," << params[1] << std::endl;
         // Check functions throw with bad constructors
         BOOST_CHECK_THROW(make_distribution<Dist>(params), std::domain_error);
         BOOST_CHECK_THROW(pdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
diff --git a/test/test_geometric.cpp b/test/test_geometric.cpp
index 7e1a00f574..d83378260a 100644
--- a/test/test_geometric.cpp
+++ b/test/test_geometric.cpp
@@ -49,6 +49,7 @@ using boost::math::geometric; // using typedef for geometric_distribution<double
 #include <boost/test/unit_test.hpp> // for test_main
 #include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 using std::cout;
@@ -798,8 +799,53 @@ if(std::numeric_limits<RealType>::is_specialized)
       negative_binomial_distribution<RealType>::find_maximum_number_of_trials(k, p, alpha),
     tolerance);
   }
+
+  using boost::math::policies::policy;
+
+  typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+  > ignore_all_policy;
+
+  std::vector<std::vector<RealType> > invalid_params = {{-1}, 
+                                                        {2}};
+  test_invalid_parameters<geometric_distribution<RealType, boost::math::policies::policy<> >, 
+                          geometric_distribution<RealType, ignore_all_policy>, 
+                          RealType>(invalid_params);
+
+  // Check constructing with NaNs
+  if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan}};
+      test_invalid_parameters<geometric_distribution<RealType, boost::math::policies::policy<> >, 
+                              geometric_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+  }
+
+  // Check construcing with Infinity
+  if (std::numeric_limits<RealType>::has_infinity)
+  {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf}};
+      test_invalid_parameters<geometric_distribution<RealType, boost::math::policies::policy<> >, 
+                              geometric_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+  } // has_infinity 
+  if (std::numeric_limits<RealType>::has_quiet_NaN)
+  {
+      test_invalid_support<geometric_distribution<RealType, boost::math::policies::policy<> >, 
+                           geometric_distribution<RealType, ignore_all_policy>, 
+                           RealType>({0.5});
+  }
     //geometric::find_upper_bound_on_p(k, alpha);
-   return;
+  return;
 } // template <class RealType> void test_spots(RealType) // Any floating-point type RealType.
 
 BOOST_AUTO_TEST_CASE( test_main )

From 0a261c0699c9ce1b2ab4c76d8d04aad78d8bac69 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sun, 31 May 2026 17:10:00 -0700
Subject: [PATCH 14/30] Reverted gamma distribution

---
 test/test_cauchy.cpp     |  1 -
 test/test_gamma_dist.cpp | 55 ++++------------------------------------
 2 files changed, 5 insertions(+), 51 deletions(-)

diff --git a/test/test_cauchy.cpp b/test/test_cauchy.cpp
index 711efa57f5..cb1ed131c1 100644
--- a/test/test_cauchy.cpp
+++ b/test/test_cauchy.cpp
@@ -26,7 +26,6 @@
 // To compile even if Cauchy mean is used.
 #include <boost/math/concepts/real_concept.hpp> // for real_concept
 #include <boost/math/distributions/cauchy.hpp>
-#include <boost/math/distributions/arcsine.hpp>
     using boost::math::cauchy_distribution;
 
 #define BOOST_TEST_MAIN
diff --git a/test/test_gamma_dist.cpp b/test/test_gamma_dist.cpp
index 7001d0a11c..96956a5624 100644
--- a/test/test_gamma_dist.cpp
+++ b/test/test_gamma_dist.cpp
@@ -35,7 +35,6 @@
     using boost::math::gamma_distribution;
 #include "../include_private/boost/math/tools/test.hpp"
 #include "test_out_of_range.hpp"
-#include "test_dist_helpers.hpp"
 
 #include <iostream>
 #include <iomanip>
@@ -242,55 +241,11 @@ void test_spots(RealType)
 
    // error tests
    check_out_of_range<boost::math::gamma_distribution<RealType> >(1, 1);
-
-   using boost::math::policies::policy;
-
-   typedef policy<
-      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
-      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
-      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
-      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
-      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
-   > ignore_all_policy;
-
-   std::vector<std::vector<RealType> > invalid_params = {{-1, 1}, 
-                                                         {0, 1},
-                                                         {1, -1},
-                                                         {1, 0}};
-   test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
-                           gamma_distribution<RealType, ignore_all_policy>, 
-                           RealType>(invalid_params);
-
-   // Check constructing with NaNs
-   if (std::numeric_limits<RealType>::has_quiet_NaN){
-      // Attempt to construct from non-finite parameters should throw.
-      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
-      invalid_params = {{nan, 1},
-                        {1, nan}};
-      test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
-                              gamma_distribution<RealType, ignore_all_policy>, 
-                              RealType>(invalid_params);
-   }
-
-   // Check construcing with Infinity
-   if (std::numeric_limits<RealType>::has_infinity)
-   {
-      // Attempt to construct from non-finite should throw.
-      RealType inf = std::numeric_limits<RealType>::infinity();
-      invalid_params = {{inf, 1},
-                        {1, inf}};
-      test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
-                              gamma_distribution<RealType, ignore_all_policy>, 
-                              RealType>(invalid_params);
-
-   } // has_infinity 
-   if (std::numeric_limits<RealType>::has_quiet_NaN)
-   {
-      test_invalid_support<gamma_distribution<RealType, boost::math::policies::policy<> >, 
-                           gamma_distribution<RealType, ignore_all_policy>, 
-                           RealType>({1, 1});
-   }
+   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(0, 1), std::domain_error);
+   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(-1, 1), std::domain_error);
+   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(1, 0), std::domain_error);
+   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(1, -1), std::domain_error);
+   BOOST_MATH_CHECK_THROW(quantile(boost::math::gamma_distribution<RealType>(1, 1), 1), std::overflow_error);
 
 } // template <class RealType>void test_spots(RealType)
 

From b42ac2bfc14d18013b3d14ed170c3d3c6a7d5261 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 09:35:00 -0700
Subject: [PATCH 15/30] Changed gamma support to [0, inf)

---
 include/boost/math/distributions/gamma.hpp | 68 +++++++++++++++++++---
 test/test_gamma_dist.cpp                   | 53 +++++++++++++++--
 2 files changed, 108 insertions(+), 13 deletions(-)

diff --git a/include/boost/math/distributions/gamma.hpp b/include/boost/math/distributions/gamma.hpp
index 5176f906d8..eb42efe914 100644
--- a/include/boost/math/distributions/gamma.hpp
+++ b/include/boost/math/distributions/gamma.hpp
@@ -57,6 +57,22 @@ BOOST_MATH_GPU_ENABLED inline bool check_gamma_x(
    return true;
 }
 
+template <class RealType, class Policy>
+BOOST_MATH_GPU_ENABLED inline bool check_gamma_x_positive(
+      const char* function,
+      RealType const& x,
+      RealType* result, const Policy& pol)
+{
+   if((x < 0) || (boost::math::isnan)(x))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Random variate is %1% but must be >= 0 !", x, pol);
+      return false;
+   }
+   return true;
+}
+
 template <class RealType, class Policy>
 BOOST_MATH_GPU_ENABLED inline bool check_gamma(
       const char* function,
@@ -112,17 +128,30 @@ gamma_distribution(RealType,RealType)->gamma_distribution<typename boost::math::
 template <class RealType, class Policy>
 BOOST_MATH_GPU_ENABLED inline boost::math::pair<RealType, RealType> range(const gamma_distribution<RealType, Policy>& /* dist */)
 { // Range of permissible values for random variable x.
-   using boost::math::tools::max_value;
-   return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>());
+  BOOST_MATH_IF_CONSTEXPR (boost::math::numeric_limits<RealType>::has_infinity)
+  { 
+      return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), boost::math::numeric_limits<RealType>::infinity()); // 0 to + infinity.
+  }
+  else
+  {
+      using boost::math::tools::max_value;
+      return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>()); // 0 to + max
+  }
 }
 
 template <class RealType, class Policy>
 BOOST_MATH_GPU_ENABLED inline boost::math::pair<RealType, RealType> support(const gamma_distribution<RealType, Policy>& /* dist */)
 { // Range of supported values for random variable x.
    // This is range where cdf rises from 0 to 1, and outside it, the pdf is zero.
-   using boost::math::tools::max_value;
-   using boost::math::tools::min_value;
-   return boost::math::pair<RealType, RealType>(min_value<RealType>(),  max_value<RealType>());
+  BOOST_MATH_IF_CONSTEXPR (boost::math::numeric_limits<RealType>::has_infinity)
+  { 
+      return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), boost::math::numeric_limits<RealType>::infinity()); // 0 to + infinity.
+  }
+  else
+  {
+      using boost::math::tools::max_value;
+      return boost::math::pair<RealType, RealType>(static_cast<RealType>(0), max_value<RealType>()); // 0 to + max
+   }
 }
 
 template <class RealType, class Policy>
@@ -138,13 +167,18 @@ BOOST_MATH_GPU_ENABLED inline RealType pdf(const gamma_distribution<RealType, Po
    RealType result = 0;
    if(false == detail::check_gamma(function, scale, shape, &result, Policy()))
       return result;
-   if(false == detail::check_gamma_x(function, x, &result, Policy()))
+   if(false == detail::check_gamma_x_positive(function, x, &result, Policy()))
       return result;
 
    if(x == 0)
    {
       return 0;
    }
+   if ((boost::math::isinf)(x))
+   {
+      return 0;
+   }
+
    result = gamma_p_derivative(shape, x / scale, Policy()) / scale;
    return result;
 } // pdf
@@ -189,8 +223,17 @@ BOOST_MATH_GPU_ENABLED inline RealType cdf(const gamma_distribution<RealType, Po
    RealType result = 0;
    if(false == detail::check_gamma(function, scale, shape, &result, Policy()))
       return result;
-   if(false == detail::check_gamma_x(function, x, &result, Policy()))
+   if(false == detail::check_gamma_x_positive(function, x, &result, Policy()))
       return result;
+   
+   if(x == 0)
+   {
+      return 0;
+   }
+   if ((boost::math::isinf)(x))
+   {
+      return 1;
+   }
 
    result = boost::math::gamma_p(shape, x / scale, Policy());
    return result;
@@ -233,9 +276,18 @@ BOOST_MATH_GPU_ENABLED inline RealType cdf(const complemented2_type<gamma_distri
    RealType result = 0;
    if(false == detail::check_gamma(function, scale, shape, &result, Policy()))
       return result;
-   if(false == detail::check_gamma_x(function, c.param, &result, Policy()))
+   if(false == detail::check_gamma_x_positive(function, c.param, &result, Policy()))
       return result;
 
+   if(c.param == 0)
+   {
+      return 1;
+   }
+   if ((boost::math::isinf)(c.param))
+   {
+      return 0;
+   }
+
    result = gamma_q(shape, c.param / scale, Policy());
 
    return result;
diff --git a/test/test_gamma_dist.cpp b/test/test_gamma_dist.cpp
index 96956a5624..75d7c06042 100644
--- a/test/test_gamma_dist.cpp
+++ b/test/test_gamma_dist.cpp
@@ -35,6 +35,7 @@
     using boost::math::gamma_distribution;
 #include "../include_private/boost/math/tools/test.hpp"
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 #include <iomanip>
@@ -241,12 +242,54 @@ void test_spots(RealType)
 
    // error tests
    check_out_of_range<boost::math::gamma_distribution<RealType> >(1, 1);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(0, 1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(-1, 1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(1, 0), std::domain_error);
-   BOOST_MATH_CHECK_THROW(boost::math::gamma_distribution<RealType>(1, -1), std::domain_error);
-   BOOST_MATH_CHECK_THROW(quantile(boost::math::gamma_distribution<RealType>(1, 1), 1), std::overflow_error);
+   using boost::math::policies::policy;
 
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{-1, 1}, 
+                                                         {0, 1},
+                                                         {1, -1},
+                                                         {1, 0}};
+   test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                           gamma_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan, 1},
+                        {1, nan}};
+      test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                              gamma_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf, 1},
+                        {1, inf}};
+      test_invalid_parameters<gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                              gamma_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<gamma_distribution<RealType, boost::math::policies::policy<boost::math::policies::overflow_error<boost::math::policies::throw_on_error> > >, 
+                           gamma_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1, 1});
+   }
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )

From 386b99ae30f7140ae756dc85322b719bc740b4ec Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 11:49:32 -0700
Subject: [PATCH 16/30] Added some tests for gamma distribution

---
 include/boost/math/distributions/gamma.hpp |  3 +--
 test/test_gamma_dist.cpp                   | 27 +++++++++++++++++++---
 2 files changed, 25 insertions(+), 5 deletions(-)

diff --git a/include/boost/math/distributions/gamma.hpp b/include/boost/math/distributions/gamma.hpp
index eb42efe914..92c755ade2 100644
--- a/include/boost/math/distributions/gamma.hpp
+++ b/include/boost/math/distributions/gamma.hpp
@@ -202,9 +202,8 @@ BOOST_MATH_GPU_ENABLED inline RealType logpdf(const gamma_distribution<RealType,
 
    if(x == 0)
    {
-      return boost::math::numeric_limits<RealType>::quiet_NaN();
+      return policies::raise_domain_error<RealType>(function, "Random variate is %1% but must be > 0 !", x, Policy());;
    }
-
    result = -k*log(theta) + (k-1)*log(x) - lgamma(k) - (x/theta);
    
    return result;
diff --git a/test/test_gamma_dist.cpp b/test/test_gamma_dist.cpp
index 75d7c06042..83f78cbc15 100644
--- a/test/test_gamma_dist.cpp
+++ b/test/test_gamma_dist.cpp
@@ -238,9 +238,7 @@ void test_spots(RealType)
     BOOST_CHECK_CLOSE(
        entropy(dist), expected_entropy, tol2);
 
-  // Rely on default definition in derived accessors.
-
-   // error tests
+   // Error tests
    check_out_of_range<boost::math::gamma_distribution<RealType> >(1, 1);
    using boost::math::policies::policy;
 
@@ -290,6 +288,29 @@ void test_spots(RealType)
                            gamma_distribution<RealType, ignore_all_policy>, 
                            RealType>({1, 1});
    }
+
+   // Test Special Values
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      BOOST_CHECK((boost::math::isnan)(logpdf(gamma_distribution<RealType, ignore_all_policy>(0.5,1), static_cast<RealType>(0))));
+      BOOST_CHECK((boost::math::isnan)(mean(gamma_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(mean(gamma_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(variance(gamma_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(variance(gamma_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(skewness(gamma_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(skewness(gamma_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(kurtosis_excess(gamma_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(kurtosis_excess(gamma_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(mode(gamma_distribution<RealType, ignore_all_policy>(-1, 1))));
+      BOOST_CHECK((boost::math::isnan)(mode(gamma_distribution<RealType, ignore_all_policy>(1, -1))));
+      BOOST_CHECK((boost::math::isnan)(mode(gamma_distribution<RealType, ignore_all_policy>(0.5, 1))));
+   }
+   BOOST_CHECK_EQUAL(pdf(gamma_distribution<RealType>(2, 1), 0), 0);
+   BOOST_CHECK_THROW(logpdf(gamma_distribution<RealType>(2, 1), static_cast<RealType>(0)), std::domain_error);
+   BOOST_CHECK_EQUAL(cdf(gamma_distribution<RealType>(2, 1), 0), 0);
+   BOOST_CHECK_EQUAL(cdf(complement(gamma_distribution<RealType>(2, 1), 0)), 1);
+
+   // More errors in moments
+
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )

From 937e9be072816280d1a30795d8c79409956ba4a8 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 12:51:23 -0700
Subject: [PATCH 17/30] Added inverse gamma dist

---
 test/test_inverse_gamma_distribution.cpp | 153 ++++++++---------------
 1 file changed, 50 insertions(+), 103 deletions(-)

diff --git a/test/test_inverse_gamma_distribution.cpp b/test/test_inverse_gamma_distribution.cpp
index 4115e1e0c1..daaa12cfaf 100644
--- a/test/test_inverse_gamma_distribution.cpp
+++ b/test/test_inverse_gamma_distribution.cpp
@@ -30,6 +30,7 @@ using ::boost::math::concepts::real_concept;
 #include <boost/test/unit_test.hpp> // for test_main
 #include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE_FRACTION
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <boost/math/distributions/inverse_gamma.hpp> // for inverse_gamma_distribution
 using boost::math::inverse_gamma_distribution;
@@ -149,48 +150,7 @@ void test_spots(RealType)
   tolerance  // tol
   );
 
-  // Check some bad parameters to the distribution,
-#ifndef BOOST_NO_EXCEPTIONS
-  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad1(-1, 0), std::domain_error); // negative shape.
-  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad2(0, -1), std::domain_error); // negative scale.
-  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad2(-1, -1), std::domain_error); // negative scale and shape.
-#else
-  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-1, 0), std::domain_error); // negative shape.
-  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(0, -1), std::domain_error); // negative scale.
-  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-1, -1), std::domain_error); // negative scale and shape.
-#endif
-
-  inverse_gamma_distribution<RealType> ig21(2, 1);
-
-  if(std::numeric_limits<RealType>::has_infinity)
-  {
-    BOOST_MATH_CHECK_THROW(pdf(ig21, +std::numeric_limits<RealType>::infinity()), std::domain_error); // x = + infinity, pdf = 0
-    BOOST_MATH_CHECK_THROW(pdf(ig21, -std::numeric_limits<RealType>::infinity()),  std::domain_error); // x = - infinity, pdf = 0
-    BOOST_MATH_CHECK_THROW(cdf(ig21, +std::numeric_limits<RealType>::infinity()),std::domain_error ); // x = + infinity, cdf = 1
-    BOOST_MATH_CHECK_THROW(cdf(ig21, -std::numeric_limits<RealType>::infinity()), std::domain_error); // x = - infinity, cdf = 0
-    BOOST_MATH_CHECK_THROW(cdf(complement(ig21, +std::numeric_limits<RealType>::infinity())), std::domain_error); // x = + infinity, c cdf = 0
-    BOOST_MATH_CHECK_THROW(cdf(complement(ig21, -std::numeric_limits<RealType>::infinity())), std::domain_error); // x = - infinity, c cdf = 1
-#ifndef BOOST_NO_EXCEPTIONS
-    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // +infinite mean
-    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(-std::numeric_limits<RealType>::infinity(),  static_cast<RealType>(1)), std::domain_error); // -infinite mean
-    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(static_cast<RealType>(0), std::numeric_limits<RealType>::infinity()), std::domain_error); // infinite sd
-#else
-    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // +infinite mean
-    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-std::numeric_limits<RealType>::infinity(),  static_cast<RealType>(1)), std::domain_error); // -infinite mean
-    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(static_cast<RealType>(0), std::numeric_limits<RealType>::infinity()), std::domain_error); // infinite sd
-#endif
-  }
-
-  if (std::numeric_limits<RealType>::has_quiet_NaN)
-  {
-    // No longer allow x to be NaN, then these tests should throw.
-    BOOST_MATH_CHECK_THROW(pdf(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
-    BOOST_MATH_CHECK_THROW(cdf(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
-    BOOST_MATH_CHECK_THROW(cdf(complement(ig21, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // x = + infinity
-    BOOST_MATH_CHECK_THROW(quantile(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // p = + infinity
-    BOOST_MATH_CHECK_THROW(quantile(complement(ig21, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // p = + infinity
-  }
-    // Spot check for pdf using 'naive pdf' function
+  // Spot check for pdf using 'naive pdf' function
   for(RealType x = 0.5; x < 5; x += 0.5)
   {
     BOOST_CHECK_CLOSE_FRACTION(
@@ -287,68 +247,55 @@ void test_spots(RealType)
   BOOST_CHECK_EQUAL(
     cdf(complement(inverse_gamma_distribution<RealType>(3), static_cast<RealType>(0)))
     , static_cast<RealType>(1));
-
-  BOOST_MATH_CHECK_THROW(
-    pdf(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)), // shape negative.
-    static_cast<RealType>(1)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    pdf(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(-1)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    cdf(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
-    static_cast<RealType>(1)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    cdf(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(-1)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    cdf(complement(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
-    static_cast<RealType>(1))), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    cdf(complement(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(-1))), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    quantile(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
-    static_cast<RealType>(0.5)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    quantile(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(-1)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    quantile(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(1.1)), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    quantile(complement(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
-    static_cast<RealType>(0.5))), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    quantile(complement(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(-1))), std::domain_error
-    );
-  BOOST_MATH_CHECK_THROW(
-    quantile(complement(
-    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
-    static_cast<RealType>(1.1))), std::domain_error
-    );
+    
    check_out_of_range<inverse_gamma_distribution<RealType> >(1, 1);
+   
+   // Check errors
+   using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{-1, 0}, 
+                                                         {0, -1},
+                                                         {-1, -1}};
+   test_invalid_parameters<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                           inverse_gamma_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan}};
+      test_invalid_parameters<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                              inverse_gamma_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf}};
+      test_invalid_parameters<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                              inverse_gamma_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
+                           inverse_gamma_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1, 1});
+   }
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )

From ca0f6db214eb9ba48daa32d2ddbafa29f4925168 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 13:23:05 -0700
Subject: [PATCH 18/30] Reverted some of the tests

---
 test/test_inverse_gamma_distribution.cpp | 58 +++++++++++++++++++++---
 1 file changed, 51 insertions(+), 7 deletions(-)

diff --git a/test/test_inverse_gamma_distribution.cpp b/test/test_inverse_gamma_distribution.cpp
index daaa12cfaf..76d645e7d6 100644
--- a/test/test_inverse_gamma_distribution.cpp
+++ b/test/test_inverse_gamma_distribution.cpp
@@ -150,7 +150,48 @@ void test_spots(RealType)
   tolerance  // tol
   );
 
-  // Spot check for pdf using 'naive pdf' function
+  // Check some bad parameters to the distribution,
+#ifndef BOOST_NO_EXCEPTIONS
+  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad1(-1, 0), std::domain_error); // negative shape.
+  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad2(0, -1), std::domain_error); // negative scale.
+  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> igbad2(-1, -1), std::domain_error); // negative scale and shape.
+#else
+  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-1, 0), std::domain_error); // negative shape.
+  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(0, -1), std::domain_error); // negative scale.
+  BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-1, -1), std::domain_error); // negative scale and shape.
+#endif
+
+  inverse_gamma_distribution<RealType> ig21(2, 1);
+
+  if(std::numeric_limits<RealType>::has_infinity)
+  {
+    BOOST_MATH_CHECK_THROW(pdf(ig21, +std::numeric_limits<RealType>::infinity()), std::domain_error); // x = + infinity, pdf = 0
+    BOOST_MATH_CHECK_THROW(pdf(ig21, -std::numeric_limits<RealType>::infinity()),  std::domain_error); // x = - infinity, pdf = 0
+    BOOST_MATH_CHECK_THROW(cdf(ig21, +std::numeric_limits<RealType>::infinity()),std::domain_error ); // x = + infinity, cdf = 1
+    BOOST_MATH_CHECK_THROW(cdf(ig21, -std::numeric_limits<RealType>::infinity()), std::domain_error); // x = - infinity, cdf = 0
+    BOOST_MATH_CHECK_THROW(cdf(complement(ig21, +std::numeric_limits<RealType>::infinity())), std::domain_error); // x = + infinity, c cdf = 0
+    BOOST_MATH_CHECK_THROW(cdf(complement(ig21, -std::numeric_limits<RealType>::infinity())), std::domain_error); // x = - infinity, c cdf = 1
+#ifndef BOOST_NO_EXCEPTIONS
+    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // +infinite mean
+    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(-std::numeric_limits<RealType>::infinity(),  static_cast<RealType>(1)), std::domain_error); // -infinite mean
+    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType> nbad1(static_cast<RealType>(0), std::numeric_limits<RealType>::infinity()), std::domain_error); // infinite sd
+#else
+    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(std::numeric_limits<RealType>::infinity(), static_cast<RealType>(1)), std::domain_error); // +infinite mean
+    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(-std::numeric_limits<RealType>::infinity(),  static_cast<RealType>(1)), std::domain_error); // -infinite mean
+    BOOST_MATH_CHECK_THROW(boost::math::inverse_gamma_distribution<RealType>(static_cast<RealType>(0), std::numeric_limits<RealType>::infinity()), std::domain_error); // infinite sd
+#endif
+  }
+
+  if (std::numeric_limits<RealType>::has_quiet_NaN)
+  {
+    // No longer allow x to be NaN, then these tests should throw.
+    BOOST_MATH_CHECK_THROW(pdf(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
+    BOOST_MATH_CHECK_THROW(cdf(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // x = NaN
+    BOOST_MATH_CHECK_THROW(cdf(complement(ig21, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // x = + infinity
+    BOOST_MATH_CHECK_THROW(quantile(ig21, +std::numeric_limits<RealType>::quiet_NaN()), std::domain_error); // p = + infinity
+    BOOST_MATH_CHECK_THROW(quantile(complement(ig21, +std::numeric_limits<RealType>::quiet_NaN())), std::domain_error); // p = + infinity
+  }
+    // Spot check for pdf using 'naive pdf' function
   for(RealType x = 0.5; x < 5; x += 0.5)
   {
     BOOST_CHECK_CLOSE_FRACTION(
@@ -247,10 +288,9 @@ void test_spots(RealType)
   BOOST_CHECK_EQUAL(
     cdf(complement(inverse_gamma_distribution<RealType>(3), static_cast<RealType>(0)))
     , static_cast<RealType>(1));
-    
+
    check_out_of_range<inverse_gamma_distribution<RealType> >(1, 1);
    
-   // Check errors
    using boost::math::policies::policy;
 
    typedef policy<
@@ -262,8 +302,8 @@ void test_spots(RealType)
       boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
    > ignore_all_policy;
 
-   std::vector<std::vector<RealType> > invalid_params = {{-1, 0}, 
-                                                         {0, -1},
+   std::vector<std::vector<RealType> > invalid_params = {{-1, 1}, 
+                                                         {1, -1},
                                                          {-1, -1}};
    test_invalid_parameters<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
                            inverse_gamma_distribution<RealType, ignore_all_policy>, 
@@ -273,7 +313,9 @@ void test_spots(RealType)
    if (std::numeric_limits<RealType>::has_quiet_NaN){
       // Attempt to construct from non-finite parameters should throw.
       RealType nan = std::numeric_limits<RealType>::quiet_NaN();
-      invalid_params = {{nan}};
+      invalid_params = {{nan, 1},
+                        {1, nan},
+                        {nan, nan}};
       test_invalid_parameters<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
                               inverse_gamma_distribution<RealType, ignore_all_policy>, 
                               RealType>(invalid_params);
@@ -284,7 +326,9 @@ void test_spots(RealType)
    {
       // Attempt to construct from non-finite should throw.
       RealType inf = std::numeric_limits<RealType>::infinity();
-      invalid_params = {{inf}};
+      invalid_params = {{inf, 1},
+                        {1, inf},
+                        {inf, inf}};
       test_invalid_parameters<inverse_gamma_distribution<RealType, boost::math::policies::policy<> >, 
                               inverse_gamma_distribution<RealType, ignore_all_policy>, 
                               RealType>(invalid_params);

From 1ba4ab3eae2aeb928df853c26573a3d36c933686 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 13:36:55 -0700
Subject: [PATCH 19/30] Reverted more inverse gamma tests

---
 test/test_inverse_gamma_distribution.cpp | 61 +++++++++++++++++++++++-
 1 file changed, 60 insertions(+), 1 deletion(-)

diff --git a/test/test_inverse_gamma_distribution.cpp b/test/test_inverse_gamma_distribution.cpp
index 76d645e7d6..2cfc62284f 100644
--- a/test/test_inverse_gamma_distribution.cpp
+++ b/test/test_inverse_gamma_distribution.cpp
@@ -288,7 +288,66 @@ void test_spots(RealType)
   BOOST_CHECK_EQUAL(
     cdf(complement(inverse_gamma_distribution<RealType>(3), static_cast<RealType>(0)))
     , static_cast<RealType>(1));
-
+  BOOST_MATH_CHECK_THROW(
+    pdf(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)), // shape negative.
+    static_cast<RealType>(1)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    pdf(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(-1)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    cdf(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
+    static_cast<RealType>(1)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    cdf(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(-1)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    cdf(complement(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
+    static_cast<RealType>(1))), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    cdf(complement(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(-1))), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    quantile(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
+    static_cast<RealType>(0.5)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    quantile(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(-1)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    quantile(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(1.1)), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    quantile(complement(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(-1)),
+    static_cast<RealType>(0.5))), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    quantile(complement(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(-1))), std::domain_error
+    );
+  BOOST_MATH_CHECK_THROW(
+    quantile(complement(
+    inverse_gamma_distribution<RealType>(static_cast<RealType>(8)),
+    static_cast<RealType>(1.1))), std::domain_error
+    ); 
    check_out_of_range<inverse_gamma_distribution<RealType> >(1, 1);
    
    using boost::math::policies::policy;

From 6e0b6b57415f7ac3cf3d90665acd792e71a84d10 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 13:42:39 -0700
Subject: [PATCH 20/30] Added inverse gaussian tests

---
 test/test_inverse_gaussian.cpp | 51 ++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/test/test_inverse_gaussian.cpp b/test/test_inverse_gaussian.cpp
index 0fe64223dc..0fc125154d 100644
--- a/test/test_inverse_gaussian.cpp
+++ b/test/test_inverse_gaussian.cpp
@@ -32,6 +32,7 @@ using boost::math::inverse_gaussian_distribution;
 using boost::math::inverse_gaussian;
 
 #include "test_out_of_range.hpp"
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
 #include <iomanip>
@@ -173,6 +174,56 @@ void test_spots(RealType)
     static_cast<RealType>(10-3), tolerance);
   BOOST_CHECK_CLOSE_FRACTION(kurtosis_excess(dist),
     static_cast<RealType>(10), tolerance);
+  
+  // Check errors
+  using boost::math::policies::policy;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{0, -1}};
+   test_invalid_parameters<inverse_gaussian_distribution<RealType, boost::math::policies::policy<> >, 
+                           inverse_gaussian_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan, 1},
+                        {1, nan},
+                        {nan, nan}};
+      test_invalid_parameters<inverse_gaussian_distribution<RealType, boost::math::policies::policy<> >, 
+                              inverse_gaussian_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf, 1},
+                        {1, inf},
+                        {1, -inf},
+                        {inf, inf}};
+      test_invalid_parameters<inverse_gaussian_distribution<RealType, boost::math::policies::policy<> >, 
+                              inverse_gaussian_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<inverse_gaussian_distribution<RealType, boost::math::policies::policy<> >, 
+                           inverse_gaussian_distribution<RealType, ignore_all_policy>, 
+                           RealType>({1, 1});
+   }
 } // template <class RealType>void test_spots(RealType)
 
 BOOST_AUTO_TEST_CASE( test_main )

From ebdfc0fb82b0c4239d054c5bb5b5179eb736f4fe Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 15:53:48 -0700
Subject: [PATCH 21/30] Added more geometric dist tests

---
 .../boost/math/distributions/geometric.hpp    | 20 ++++++--------
 test/test_geometric.cpp                       | 26 +++++++++++++++++--
 2 files changed, 32 insertions(+), 14 deletions(-)

diff --git a/include/boost/math/distributions/geometric.hpp b/include/boost/math/distributions/geometric.hpp
index 22f70a4dbd..3f038f6a64 100644
--- a/include/boost/math/distributions/geometric.hpp
+++ b/include/boost/math/distributions/geometric.hpp
@@ -145,9 +145,9 @@ namespace boost
         RealType result = 0;  // of error checks.
         RealType successes = 1;
         RealType failures = trials - successes;
-        if(false == detail::check_probability(function, alpha, &result, Policy())
+        if(false == (detail::check_probability(function, alpha, &result, Policy())
           && geometric_detail::check_dist_and_k(
-          function, RealType(0), failures, &result, Policy()))
+          function, RealType(0), failures, &result, Policy())))
         {
           return result;
         }
@@ -170,9 +170,9 @@ namespace boost
         RealType result = 0;  // of error checks.
         RealType successes = 1;
         RealType failures = trials - successes;
-        if(false == geometric_detail::check_dist_and_k(
+        if(false == (geometric_detail::check_dist_and_k(
           function, RealType(0), failures, &result, Policy())
-          && detail::check_probability(function, alpha, &result, Policy()))
+          && detail::check_probability(function, alpha, &result, Policy())))
         {
           return result;
         }
@@ -202,9 +202,9 @@ namespace boost
         constexpr auto function = "boost::math::geometric<%1%>::find_minimum_number_of_trials";
         // Error checks:
         RealType result = 0;
-        if(false == geometric_detail::check_dist_and_k(
+        if(false == (geometric_detail::check_dist_and_k(
           function, p, k, &result, Policy())
-          && detail::check_probability(function, alpha, &result, Policy()))
+          && detail::check_probability(function, alpha, &result, Policy())))
         {
           return result;
         }
@@ -220,9 +220,9 @@ namespace boost
         constexpr auto function = "boost::math::geometric<%1%>::find_maximum_number_of_trials";
         // Error checks:
         RealType result = 0;
-        if(false == geometric_detail::check_dist_and_k(
+        if(false == (geometric_detail::check_dist_and_k(
           function, p, k, &result, Policy())
-          &&  detail::check_probability(function, alpha, &result, Policy()))
+          &&  detail::check_probability(function, alpha, &result, Policy())))
         {
           return result;
         }
@@ -497,10 +497,6 @@ namespace boost
       { // p <= pdf(dist, 0) == cdf(dist, 0)
         return 0;
       }
-      if (x == 1)
-      {
-        return 0;
-      }
 
       // log(1-x) /log(1-success_fraction) -1; but use log1p in case success_fraction is small
       result = boost::math::log1p(-x, Policy()) / boost::math::log1p(-success_fraction, Policy()) - 1;
diff --git a/test/test_geometric.cpp b/test/test_geometric.cpp
index d83378260a..b48d171c18 100644
--- a/test/test_geometric.cpp
+++ b/test/test_geometric.cpp
@@ -843,8 +843,30 @@ if(std::numeric_limits<RealType>::is_specialized)
       test_invalid_support<geometric_distribution<RealType, boost::math::policies::policy<> >, 
                            geometric_distribution<RealType, ignore_all_policy>, 
                            RealType>({0.5});
-  }
-    //geometric::find_upper_bound_on_p(k, alpha);
+      // Check incorrect constructors for find_lower_bound_on_p
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_lower_bound_on_p(8, -0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_lower_bound_on_p(8, 1.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_lower_bound_on_p(0, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_lower_bound_on_p(-1, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_upper_bound_on_p(8, -0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_upper_bound_on_p(8, 1.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_upper_bound_on_p(0, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_upper_bound_on_p(-1, 0.25)));
+
+      // Incorrect constructors for find_minimum_number_of_trials
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_minimum_number_of_trials(1, 0.25, -0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_minimum_number_of_trials(1, 0.25, 1.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_minimum_number_of_trials(1, -0.25, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_minimum_number_of_trials(1, 1.25, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_minimum_number_of_trials(-1, 0.25, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_maximum_number_of_trials(1, 0.25, -0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_maximum_number_of_trials(1, 0.25, 1.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_maximum_number_of_trials(1, -0.25, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_maximum_number_of_trials(1, 1.25, 0.25)));
+      BOOST_CHECK((boost::math::isnan)(geometric_distribution<RealType, ignore_all_policy>::find_maximum_number_of_trials(-1, 0.25, 0.25)));
+    }
+
+  //geometric::find_upper_bound_on_p(k, alpha);
   return;
 } // template <class RealType> void test_spots(RealType) // Any floating-point type RealType.
 

From d54ccadb5ed5795cc305b0e6698b862d985feb93 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 16:22:52 -0700
Subject: [PATCH 22/30] Added hyperexponential tests

---
 test/test_hyperexponential_dist.cpp | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/test_hyperexponential_dist.cpp b/test/test_hyperexponential_dist.cpp
index c7d3c9843b..a4fc5509ed 100644
--- a/test/test_hyperexponential_dist.cpp
+++ b/test/test_hyperexponential_dist.cpp
@@ -398,6 +398,26 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(error_cases, RealT, test_types)
    BOOST_MATH_CHECK_THROW(dist_t(probs.begin(), probs.begin(), rates.begin(), rates.begin()), std::domain_error);
    BOOST_MATH_CHECK_THROW(dist_t(rates.begin(), rates.begin()), std::domain_error);
 
+   typedef boost::math::policies::policy<
+        boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+        boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+        boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+        boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+        boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+        boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   if (std::numeric_limits<RealT>::has_quiet_NaN)
+   {
+        typedef boost::math::hyperexponential_distribution<RealT, ignore_all_policy> ignore_all_hyperexp;
+        BOOST_CHECK((boost::math::isnan)(boost::math::pdf(ignore_all_hyperexp({ 0.25, 0.5, 0.25 }, { -0.5, 1.0, 1.5 }), 1)));
+        BOOST_CHECK((boost::math::isnan)(boost::math::pdf(ignore_all_hyperexp({ 0.25, 0.5, 0.25 }, { 0.5, 1.0, 1.5 }), -1)));
+        BOOST_CHECK((boost::math::isnan)(boost::math::cdf(ignore_all_hyperexp({ 0.25, 0.5, 0.25 }, { 0.5, 1.0, 1.5 }), -1)));
+        BOOST_CHECK((boost::math::isnan)(boost::math::cdf(complement(ignore_all_hyperexp({ 0.25, 0.5, 0.25 }, { 0.5, 1.0, 1.5 }), -1))));
+        BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_all_hyperexp({ 0.25, 0.5, 0.25 }, { 1.0, 1.5 }), -0.25)));
+        BOOST_CHECK((boost::math::isnan)(boost::math::quantile(ignore_all_hyperexp({ 0.25, 0.5, 0.25 }, { 1.0, 1.5 }), 1.25)));
+    }
+
    // Test C++20 ranges (Currently only GCC10 has full support to P0896R4)
    #if (__cplusplus > 202000L || _MSVC_LANG > 202000L) && __has_include(<ranges>) && __GNUC__ >= 10
    // Support for ranges is broken using gcc 11.1

From adf9ee43af7009e1142a150c0eb23be478067d75 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 18:04:27 -0700
Subject: [PATCH 23/30] Added hypergeometric tests

---
 test/test_hypergeometric_dist.cpp | 52 +++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/test/test_hypergeometric_dist.cpp b/test/test_hypergeometric_dist.cpp
index 961e5394a6..e1f11336e3 100644
--- a/test/test_hypergeometric_dist.cpp
+++ b/test/test_hypergeometric_dist.cpp
@@ -16,6 +16,7 @@
 #include <boost/test/results_collector.hpp>
 #include <boost/test/unit_test.hpp>
 #include <boost/test/tools/floating_point_comparison.hpp>
+#include "test_dist_helpers.hpp"
 
 #include <iostream>
    using std::cout;
@@ -491,6 +492,57 @@ void test_spots(RealType /*T*/, const char* type_name)
 
    BOOST_MATH_CHECK_THROW(d = boost::math::hypergeometric_distribution<RealType>(501, 40, 500), std::domain_error);
    BOOST_MATH_CHECK_THROW(d = boost::math::hypergeometric_distribution<RealType>(40, 501, 500), std::domain_error);
+
+   using boost::math::policies::policy;
+   using boost::math::hypergeometric_distribution;
+
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::ignore_error>,
+      boost::math::policies::overflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::underflow_error<boost::math::policies::ignore_error>,
+      boost::math::policies::denorm_error<boost::math::policies::ignore_error>,
+      boost::math::policies::pole_error<boost::math::policies::ignore_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
+   > ignore_all_policy;
+
+   std::vector<std::vector<RealType> > invalid_params = {{51, 40, 50}, 
+                                                         {40, 51, 50},
+                                                         {-1, 40, 50}};
+   test_invalid_parameters<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
+                           hypergeometric_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+
+   // Check constructing with NaNs
+   if (std::numeric_limits<RealType>::has_quiet_NaN){
+      // Attempt to construct from non-finite parameters should throw.
+      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
+      invalid_params = {{nan, 5, 5},
+                        {5, nan, 5},
+                        {5, 5, nan}};
+      test_invalid_parameters<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
+                              hypergeometric_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+   }
+
+   // Check construcing with Infinity
+   if (std::numeric_limits<RealType>::has_infinity)
+   {
+      // Attempt to construct from non-finite should throw.
+      RealType inf = std::numeric_limits<RealType>::infinity();
+      invalid_params = {{inf, 5, 5},
+                        {5, inf, 5},
+                        {5, 5, inf}};
+      test_invalid_parameters<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
+                              hypergeometric_distribution<RealType, ignore_all_policy>, 
+                              RealType>(invalid_params);
+
+   } // has_infinity 
+   if (std::numeric_limits<RealType>::has_quiet_NaN)
+   {
+      test_invalid_support<hypergeometric_distribution<RealType, boost::math::policies::policy<boost::math::policies::overflow_error<boost::math::policies::throw_on_error> > >, 
+                           hypergeometric_distribution<RealType, ignore_all_policy>, 
+                           RealType>({50, 30, 500});
+   }
 }
 
 

From 16674ab947d27443cecea8942f28bfd14fd20c93 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Mon, 1 Jun 2026 18:05:39 -0700
Subject: [PATCH 24/30] test_hypergeometric_dist.cpp

---
 test/test_hypergeometric_dist.cpp | 29 ++---------------------------
 1 file changed, 2 insertions(+), 27 deletions(-)

diff --git a/test/test_hypergeometric_dist.cpp b/test/test_hypergeometric_dist.cpp
index e1f11336e3..663ef8ea10 100644
--- a/test/test_hypergeometric_dist.cpp
+++ b/test/test_hypergeometric_dist.cpp
@@ -512,36 +512,11 @@ void test_spots(RealType /*T*/, const char* type_name)
                            hypergeometric_distribution<RealType, ignore_all_policy>, 
                            RealType>(invalid_params);
 
-   // Check constructing with NaNs
-   if (std::numeric_limits<RealType>::has_quiet_NaN){
-      // Attempt to construct from non-finite parameters should throw.
-      RealType nan = std::numeric_limits<RealType>::quiet_NaN();
-      invalid_params = {{nan, 5, 5},
-                        {5, nan, 5},
-                        {5, 5, nan}};
-      test_invalid_parameters<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
-                              hypergeometric_distribution<RealType, ignore_all_policy>, 
-                              RealType>(invalid_params);
-   }
-
-   // Check construcing with Infinity
-   if (std::numeric_limits<RealType>::has_infinity)
-   {
-      // Attempt to construct from non-finite should throw.
-      RealType inf = std::numeric_limits<RealType>::infinity();
-      invalid_params = {{inf, 5, 5},
-                        {5, inf, 5},
-                        {5, 5, inf}};
-      test_invalid_parameters<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
-                              hypergeometric_distribution<RealType, ignore_all_policy>, 
-                              RealType>(invalid_params);
-
-   } // has_infinity 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<hypergeometric_distribution<RealType, boost::math::policies::policy<boost::math::policies::overflow_error<boost::math::policies::throw_on_error> > >, 
+      test_invalid_support<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
                            hypergeometric_distribution<RealType, ignore_all_policy>, 
-                           RealType>({50, 30, 500});
+                           RealType>({4, 13, 26});
    }
 }
 

From 36b17357ad7f0ff090eb4a7b8ffb6086729ecca5 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 13 Jun 2026 11:20:14 -0700
Subject: [PATCH 25/30] Fixed c++14 is_constructible_v

---
 test/test_dist_helpers.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index bc69154b6c..44cb2b14f2 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -14,17 +14,17 @@ template <class Dist, class Container>
 Dist make_distribution(const Container& c)
 {
     using value_type = typename Dist::value_type;
-    if constexpr (std::is_constructible_v<Dist, value_type, value_type, value_type>)
+    if constexpr (std::is_constructible<Dist, value_type, value_type, value_type>::value)
     {
         if (c.size() >= 3)
             return Dist(c.data()[0], c.data()[1], c.data()[2]);
     }
-    if constexpr (std::is_constructible_v<Dist, value_type, value_type>)
+    if constexpr (std::is_constructible<Dist, value_type, value_type>::value)
     {
         if (c.size() >= 2)
             return Dist(c.data()[0], c.data()[1]);
     }
-    if constexpr (std::is_constructible_v<Dist, value_type>)
+    if constexpr (std::is_constructible<Dist, value_type>::value)
     {
         if (c.size() >= 1)
             return Dist(c.data()[0]);

From 6c0633328460453096ed554e5f2af5dac993dbbc Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 13 Jun 2026 14:04:10 -0700
Subject: [PATCH 26/30] Macos fix

---
 test/test_hypergeometric_dist.cpp | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/test/test_hypergeometric_dist.cpp b/test/test_hypergeometric_dist.cpp
index 663ef8ea10..dee2110d5a 100644
--- a/test/test_hypergeometric_dist.cpp
+++ b/test/test_hypergeometric_dist.cpp
@@ -505,16 +505,25 @@ void test_spots(RealType /*T*/, const char* type_name)
       boost::math::policies::evaluation_error<boost::math::policies::ignore_error>
    > ignore_all_policy;
 
+   typedef policy<
+      boost::math::policies::domain_error<boost::math::policies::throw_on_error>,
+      boost::math::policies::overflow_error<boost::math::policies::throw_on_error>,
+      boost::math::policies::underflow_error<boost::math::policies::throw_on_error>,
+      boost::math::policies::denorm_error<boost::math::policies::throw_on_error>,
+      boost::math::policies::pole_error<boost::math::policies::throw_on_error>,
+      boost::math::policies::evaluation_error<boost::math::policies::throw_on_error>
+   > throw_all_policy;
+
    std::vector<std::vector<RealType> > invalid_params = {{51, 40, 50}, 
                                                          {40, 51, 50},
                                                          {-1, 40, 50}};
-   test_invalid_parameters<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
+   test_invalid_parameters<hypergeometric_distribution<RealType, throw_all_policy>, 
                            hypergeometric_distribution<RealType, ignore_all_policy>, 
                            RealType>(invalid_params);
 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
-      test_invalid_support<hypergeometric_distribution<RealType, boost::math::policies::policy<> >, 
+      test_invalid_support<hypergeometric_distribution<RealType, throw_all_policy>, 
                            hypergeometric_distribution<RealType, ignore_all_policy>, 
                            RealType>({4, 13, 26});
    }

From b3acc195fc1d116a8ab506ea7d33546ce85e1926 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 13 Jun 2026 14:22:37 -0700
Subject: [PATCH 27/30] Added macos debugging info

---
 test/test_dist_helpers.hpp        | 1 +
 test/test_hypergeometric_dist.cpp | 6 +++---
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 44cb2b14f2..dd3a624838 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -163,6 +163,7 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
     {
         params = invalid_parameters[i];
         // Check functions throw with bad constructors
+        std::cout << params[0] << ", " << params[1] << ", " << params[2] << std::endl;
         BOOST_CHECK_THROW(make_distribution<Dist>(params), std::domain_error);
         BOOST_CHECK_THROW(pdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
         BOOST_CHECK_THROW(logpdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
diff --git a/test/test_hypergeometric_dist.cpp b/test/test_hypergeometric_dist.cpp
index dee2110d5a..9457ebeae8 100644
--- a/test/test_hypergeometric_dist.cpp
+++ b/test/test_hypergeometric_dist.cpp
@@ -514,9 +514,9 @@ void test_spots(RealType /*T*/, const char* type_name)
       boost::math::policies::evaluation_error<boost::math::policies::throw_on_error>
    > throw_all_policy;
 
-   std::vector<std::vector<RealType> > invalid_params = {{51, 40, 50}, 
-                                                         {40, 51, 50},
-                                                         {-1, 40, 50}};
+   std::vector<std::vector<RealType> > invalid_params = {{51., 40., 50.}, 
+                                                         {40., 51., 50.},
+                                                         {-1., 40., 50.}};
    test_invalid_parameters<hypergeometric_distribution<RealType, throw_all_policy>, 
                            hypergeometric_distribution<RealType, ignore_all_policy>, 
                            RealType>(invalid_params);

From 70ee3d751659ed5eebc13ec9f21f03f031238b27 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 13 Jun 2026 14:59:07 -0700
Subject: [PATCH 28/30] Another macos fix?

---
 test/test_hypergeometric_dist.cpp | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/test_hypergeometric_dist.cpp b/test/test_hypergeometric_dist.cpp
index 9457ebeae8..6603bb58b1 100644
--- a/test/test_hypergeometric_dist.cpp
+++ b/test/test_hypergeometric_dist.cpp
@@ -517,12 +517,13 @@ void test_spots(RealType /*T*/, const char* type_name)
    std::vector<std::vector<RealType> > invalid_params = {{51., 40., 50.}, 
                                                          {40., 51., 50.},
                                                          {-1., 40., 50.}};
-   test_invalid_parameters<hypergeometric_distribution<RealType, throw_all_policy>, 
-                           hypergeometric_distribution<RealType, ignore_all_policy>, 
-                           RealType>(invalid_params);
 
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
+      test_invalid_parameters<hypergeometric_distribution<RealType, throw_all_policy>, 
+                           hypergeometric_distribution<RealType, ignore_all_policy>, 
+                           RealType>(invalid_params);
+                           
       test_invalid_support<hypergeometric_distribution<RealType, throw_all_policy>, 
                            hypergeometric_distribution<RealType, ignore_all_policy>, 
                            RealType>({4, 13, 26});

From a56f797b972c84a2e876a40994e5a6080afb1903 Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 13 Jun 2026 15:23:49 -0700
Subject: [PATCH 29/30] Added try catch for debugging

---
 test/test_dist_helpers.hpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index dd3a624838..4e4d59fd19 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -164,6 +164,13 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
         params = invalid_parameters[i];
         // Check functions throw with bad constructors
         std::cout << params[0] << ", " << params[1] << ", " << params[2] << std::endl;
+        try 
+        { 
+            std::cout << pdf(make_distribution<Dist>(params), static_cast<Real>(0)) << std::endl;
+        }
+        catch(const std::exception &exc){
+            std::cerr << exc.what() << std::endl;
+        }
         BOOST_CHECK_THROW(make_distribution<Dist>(params), std::domain_error);
         BOOST_CHECK_THROW(pdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
         BOOST_CHECK_THROW(logpdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);

From 2ef063f26615ce6ff767042e0ae6ddbad298180b Mon Sep 17 00:00:00 2001
From: Jacob Hass <jacobhass8@gmail.com>
Date: Sat, 13 Jun 2026 19:12:33 -0700
Subject: [PATCH 30/30] Deleted failing hypergeometric test; input -1 coerced
 to uint

---
 test/test_dist_helpers.hpp        | 8 --------
 test/test_hypergeometric_dist.cpp | 4 +---
 2 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/test/test_dist_helpers.hpp b/test/test_dist_helpers.hpp
index 4e4d59fd19..44cb2b14f2 100644
--- a/test/test_dist_helpers.hpp
+++ b/test/test_dist_helpers.hpp
@@ -163,14 +163,6 @@ void test_invalid_parameters(std::vector<std::vector<Real> > invalid_parameters)
     {
         params = invalid_parameters[i];
         // Check functions throw with bad constructors
-        std::cout << params[0] << ", " << params[1] << ", " << params[2] << std::endl;
-        try 
-        { 
-            std::cout << pdf(make_distribution<Dist>(params), static_cast<Real>(0)) << std::endl;
-        }
-        catch(const std::exception &exc){
-            std::cerr << exc.what() << std::endl;
-        }
         BOOST_CHECK_THROW(make_distribution<Dist>(params), std::domain_error);
         BOOST_CHECK_THROW(pdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
         BOOST_CHECK_THROW(logpdf(make_distribution<Dist>(params), static_cast<Real>(0)), std::domain_error);
diff --git a/test/test_hypergeometric_dist.cpp b/test/test_hypergeometric_dist.cpp
index 6603bb58b1..30339e24fe 100644
--- a/test/test_hypergeometric_dist.cpp
+++ b/test/test_hypergeometric_dist.cpp
@@ -515,9 +515,7 @@ void test_spots(RealType /*T*/, const char* type_name)
    > throw_all_policy;
 
    std::vector<std::vector<RealType> > invalid_params = {{51., 40., 50.}, 
-                                                         {40., 51., 50.},
-                                                         {-1., 40., 50.}};
-
+                                                         {40., 51., 50.}};
    if (std::numeric_limits<RealType>::has_quiet_NaN)
    {
       test_invalid_parameters<hypergeometric_distribution<RealType, throw_all_policy>,