Class template additive_combine

Class template additive_combine_engine

boost::random::additive_combine_engine

Synopsis

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

template<typename MLCG1, typename MLCG2> 
class additive_combine_engine {
public:
  // types
  typedef               ; 
  typedef               ;
  typedef  ;

  // construct/copy/destruct
  ();
  ();
  template<typename SeedSeq> ();
  (, 
                          );
  template<typename It> (, );

  // public static functions
   ();
   ();

  // public member functions
   ();
   ();
  template<typename SeedSeq>  ();
   (, );
  template<typename It>  (, );
   ();
  template<typename Iter>  (, );
   ();

  // friend functions
  template<typename CharT, typename Traits> 
     
    (, 
               );
  template<typename CharT, typename Traits> 
     
    (, 
               );
   (, 
                  );
   (, 
                  );

  // public data members
  static  has_fixed_range;
};

Description

An instantiation of class template additive_combine_engine models a pseudo-random number generator . It combines two multiplicative linear_congruential_engine number generators, i.e. those with c = 0. It is described in

"Efficient and Portable Combined Random Number Generators", Pierre L'Ecuyer, Communications of the ACM, Vol. 31, No. 6, June 1988, pp. 742-749, 774

The template parameters MLCG1 and MLCG2 shall denote two different linear_congruential_engine number generators, each with c = 0. Each invocation returns a random number X(n) := (MLCG1(n) - MLCG2(n)) mod (m1 - 1), where m1 denotes the modulus of MLCG1.

`additive_combine_engine` public construct/copy/destruct

```
();
```
Constructs an additive_combine_engine using the default constructors of the two base generators.
```
( seed);
```
Constructs an additive_combine_engine, using seed as the constructor argument for both base generators.

template<typename SeedSeq> ( seq);

Constructs an additive_combine_engine, using seq as the constructor argument for both base generators.

	Warning
	The semantics of this function are liable to change. A `seed_seq` is designed to generate all the seeds in one shot, but this seeds the two base engines independantly and probably ends up giving the same sequence to both.

```
( seed1, 
                         seed2);
```
Constructs an additive_combine_engine, using seed1 and seed2 as the constructor argument to the first and second base generators, respectively.
```
template<typename It> ( first,  last);
```
Contructs an additive_combine_engine with values from the range defined by the input iterators first and last. first will be modified to point to the element after the last one used.

Throws: std::invalid_argument if the input range is too small.

Exception Safety: Basic

`additive_combine_engine` public static functions

```
 ();
```
Returns the smallest value that the generator can produce
```
 ();
```
Returns the largest value that the generator can produce

`additive_combine_engine` public member functions

```
 ();
```
Seeds an additive_combine_engine using the default seeds of the two base generators.
```
 ( seed);
```
Seeds an additive_combine_engine, using seed as the seed for both base generators.
```
template<typename SeedSeq>  ( seq);
```
Seeds an additive_combine_engine, using seq to seed both base generators.

See the warning on the corresponding constructor.
```
 ( seed1, 
           seed2);
```
Seeds an additive_combine generator, using seed1 and seed2 as the seeds to the first and second base generators, respectively.
```
template<typename It>  ( first,  last);
```
Seeds an additive_combine_engine with values from the range defined by the input iterators first and last. first will be modified to point to the element after the last one used.

Throws: std::invalid_argument if the input range is too small.

Exception Safety: Basic
```
 ();
```
Returns the next value of the generator.

template<typename Iter>  ( first,  last);

Fills a range with random values

```
 ( z);
```
Advances the state of the generator by z.

`additive_combine_engine` friend functions

```
template<typename CharT, typename Traits> 
   
  ( os, 
              r);
```
Writes the state of an additive_combine_engine to a std::ostream. The textual representation of an additive_combine_engine is the textual representation of the first base generator followed by the textual representation of the second base generator.

template<typename CharT, typename Traits> 
   
  ( is, 
              r);

Reads the state of an additive_combine_engine from a std::istream.

```
 ( x, 
                 y);
```
Returns: true iff the two additive_combine_engines will produce the same sequence of values.
```
 ( lhs, 
                 rhs);
```
Returns: true iff the two additive_combine_engines will produce different sequences of values.

Class template additive_combine_engine

Synopsis

Description

additive_combine_engine public construct/copy/destruct

additive_combine_engine public static functions

additive_combine_engine public member functions

additive_combine_engine friend functions

`additive_combine_engine` public construct/copy/destruct

`additive_combine_engine` public static functions

`additive_combine_engine` public member functions

`additive_combine_engine` friend functions