/* boost random/non_central_chi_squared_distribution.hpp header file * * Copyright Thijs van den Berg 2014 * * Distributed under 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) * * See http://www.boost.org for most recent version including documentation. * * $Id$ */ #ifndef BOOST_RANDOM_NON_CENTRAL_CHI_SQUARED_DISTRIBUTION_HPP #define BOOST_RANDOM_NON_CENTRAL_CHI_SQUARED_DISTRIBUTION_HPP #include #include #include #include #include #include #include #include #include #include namespace boost { namespace random { /** * The noncentral chi-squared distribution is a real valued distribution with * two parameter, @c k and @c lambda. The distribution produces values > 0. * * This is the distribution of the sum of squares of k Normal distributed * variates each with variance one and \f$\lambda\f$ the sum of squares of the * normal means. * * The distribution function is * \f$\displaystyle P(x) = \frac{1}{2} e^{-(x+\lambda)/2} \left( \frac{x}{\lambda} \right)^{k/4-1/2} I_{k/2-1}( \sqrt{\lambda x} )\f$. * where \f$\displaystyle I_\nu(z)\f$ is a modified Bessel function of the * first kind. * * The algorithm is taken from * * @blockquote * "Monte Carlo Methods in Financial Engineering", Paul Glasserman, * 2003, XIII, 596 p, Stochastic Modelling and Applied Probability, Vol. 53, * ISBN 978-0-387-21617-1, p 124, Fig. 3.5. * @endblockquote */ template class non_central_chi_squared_distribution { public: typedef RealType result_type; typedef RealType input_type; class param_type { public: typedef non_central_chi_squared_distribution distribution_type; /** * Constructs the parameters of a non_central_chi_squared_distribution. * @c k and @c lambda are the parameter of the distribution. * * Requires: k > 0 && lambda > 0 */ explicit param_type(RealType k_arg = RealType(1), RealType lambda_arg = RealType(1)) : _k(k_arg), _lambda(lambda_arg) { BOOST_ASSERT(k_arg > RealType(0)); BOOST_ASSERT(lambda_arg > RealType(0)); } /** Returns the @c k parameter of the distribution */ RealType k() const { return _k; } /** Returns the @c lambda parameter of the distribution */ RealType lambda() const { return _lambda; } /** Writes the parameters of the distribution to a @c std::ostream. */ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm) { os << parm._k << ' ' << parm._lambda; return os; } /** Reads the parameters of the distribution from a @c std::istream. */ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm) { is >> parm._k >> std::ws >> parm._lambda; return is; } /** Returns true if the parameters have the same values. */ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs) { return lhs._k == rhs._k && lhs._lambda == rhs._lambda; } /** Returns true if the parameters have different values. */ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type) private: RealType _k; RealType _lambda; }; /** * Construct a @c non_central_chi_squared_distribution object. @c k and * @c lambda are the parameter of the distribution. * * Requires: k > 0 && lambda > 0 */ explicit non_central_chi_squared_distribution(RealType k_arg = RealType(1), RealType lambda_arg = RealType(1)) : _param(k_arg, lambda_arg) { BOOST_ASSERT(k_arg > RealType(0)); BOOST_ASSERT(lambda_arg > RealType(0)); } /** * Construct a @c non_central_chi_squared_distribution object from the parameter. */ explicit non_central_chi_squared_distribution(const param_type& parm) : _param( parm ) { } /** * Returns a random variate distributed according to the * non central chi squared distribution specified by @c param. */ template RealType operator()(URNG& eng, const param_type& parm) const { return non_central_chi_squared_distribution(parm)(eng); } /** * Returns a random variate distributed according to the * non central chi squared distribution. */ template RealType operator()(URNG& eng) { using std::sqrt; if (_param.k() > 1) { boost::random::normal_distribution n_dist; boost::random::chi_squared_distribution c_dist(_param.k() - RealType(1)); RealType _z = n_dist(eng); RealType _x = c_dist(eng); RealType term1 = _z + sqrt(_param.lambda()); return term1*term1 + _x; } else { boost::random::poisson_distribution<> p_dist(_param.lambda()/RealType(2)); boost::random::poisson_distribution<>::result_type _p = p_dist(eng); boost::random::chi_squared_distribution c_dist(_param.k() + RealType(2)*_p); return c_dist(eng); } } /** Returns the @c k parameter of the distribution. */ RealType k() const { return _param.k(); } /** Returns the @c lambda parameter of the distribution. */ RealType lambda() const { return _param.lambda(); } /** Returns the parameters of the distribution. */ param_type param() const { return _param; } /** Sets parameters of the distribution. */ void param(const param_type& parm) { _param = parm; } /** Resets the distribution, so that subsequent uses does not depend on values already produced by it.*/ void reset() {} /** Returns the smallest value that the distribution can produce. */ RealType min BOOST_PREVENT_MACRO_SUBSTITUTION() const { return RealType(0); } /** Returns the largest value that the distribution can produce. */ RealType max BOOST_PREVENT_MACRO_SUBSTITUTION() const { return (std::numeric_limits::infinity)(); } /** Writes the parameters of the distribution to a @c std::ostream. */ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, non_central_chi_squared_distribution, dist) { os << dist.param(); return os; } /** reads the parameters of the distribution from a @c std::istream. */ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, non_central_chi_squared_distribution, dist) { param_type parm; if(is >> parm) { dist.param(parm); } return is; } /** Returns true if two distributions have the same parameters and produce the same sequence of random numbers given equal generators.*/ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(non_central_chi_squared_distribution, lhs, rhs) { return lhs.param() == rhs.param(); } /** Returns true if two distributions have different parameters and/or can produce different sequences of random numbers given equal generators.*/ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(non_central_chi_squared_distribution) private: /// @cond show_private param_type _param; /// @endcond }; } // namespace random } // namespace boost #endif