third_party/boost/include/boost/random/variate_generator.hpp

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