New Distribution Testing Infastructure

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)

include/boost/math/distributions/detail/common_error_handling.hpp

@@ -217,6 +217,70 @@ BOOST_MATH_GPU_ENABLED inline bool check_finite(
    return true;
 }
 
+template <class RealType, class Policy>
+BOOST_MATH_GPU_ENABLED inline bool check_inverse_gamma_shape(
+      const char* function, // inverse_gamma
+      RealType shape, // shape aka alpha
+      RealType* result, // to update, perhaps with NaN
+      const Policy& pol)
+{  // Sources say shape argument must be > 0
+   // but seems logical to allow shape zero as special case,
+   // returning pdf and cdf zero (but not < 0).
+   // (Functions like mean, variance with other limits on shape are checked
+   // in version including an operator & limit below).
+   if((shape < 0) || !(boost::math::isfinite)(shape))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Shape parameter is %1%, but must be >= 0 !", shape, pol);
+      return false;
+   }
+   return true;
+} //bool check_inverse_gamma_shape
+
+template <class RealType, class Policy>
+BOOST_MATH_GPU_ENABLED inline bool check_inverse_gamma_x(
+      const char* function,
+      RealType const& x,
+      RealType* result, const Policy& pol)
+{
+   if((x < 0) || !(boost::math::isfinite)(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_inverse_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_inverse_gamma(
+      const char* function, // TODO swap these over, so shape is first.
+      RealType scale,  // scale aka beta
+      RealType shape, // shape aka alpha
+      RealType* result, const Policy& pol)
+{
+   return check_scale(function, scale, result, pol)
+     && check_inverse_gamma_shape(function, shape, result, pol);
+} // bool check_inverse_gamma
+
 } // namespace detail
 } // namespace math
 } // namespace boost

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>
@@ -128,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
@@ -225,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;
@@ -246,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;

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)
    {

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
@@ -168,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;
@@ -189,8 +222,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 +275,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;