Boost Random Number Library Variate Generator

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 .

Class template variate_generator

Synopsis

#include <boost/random/variate_generator.hpp>

template<class Engine, class Distribution>
class variate_generator
{
public:
  typedef Engine engine_type;
  typedef Distribution distribution_type;
  typedef typename Distribution::result_type result_type;

  variate_generator(Engine e, Distribution d);

  result_type operator()();
  template<class T>
  result_type operator()(T value);
  
  engine_value_type& engine();
  const engine_value_type& engine() const;

  result_type min() const;
  result_type max() const;
};

Description

Instantations of class template 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 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.

    variate_generator(engine_type eng, distribution_type d)
Effects: Constructs a 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.
    result_type operator()()
Returns: distribution()(e)
Notes: The sequence of numbers produced by the uniform random number generator e, se, is obtained from the sequence of numbers produced by the associated uniform random number generator eng, seng, as follows: Consider the values of numeric_limits<T>::is_integer for T both Distribution::input_type and engine_value_type::result_type. If the values for both types are true, then se is identical to seng. Otherwise, if the values for both types are false, then the numbers in seng are divided by engine().max()-engine().min() to obtain the numbers in se. Otherwise, if the value for engine_value_type::result_type is true and the value for Distribution::input_type is false, then the numbers in seng are divided by engine().max()-engine().min()+1 to obtain the numbers in se. Otherwise, the mapping from seng to se is implementation-defined. In all cases, an implicit conversion from engine_value_type::result_type to Distribution::input_type is performed. If such a conversion does not exist, the program is ill-formed.
    template<class T> result_type operator()(T value)
Returns: distribution()(e, value). For the semantics of e, see the description of operator()().
    engine_value_type& engine()
Returns: A reference to the associated uniform random number generator.
    const engine_value_type& engine() const
Returns: A reference to the associated uniform random number generator.
    distribution_type& distribution()
Returns: A reference to the associated random distribution.
    const distribution_type& distribution() const
Returns: A reference to the associated random distribution.
    result_type min() const
Precondition: distribution().min() is well-formed
Returns: distribution().min()
    result_type max() const
Precondition: distribution().max() is well-formed
Returns: distribution().max()


Jens Maurer, 2003-10-25