| /* boost random/variate_generator.hpp header file |
| * |
| * Copyright Jens Maurer 2002 |
| * Copyright Steven Watanabe 2011 |
| * 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_RANDOM_GENERATOR_HPP |
| #define BOOST_RANDOM_RANDOM_GENERATOR_HPP |
| |
| #include <boost/random/detail/ptr_helper.hpp> |
| |
| #include <boost/random/detail/disable_warnings.hpp> |
| |
| namespace boost { |
| |
| /// \cond hide_private_members |
| |
| namespace random { |
| |
| ///\endcond |
| |
| /** |
| * A random variate generator is used to join a random number |
| * generator together with a random number distribution. |
| * Boost.Random provides a vast choice of \generators as well |
| * as \distributions. |
| * |
| * The argument for the template parameter Engine shall be of |
| * the form U, U&, or U*, where U models a |
| * \uniform_random_number_generator. Then, the member |
| * engine_value_type names U (not the pointer or reference to U). |
| * |
| * Specializations of @c variate_generator satisfy the |
| * requirements of CopyConstructible. They also satisfy the |
| * requirements of Assignable unless the template parameter |
| * Engine is of the form U&. |
| * |
| * The complexity of all functions specified in this section |
| * is constant. No function described in this section except |
| * the constructor throws an exception. |
| */ |
| template<class Engine, class Distribution> |
| class variate_generator |
| { |
| private: |
| typedef boost::random::detail::ptr_helper<Engine> helper_type; |
| public: |
| typedef typename helper_type::value_type engine_value_type; |
| typedef Engine engine_type; |
| typedef Distribution distribution_type; |
| typedef typename Distribution::result_type result_type; |
| |
| /** |
| * Constructs a @c variate_generator object with the associated |
| * \uniform_random_number_generator eng and the associated |
| * \random_distribution d. |
| * |
| * Throws: If and what the copy constructor of Engine or |
| * Distribution throws. |
| */ |
| variate_generator(Engine e, Distribution d) |
| : _eng(e), _dist(d) { } |
| |
| /** Returns: distribution()(engine()) */ |
| result_type operator()() { return _dist(engine()); } |
| /** |
| * Returns: distribution()(engine(), value). |
| */ |
| template<class T> |
| result_type operator()(const T& value) { return _dist(engine(), value); } |
| |
| /** |
| * Returns: A reference to the associated uniform random number generator. |
| */ |
| engine_value_type& engine() { return helper_type::ref(_eng); } |
| /** |
| * Returns: A reference to the associated uniform random number generator. |
| */ |
| const engine_value_type& engine() const { return helper_type::ref(_eng); } |
| |
| /** Returns: A reference to the associated \random_distribution. */ |
| distribution_type& distribution() { return _dist; } |
| /** |
| * Returns: A reference to the associated random distribution. |
| */ |
| const distribution_type& distribution() const { return _dist; } |
| |
| /** |
| * Precondition: distribution().min() is well-formed |
| * |
| * Returns: distribution().min() |
| */ |
| result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (distribution().min)(); } |
| /** |
| * Precondition: distribution().max() is well-formed |
| * |
| * Returns: distribution().max() |
| */ |
| result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (distribution().max)(); } |
| |
| private: |
| Engine _eng; |
| distribution_type _dist; |
| }; |
| |
| } // namespace random |
| |
| using random::variate_generator; |
| |
| } // namespace boost |
| |
| #include <boost/random/detail/enable_warnings.hpp> |
| |
| #endif // BOOST_RANDOM_RANDOM_GENERATOR_HPP |