Class template variate

Class template variate_generator

boost::variate_generator

Synopsis

// In header: <boost/random/variate_generator.hpp>

template<typename Engine, typename Distribution> 
class variate_generator {
public:
  // types
  typedef helper_type::value_type   engine_value_type;
  typedef Engine                    engine_type;      
  typedef Distribution              distribution_type;
  typedef Distribution::result_type result_type;      

  // construct/copy/destruct
  variate_generator(Engine, Distribution);

  // public member functions
  result_type operator()();
  template<typename T> result_type operator()(const T &);
  engine_value_type & engine();
  const engine_value_type & engine() const;
  distribution_type & distribution();
  const distribution_type & distribution() const;
  result_type min() const;
  result_type max() const;
};

Description

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 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` public construct/copy/destruct

```
variate_generator(Engine e, Distribution d);
```
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.

`variate_generator` public member functions

```
result_type operator()();
```
Returns: distribution()(engine())

template<typename T> result_type operator()(const T & value);

Returns: distribution()(engine(), value).

```
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()