Initial Commit

.svn/pristine/00/00549dac5589acb2f8fd75d4a5db4b01ba121be1.svn-base

@@ -0,0 +1,194 @@
+// Copyright John Maddock 2006, 2007.
+// Copyright Paul A. Bristow 2006, 2007, 2012.
+
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_DISTRIBUTIONS_COMMON_ERROR_HANDLING_HPP
+#define BOOST_MATH_DISTRIBUTIONS_COMMON_ERROR_HANDLING_HPP
+
+#include <boost/math/policies/error_handling.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+// using boost::math::isfinite;
+// using boost::math::isnan;
+
+namespace boost{ namespace math{ namespace detail
+{
+
+template <class RealType, class Policy>
+inline bool check_probability(const char* function, RealType const& prob, RealType* result, const Policy& pol)
+{
+   if((prob < 0) || (prob > 1) || !(boost::math::isfinite)(prob))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Probability argument is %1%, but must be >= 0 and <= 1 !", prob, pol);
+      return false;
+   }
+   return true;
+}
+
+template <class RealType, class Policy>
+inline bool check_df(const char* function, RealType const& df, RealType* result, const Policy& pol)
+{ //  df > 0 but NOT +infinity allowed.
+   if((df <= 0) || !(boost::math::isfinite)(df))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Degrees of freedom argument is %1%, but must be > 0 !", df, pol);
+      return false;
+   }
+   return true;
+}
+
+template <class RealType, class Policy>
+inline bool check_df_gt0_to_inf(const char* function, RealType const& df, RealType* result, const Policy& pol)
+{  // df > 0 or +infinity are allowed.
+   if( (df <= 0) || (boost::math::isnan)(df) )
+   { // is bad df <= 0 or NaN or -infinity.
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Degrees of freedom argument is %1%, but must be > 0 !", df, pol);
+      return false;
+   }
+   return true;
+} // check_df_gt0_to_inf
+
+
+template <class RealType, class Policy>
+inline bool check_scale(
+      const char* function,
+      RealType scale,
+      RealType* result,
+      const Policy& pol)
+{
+   if((scale <= 0) || !(boost::math::isfinite)(scale))
+   { // Assume scale == 0 is NOT valid for any distribution.
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Scale parameter is %1%, but must be > 0 !", scale, pol);
+      return false;
+   }
+   return true;
+}
+
+template <class RealType, class Policy>
+inline bool check_location(
+      const char* function,
+      RealType location,
+      RealType* result,
+      const Policy& pol)
+{
+   if(!(boost::math::isfinite)(location))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Location parameter is %1%, but must be finite!", location, pol);
+      return false;
+   }
+   return true;
+}
+
+template <class RealType, class Policy>
+inline bool check_x(
+      const char* function,
+      RealType x,
+      RealType* result,
+      const Policy& pol)
+{
+   // Note that this test catches both infinity and NaN.
+   // Some distributions permit x to be infinite, so these must be tested 1st and return,
+   // leaving this test to catch any NaNs.
+   // See Normal, Logistic, Laplace and Cauchy for example.
+   if(!(boost::math::isfinite)(x))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Random variate x is %1%, but must be finite!", x, pol);
+      return false;
+   }
+   return true;
+} // bool check_x
+
+template <class RealType, class Policy>
+inline bool check_x_gt0(
+      const char* function,
+      RealType x,
+      RealType* result,
+      const Policy& pol)
+{
+   if(x <= 0)
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Random variate x is %1%, but must be > 0!", x, pol);
+      return false;
+   }
+
+   return true;
+   // Note that this test catches both infinity and NaN.
+   // Some special cases permit x to be infinite, so these must be tested 1st,
+   // leaving this test to catch any NaNs.  See Normal and cauchy for example.
+} // bool check_x_gt0
+
+template <class RealType, class Policy>
+inline bool check_positive_x(
+      const char* function,
+      RealType x,
+      RealType* result,
+      const Policy& pol)
+{
+   if(!(boost::math::isfinite)(x) || (x < 0))
+   {
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Random variate x is %1%, but must be finite and >= 0!", x, pol);
+      return false;
+   }
+   return true;
+   // Note that this test catches both infinity and NaN.
+   // Some special cases permit x to be infinite, so these must be tested 1st,
+   // leaving this test to catch any NaNs.  see Normal and cauchy for example.
+}
+
+template <class RealType, class Policy>
+inline bool check_non_centrality(
+      const char* function,
+      RealType ncp,
+      RealType* result,
+      const Policy& pol)
+{
+   if((ncp < 0) || !(boost::math::isfinite)(ncp))
+   { // Assume scale == 0 is NOT valid for any distribution.
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Non centrality parameter is %1%, but must be > 0 !", ncp, pol);
+      return false;
+   }
+   return true;
+}
+
+template <class RealType, class Policy>
+inline bool check_finite(
+      const char* function,
+      RealType x,
+      RealType* result,
+      const Policy& pol)
+{
+   if(!(boost::math::isfinite)(x))
+   { // Assume scale == 0 is NOT valid for any distribution.
+      *result = policies::raise_domain_error<RealType>(
+         function,
+         "Parameter is %1%, but must be finite !", x, pol);
+      return false;
+   }
+   return true;
+}
+
+} // namespace detail
+} // namespace math
+} // namespace boost
+
+#endif // BOOST_MATH_DISTRIBUTIONS_COMMON_ERROR_HANDLING_HPP