| /* boost random/variate_generator.hpp header file |
| * |
| * Copyright Jens Maurer 2002 |
| * 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: variate_generator.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $ |
| * |
| */ |
| |
| #ifndef BOOST_RANDOM_RANDOM_GENERATOR_HPP |
| #define BOOST_RANDOM_RANDOM_GENERATOR_HPP |
| |
| #include <boost/config.hpp> |
| |
| // implementation details |
| #include <boost/detail/workaround.hpp> |
| #include <boost/random/uniform_01.hpp> |
| #include <boost/random/detail/pass_through_engine.hpp> |
| #include <boost/random/detail/uniform_int_float.hpp> |
| #include <boost/random/detail/ptr_helper.hpp> |
| |
| // Borland C++ 5.6.0 has problems using its numeric_limits traits as |
| // template parameters |
| #if BOOST_WORKAROUND(__BORLANDC__, <= 0x564) |
| #include <boost/type_traits/is_integral.hpp> |
| #endif |
| |
| #include <boost/random/detail/disable_warnings.hpp> |
| |
| namespace boost { |
| |
| /// \cond hide_private_members |
| |
| namespace random { |
| namespace detail { |
| |
| template<bool have_int, bool want_int> |
| struct engine_helper; |
| |
| // for consistency, always have two levels of decorations |
| template<> |
| struct engine_helper<true, true> |
| { |
| template<class Engine, class DistInputType> |
| struct impl |
| { |
| typedef pass_through_engine<Engine> type; |
| }; |
| }; |
| |
| template<> |
| struct engine_helper<false, false> |
| { |
| template<class Engine, class DistInputType> |
| struct impl |
| { |
| typedef uniform_01<Engine, DistInputType> type; |
| }; |
| }; |
| |
| template<> |
| struct engine_helper<true, false> |
| { |
| template<class Engine, class DistInputType> |
| struct impl |
| { |
| typedef uniform_01<Engine, DistInputType> type; |
| }; |
| }; |
| |
| template<> |
| struct engine_helper<false, true> |
| { |
| template<class Engine, class DistInputType> |
| struct impl |
| { |
| typedef uniform_int_float<Engine, unsigned long> type; |
| }; |
| }; |
| |
| } // namespace detail |
| } // 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. |
| * |
| * Instantations of class template @c variate_generator model |
| * a \number_generator. |
| * |
| * 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 random::detail::pass_through_engine<Engine> decorated_engine; |
| |
| public: |
| typedef typename decorated_engine::base_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(decorated_engine(e)), _dist(d) { } |
| |
| /** |
| * Returns: distribution()(e) |
| * |
| * Notes: The sequence of numbers produced by the |
| * \uniform_random_number_generator e, s<sub>e</sub>, is |
| * obtained from the sequence of numbers produced by the |
| * associated \uniform_random_number_generator eng, s<sub>eng</sub>, |
| * as follows: Consider the values of @c numeric_limits<T>::is_integer |
| * for @c T both @c Distribution::input_type and |
| * @c engine_value_type::result_type. If the values for both types are |
| * true, then se is identical to s<sub>eng</sub>. Otherwise, if the |
| * values for both types are false, then the numbers in s<sub>eng</sub> |
| * are divided by engine().max()-engine().min() to obtain the numbers |
| * in s<sub>e</sub>. Otherwise, if the value for |
| * @c engine_value_type::result_type is true and the value for |
| * @c Distribution::input_type is false, then the numbers in s<sub>eng</sub> |
| * are divided by engine().max()-engine().min()+1 to obtain the numbers in |
| * s<sub>e</sub>. Otherwise, the mapping from s<sub>eng</sub> to |
| * s<sub>e</sub> is implementation-defined. In all cases, an |
| * implicit conversion from @c engine_value_type::result_type to |
| * @c Distribution::input_type is performed. If such a conversion does |
| * not exist, the program is ill-formed. |
| */ |
| result_type operator()() { return _dist(_eng); } |
| /** |
| * Returns: distribution()(e, value). |
| * For the semantics of e, see the description of operator()(). |
| */ |
| template<class T> |
| result_type operator()(T value) { return _dist(_eng, value); } |
| |
| /** |
| * Returns: A reference to the associated uniform random number generator. |
| */ |
| engine_value_type& engine() { return _eng.base().base(); } |
| /** |
| * Returns: A reference to the associated uniform random number generator. |
| */ |
| const engine_value_type& engine() const { return _eng.base().base(); } |
| |
| /** |
| * 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: |
| #if BOOST_WORKAROUND(__BORLANDC__, <= 0x564) |
| typedef typename random::detail::engine_helper< |
| ::boost::is_integral<typename decorated_engine::result_type>::value, |
| ::boost::is_integral<typename Distribution::input_type>::value |
| >::BOOST_NESTED_TEMPLATE impl<decorated_engine, typename Distribution::input_type>::type internal_engine_type; |
| #else |
| enum { |
| have_int = std::numeric_limits<typename decorated_engine::result_type>::is_integer, |
| want_int = std::numeric_limits<typename Distribution::input_type>::is_integer |
| }; |
| typedef typename random::detail::engine_helper<have_int, want_int>::BOOST_NESTED_TEMPLATE impl<decorated_engine, typename Distribution::input_type>::type internal_engine_type; |
| #endif |
| |
| internal_engine_type _eng; |
| distribution_type _dist; |
| }; |
| |
| } // namespace boost |
| |
| #include <boost/random/detail/disable_warnings.hpp> |
| |
| #endif // BOOST_RANDOM_RANDOM_GENERATOR_HPP |