| // Copyright 2008 Gautam Sewani |
| // Copyright 2008 John Maddock |
| // |
| // 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_HYPERGEOMETRIC_HPP |
| #define BOOST_MATH_DISTRIBUTIONS_HYPERGEOMETRIC_HPP |
| |
| #include <boost/math/distributions/detail/common_error_handling.hpp> |
| #include <boost/math/distributions/complement.hpp> |
| #include <boost/math/distributions/detail/hypergeometric_pdf.hpp> |
| #include <boost/math/distributions/detail/hypergeometric_cdf.hpp> |
| #include <boost/math/distributions/detail/hypergeometric_quantile.hpp> |
| #include <boost/math/special_functions/fpclassify.hpp> |
| |
| |
| namespace boost { namespace math { |
| |
| template <class RealType = double, class Policy = policies::policy<> > |
| class hypergeometric_distribution |
| { |
| public: |
| typedef RealType value_type; |
| typedef Policy policy_type; |
| |
| hypergeometric_distribution(unsigned r, unsigned n, unsigned N) // Constructor. |
| : m_n(n), m_N(N), m_r(r) |
| { |
| static const char* function = "boost::math::hypergeometric_distribution<%1%>::hypergeometric_distribution"; |
| RealType ret; |
| check_params(function, &ret); |
| } |
| // Accessor functions. |
| unsigned total()const |
| { |
| return m_N; |
| } |
| |
| unsigned defective()const |
| { |
| return m_n; |
| } |
| |
| unsigned sample_count()const |
| { |
| return m_r; |
| } |
| |
| bool check_params(const char* function, RealType* result)const |
| { |
| if(m_r > m_N) |
| { |
| *result = boost::math::policies::raise_domain_error<RealType>( |
| function, "Parameter r out of range: must be <= N but got %1%", static_cast<RealType>(m_r), Policy()); |
| return false; |
| } |
| if(m_n > m_N) |
| { |
| *result = boost::math::policies::raise_domain_error<RealType>( |
| function, "Parameter n out of range: must be <= N but got %1%", static_cast<RealType>(m_n), Policy()); |
| return false; |
| } |
| return true; |
| } |
| bool check_x(unsigned x, const char* function, RealType* result)const |
| { |
| if(x < static_cast<unsigned>((std::max)(0, (int)(m_n + m_r) - (int)(m_N)))) |
| { |
| *result = boost::math::policies::raise_domain_error<RealType>( |
| function, "Random variable out of range: must be > 0 and > m + r - N but got %1%", static_cast<RealType>(x), Policy()); |
| return false; |
| } |
| if(x > (std::min)(m_r, m_n)) |
| { |
| *result = boost::math::policies::raise_domain_error<RealType>( |
| function, "Random variable out of range: must be less than both n and r but got %1%", static_cast<RealType>(x), Policy()); |
| return false; |
| } |
| return true; |
| } |
| |
| private: |
| // Data members: |
| unsigned m_n; // number of "defective" items |
| unsigned m_N; // number of "total" items |
| unsigned m_r; // number of items picked |
| |
| }; // class hypergeometric_distribution |
| |
| typedef hypergeometric_distribution<double> hypergeometric; |
| |
| template <class RealType, class Policy> |
| inline const std::pair<unsigned, unsigned> range(const hypergeometric_distribution<RealType, Policy>& dist) |
| { // Range of permissible values for random variable x. |
| #ifdef BOOST_MSVC |
| # pragma warning(push) |
| # pragma warning(disable:4267) |
| #endif |
| unsigned r = dist.sample_count(); |
| unsigned n = dist.defective(); |
| unsigned N = dist.total(); |
| unsigned l = static_cast<unsigned>((std::max)(0, (int)(n + r) - (int)(N))); |
| unsigned u = (std::min)(r, n); |
| return std::pair<unsigned, unsigned>(l, u); |
| #ifdef BOOST_MSVC |
| # pragma warning(pop) |
| #endif |
| } |
| |
| template <class RealType, class Policy> |
| inline const std::pair<unsigned, unsigned> support(const hypergeometric_distribution<RealType, Policy>& d) |
| { |
| return range(d); |
| } |
| |
| template <class RealType, class Policy> |
| inline RealType pdf(const hypergeometric_distribution<RealType, Policy>& dist, const unsigned& x) |
| { |
| static const char* function = "boost::math::pdf(const hypergeometric_distribution<%1%>&, const %1%&)"; |
| RealType result; |
| if(!dist.check_params(function, &result)) |
| return result; |
| if(!dist.check_x(x, function, &result)) |
| return result; |
| |
| return boost::math::detail::hypergeometric_pdf<RealType>( |
| x, dist.sample_count(), dist.defective(), dist.total(), Policy()); |
| } |
| |
| template <class RealType, class Policy, class U> |
| inline RealType pdf(const hypergeometric_distribution<RealType, Policy>& dist, const U& x) |
| { |
| static const char* function = "boost::math::pdf(const hypergeometric_distribution<%1%>&, const %1%&)"; |
| RealType r = static_cast<RealType>(x); |
| unsigned u = boost::math::itrunc(r); |
| if(u != r) |
| { |
| return boost::math::policies::raise_domain_error<RealType>( |
| function, "Random variable out of range: must be an integer but got %1%", r, Policy()); |
| } |
| return pdf(dist, u); |
| } |
| |
| template <class RealType, class Policy> |
| inline RealType cdf(const hypergeometric_distribution<RealType, Policy>& dist, const unsigned& x) |
| { |
| static const char* function = "boost::math::cdf(const hypergeometric_distribution<%1%>&, const %1%&)"; |
| RealType result; |
| if(!dist.check_params(function, &result)) |
| return result; |
| if(!dist.check_x(x, function, &result)) |
| return result; |
| |
| return boost::math::detail::hypergeometric_cdf<RealType>( |
| x, dist.sample_count(), dist.defective(), dist.total(), false, Policy()); |
| } |
| |
| template <class RealType, class Policy, class U> |
| inline RealType cdf(const hypergeometric_distribution<RealType, Policy>& dist, const U& x) |
| { |
| static const char* function = "boost::math::cdf(const hypergeometric_distribution<%1%>&, const %1%&)"; |
| RealType r = static_cast<RealType>(x); |
| unsigned u = boost::math::itrunc(r); |
| if(u != r) |
| { |
| return boost::math::policies::raise_domain_error<RealType>( |
| function, "Random variable out of range: must be an integer but got %1%", r, Policy()); |
| } |
| return cdf(dist, u); |
| } |
| |
| template <class RealType, class Policy> |
| inline RealType cdf(const complemented2_type<hypergeometric_distribution<RealType, Policy>, unsigned>& c) |
| { |
| static const char* function = "boost::math::cdf(const hypergeometric_distribution<%1%>&, const %1%&)"; |
| RealType result; |
| if(!c.dist.check_params(function, &result)) |
| return result; |
| if(!c.dist.check_x(c.param, function, &result)) |
| return result; |
| |
| return boost::math::detail::hypergeometric_cdf<RealType>( |
| c.param, c.dist.sample_count(), c.dist.defective(), c.dist.total(), true, Policy()); |
| } |
| |
| template <class RealType, class Policy, class U> |
| inline RealType cdf(const complemented2_type<hypergeometric_distribution<RealType, Policy>, U>& c) |
| { |
| static const char* function = "boost::math::cdf(const hypergeometric_distribution<%1%>&, const %1%&)"; |
| RealType r = static_cast<RealType>(c.param); |
| unsigned u = boost::math::itrunc(r); |
| if(u != r) |
| { |
| return boost::math::policies::raise_domain_error<RealType>( |
| function, "Random variable out of range: must be an integer but got %1%", r, Policy()); |
| } |
| return cdf(complement(c.dist, u)); |
| } |
| |
| template <class RealType, class Policy> |
| inline RealType quantile(const hypergeometric_distribution<RealType, Policy>& dist, const RealType& p) |
| { |
| BOOST_MATH_STD_USING // for ADL of std functions |
| |
| // Checking function argument |
| RealType result; |
| const char* function = "boost::math::quantile(const hypergeometric_distribution<%1%>&, %1%)"; |
| if (false == dist.check_params(function, &result)) return result; |
| if(false == detail::check_probability(function, p, &result, Policy())) return result; |
| |
| return static_cast<RealType>(detail::hypergeometric_quantile(p, RealType(1 - p), dist.sample_count(), dist.defective(), dist.total(), Policy())); |
| } // quantile |
| |
| template <class RealType, class Policy> |
| inline RealType quantile(const complemented2_type<hypergeometric_distribution<RealType, Policy>, RealType>& c) |
| { |
| BOOST_MATH_STD_USING // for ADL of std functions |
| |
| // Checking function argument |
| RealType result; |
| const char* function = "quantile(const complemented2_type<hypergeometric_distribution<%1%>, %1%>&)"; |
| if (false == c.dist.check_params(function, &result)) return result; |
| if(false == detail::check_probability(function, c.param, &result, Policy())) return result; |
| |
| return static_cast<RealType>(detail::hypergeometric_quantile(RealType(1 - c.param), c.param, c.dist.sample_count(), c.dist.defective(), c.dist.total(), Policy())); |
| } // quantile |
| |
| template <class RealType, class Policy> |
| inline RealType mean(const hypergeometric_distribution<RealType, Policy>& dist) |
| { |
| return static_cast<RealType>(dist.sample_count() * dist.defective()) / dist.total(); |
| } // RealType mean(const hypergeometric_distribution<RealType, Policy>& dist) |
| |
| template <class RealType, class Policy> |
| inline RealType variance(const hypergeometric_distribution<RealType, Policy>& dist) |
| { |
| RealType r = static_cast<RealType>(dist.sample_count()); |
| RealType n = static_cast<RealType>(dist.defective()); |
| RealType N = static_cast<RealType>(dist.total()); |
| return r * (n / N) * (1 - n / N) * (N - r) / (N - 1); |
| } // RealType variance(const hypergeometric_distribution<RealType, Policy>& dist) |
| |
| template <class RealType, class Policy> |
| inline RealType mode(const hypergeometric_distribution<RealType, Policy>& dist) |
| { |
| BOOST_MATH_STD_USING |
| RealType r = static_cast<RealType>(dist.sample_count()); |
| RealType n = static_cast<RealType>(dist.defective()); |
| RealType N = static_cast<RealType>(dist.total()); |
| return floor((r + 1) * (n + 1) / (N + 2)); |
| } |
| |
| template <class RealType, class Policy> |
| inline RealType skewness(const hypergeometric_distribution<RealType, Policy>& dist) |
| { |
| BOOST_MATH_STD_USING |
| RealType r = static_cast<RealType>(dist.sample_count()); |
| RealType n = static_cast<RealType>(dist.defective()); |
| RealType N = static_cast<RealType>(dist.total()); |
| return (N - 2 * n) * sqrt(N - 1) * (N - 2 * r) / (sqrt(n * r * (N - n) * (N - r)) * (N - 2)); |
| } // RealType skewness(const hypergeometric_distribution<RealType, Policy>& dist) |
| |
| template <class RealType, class Policy> |
| inline RealType kurtosis_excess(const hypergeometric_distribution<RealType, Policy>& dist) |
| { |
| RealType r = static_cast<RealType>(dist.sample_count()); |
| RealType n = static_cast<RealType>(dist.defective()); |
| RealType N = static_cast<RealType>(dist.total()); |
| RealType t1 = N * N * (N - 1) / (r * (N - 2) * (N - 3) * (N - r)); |
| RealType t2 = (N * (N + 1) - 6 * N * (N - r)) / (n * (N - n)) |
| + 3 * r * (N - r) * (N + 6) / (N * N) - 6; |
| return t1 * t2; |
| } // RealType kurtosis_excess(const hypergeometric_distribution<RealType, Policy>& dist) |
| |
| template <class RealType, class Policy> |
| inline RealType kurtosis(const hypergeometric_distribution<RealType, Policy>& dist) |
| { |
| return kurtosis_excess(dist) + 3; |
| } // RealType kurtosis_excess(const hypergeometric_distribution<RealType, Policy>& dist) |
| }} // namespaces |
| |
| // This include must be at the end, *after* the accessors |
| // for this distribution have been defined, in order to |
| // keep compilers that support two-phase lookup happy. |
| #include <boost/math/distributions/detail/derived_accessors.hpp> |
| |
| #endif // include guard |