SV platform dependency builds

//  Copyright John Maddock 2006.

//  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_STATS_DERIVED_HPP

#define BOOST_STATS_DERIVED_HPP

// This file implements various common properties of distributions

// that can be implemented in terms of other properties:

// variance OR standard deviation (see note below),

// hazard, cumulative hazard (chf), coefficient_of_variation.

//

// Note that while both variance and standard_deviation are provided

// here, each distribution MUST SPECIALIZE AT LEAST ONE OF THESE

// otherwise these two versions will just call each other over and over

// until stack space runs out ...

// Of course there may be more efficient means of implementing these

// that are specific to a particular distribution, but these generic

// versions give these properties "for free" with most distributions.

//

// In order to make use of this header, it must be included AT THE END

// of the distribution header, AFTER the distribution and its core

// property accessors have been defined: this is so that compilers

// that implement 2-phase lookup and early-type-checking of templates

// can find the definitions refered to herein.

//

#include <boost/type_traits/is_same.hpp>

#include <boost/static_assert.hpp>

#ifdef BOOST_MSVC

# pragma warning(push)

# pragma warning(disable: 4723) // potential divide by 0

// Suppressing spurious warning in coefficient_of_variation

#endif

namespace boost{ namespace math{

template <class Distribution>

typename Distribution::value_type variance(const Distribution& dist);

template <class Distribution>

inline typename Distribution::value_type standard_deviation(const Distribution& dist)

{

   BOOST_MATH_STD_USING  // ADL of sqrt.

   return sqrt(variance(dist));

}

template <class Distribution>

inline typename Distribution::value_type variance(const Distribution& dist)

{

   typename Distribution::value_type result = standard_deviation(dist);

   return result * result;

}

template <class Distribution, class RealType>

inline typename Distribution::value_type hazard(const Distribution& dist, const RealType& x)

{ // hazard function

  // http://www.itl.nist.gov/div898/handbook/eda/section3/eda362.htm#HAZ

   typedef typename Distribution::value_type value_type;

   typedef typename Distribution::policy_type policy_type;

   value_type p = cdf(complement(dist, x));

   value_type d = pdf(dist, x);

   if(d > p * tools::max_value<value_type>())

      return policies::raise_overflow_error<value_type>(

      "boost::math::hazard(const Distribution&, %1%)", 0, policy_type());

   if(d == 0)

   {

      // This protects against 0/0, but is it the right thing to do?

      return 0;

   }

   return d / p;

}

template <class Distribution, class RealType>

inline typename Distribution::value_type chf(const Distribution& dist, const RealType& x)

{ // cumulative hazard function.

  // http://www.itl.nist.gov/div898/handbook/eda/section3/eda362.htm#HAZ

   BOOST_MATH_STD_USING

   return -log(cdf(complement(dist, x)));

}

template <class Distribution>

inline typename Distribution::value_type coefficient_of_variation(const Distribution& dist)

{

   typedef typename Distribution::value_type value_type;

   typedef typename Distribution::policy_type policy_type;

   using std::abs;

   value_type m = mean(dist);

   value_type d = standard_deviation(dist);

   if((abs(m) < 1) && (d > abs(m) * tools::max_value<value_type>()))

   { // Checks too that m is not zero,

      return policies::raise_overflow_error<value_type>("boost::math::coefficient_of_variation(const Distribution&, %1%)", 0, policy_type());

   }

   return d / m; // so MSVC warning on zerodivide is spurious, and suppressed.

}

//

// Next follow overloads of some of the standard accessors with mixed

// argument types. We just use a typecast to forward on to the "real"

// implementation with all arguments of the same type:

//

template <class Distribution, class RealType>

inline typename Distribution::value_type pdf(const Distribution& dist, const RealType& x)

{

   typedef typename Distribution::value_type value_type;

   return pdf(dist, static_cast<value_type>(x));

}

template <class Distribution, class RealType>

inline typename Distribution::value_type cdf(const Distribution& dist, const RealType& x)

{

   typedef typename Distribution::value_type value_type;

   return cdf(dist, static_cast<value_type>(x));

}

template <class Distribution, class RealType>

inline typename Distribution::value_type quantile(const Distribution& dist, const RealType& x)

{

   typedef typename Distribution::value_type value_type;

   return quantile(dist, static_cast<value_type>(x));

}

/*

template <class Distribution, class RealType>

inline typename Distribution::value_type chf(const Distribution& dist, const RealType& x)

{

   typedef typename Distribution::value_type value_type;

   return chf(dist, static_cast<value_type>(x));

}

*/

template <class Distribution, class RealType>

inline typename Distribution::value_type cdf(const complemented2_type<Distribution, RealType>& c)

{

   typedef typename Distribution::value_type value_type;

   return cdf(complement(c.dist, static_cast<value_type>(c.param)));

}

template <class Distribution, class RealType>

inline typename Distribution::value_type quantile(const complemented2_type<Distribution, RealType>& c)

{

   typedef typename Distribution::value_type value_type;

   return quantile(complement(c.dist, static_cast<value_type>(c.param)));

}

template <class Dist>

inline typename Dist::value_type median(const Dist& d)

{ // median - default definition for those distributions for which a

  // simple closed form is not known,

  // and for which a domain_error and/or NaN generating function is NOT defined.

  typedef typename Dist::value_type value_type;

  return quantile(d, static_cast<value_type>(0.5f));

}

} // namespace math

} // namespace boost

#ifdef BOOST_MSVC

# pragma warning(pop)

#endif

#endif // BOOST_STATS_DERIVED_HPP