ceph/src/boost/libs/math/include/boost/math/distributions/detail/derived_accessors.hpp

   1 //  Copyright John Maddock 2006.
   2 //  Use, modification and distribution are subject to the
   3 //  Boost Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #ifndef BOOST_STATS_DERIVED_HPP
   7 #define BOOST_STATS_DERIVED_HPP
   8
   9 // This file implements various common properties of distributions
  10 // that can be implemented in terms of other properties:
  11 // variance OR standard deviation (see note below),
  12 // hazard, cumulative hazard (chf), coefficient_of_variation.
  13 //
  14 // Note that while both variance and standard_deviation are provided
  15 // here, each distribution MUST SPECIALIZE AT LEAST ONE OF THESE
  16 // otherwise these two versions will just call each other over and over
  17 // until stack space runs out ...
  18
  19 // Of course there may be more efficient means of implementing these
  20 // that are specific to a particular distribution, but these generic
  21 // versions give these properties "for free" with most distributions.
  22 //
  23 // In order to make use of this header, it must be included AT THE END
  24 // of the distribution header, AFTER the distribution and its core
  25 // property accessors have been defined: this is so that compilers
  26 // that implement 2-phase lookup and early-type-checking of templates
  27 // can find the definitions refered to herein.
  28 //
  29
  30 #include <boost/type_traits/is_same.hpp>
  31 #include <boost/static_assert.hpp>
  32
  33 #ifdef BOOST_MSVC
  34 # pragma warning(push)
  35 # pragma warning(disable: 4723) // potential divide by 0
  36 // Suppressing spurious warning in coefficient_of_variation
  37 #endif
  38
  39 namespace boost{ namespace math{
  40
  41 template <class Distribution>
  42 typename Distribution::value_type variance(const Distribution& dist);
  43
  44 template <class Distribution>
  45 inline typename Distribution::value_type standard_deviation(const Distribution& dist)
  46 {
  47    BOOST_MATH_STD_USING  // ADL of sqrt.
  48    return sqrt(variance(dist));
  49 }
  50
  51 template <class Distribution>
  52 inline typename Distribution::value_type variance(const Distribution& dist)
  53 {
  54    typename Distribution::value_type result = standard_deviation(dist);
  55    return result * result;
  56 }
  57
  58 template <class Distribution, class RealType>
  59 inline typename Distribution::value_type hazard(const Distribution& dist, const RealType& x)
  60 { // hazard function
  61   // http://www.itl.nist.gov/div898/handbook/eda/section3/eda362.htm#HAZ
  62    typedef typename Distribution::value_type value_type;
  63    typedef typename Distribution::policy_type policy_type;
  64    value_type p = cdf(complement(dist, x));
  65    value_type d = pdf(dist, x);
  66    if(d > p * tools::max_value<value_type>())
  67       return policies::raise_overflow_error<value_type>(
  68       "boost::math::hazard(const Distribution&, %1%)", 0, policy_type());
  69    if(d == 0)
  70    {
  71       // This protects against 0/0, but is it the right thing to do?
  72       return 0;
  73    }
  74    return d / p;
  75 }
  76
  77 template <class Distribution, class RealType>
  78 inline typename Distribution::value_type chf(const Distribution& dist, const RealType& x)
  79 { // cumulative hazard function.
  80   // http://www.itl.nist.gov/div898/handbook/eda/section3/eda362.htm#HAZ
  81    BOOST_MATH_STD_USING
  82    return -log(cdf(complement(dist, x)));
  83 }
  84
  85 template <class Distribution>
  86 inline typename Distribution::value_type coefficient_of_variation(const Distribution& dist)
  87 {
  88    typedef typename Distribution::value_type value_type;
  89    typedef typename Distribution::policy_type policy_type;
  90
  91    using std::abs;
  92
  93    value_type m = mean(dist);
  94    value_type d = standard_deviation(dist);
  95    if((abs(m) < 1) && (d > abs(m) * tools::max_value<value_type>()))
  96    { // Checks too that m is not zero,
  97       return policies::raise_overflow_error<value_type>("boost::math::coefficient_of_variation(const Distribution&, %1%)", 0, policy_type());
  98    }
  99    return d / m; // so MSVC warning on zerodivide is spurious, and suppressed.
 100 }
 101 //
 102 // Next follow overloads of some of the standard accessors with mixed
 103 // argument types. We just use a typecast to forward on to the "real"
 104 // implementation with all arguments of the same type:
 105 //
 106 template <class Distribution, class RealType>
 107 inline typename Distribution::value_type pdf(const Distribution& dist, const RealType& x)
 108 {
 109    typedef typename Distribution::value_type value_type;
 110    return pdf(dist, static_cast<value_type>(x));
 111 }
 112 template <class Distribution, class RealType>
 113 inline typename Distribution::value_type cdf(const Distribution& dist, const RealType& x)
 114 {
 115    typedef typename Distribution::value_type value_type;
 116    return cdf(dist, static_cast<value_type>(x));
 117 }
 118 template <class Distribution, class RealType>
 119 inline typename Distribution::value_type quantile(const Distribution& dist, const RealType& x)
 120 {
 121    typedef typename Distribution::value_type value_type;
 122    return quantile(dist, static_cast<value_type>(x));
 123 }
 124 /*
 125 template <class Distribution, class RealType>
 126 inline typename Distribution::value_type chf(const Distribution& dist, const RealType& x)
 127 {
 128    typedef typename Distribution::value_type value_type;
 129    return chf(dist, static_cast<value_type>(x));
 130 }
 131 */
 132 template <class Distribution, class RealType>
 133 inline typename Distribution::value_type cdf(const complemented2_type<Distribution, RealType>& c)
 134 {
 135    typedef typename Distribution::value_type value_type;
 136    return cdf(complement(c.dist, static_cast<value_type>(c.param)));
 137 }
 138
 139 template <class Distribution, class RealType>
 140 inline typename Distribution::value_type quantile(const complemented2_type<Distribution, RealType>& c)
 141 {
 142    typedef typename Distribution::value_type value_type;
 143    return quantile(complement(c.dist, static_cast<value_type>(c.param)));
 144 }
 145
 146 template <class Dist>
 147 inline typename Dist::value_type median(const Dist& d)
 148 { // median - default definition for those distributions for which a
 149   // simple closed form is not known,
 150   // and for which a domain_error and/or NaN generating function is NOT defined.
 151   typedef typename Dist::value_type value_type;
 152   return quantile(d, static_cast<value_type>(0.5f));
 153 }
 154
 155 } // namespace math
 156 } // namespace boost
 157
 158
 159 #ifdef BOOST_MSVC
 160 # pragma warning(pop)
 161 #endif
 162
 163 #endif // BOOST_STATS_DERIVED_HPP