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 MLCG1              ; 
  typedef MLCG2              ;
  typedef  ;

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

  // public static functions
  constexpr  ();
  constexpr  ();

  // public member functions
  void ();
  void ();
  template<typename SeedSeq> void (SeedSeq &);
  void (typename , typename );
  template<typename It> void (It &, It);
   ();
  template<typename Iter> void (Iter, Iter);
  void (boost::uintmax_t);

  // friend functions
  template<typename CharT, typename Traits> 
    CharT, Traits > & 
    (CharT, Traits > &, 
               const additive_combine_engine &);
  template<typename CharT, typename Traits> 
    CharT, Traits > & 
    (CharT, Traits > &, 
               const additive_combine_engine &);
  bool (const additive_combine_engine &, 
                  const additive_combine_engine &);
  bool (const additive_combine_engine &, 
                  const additive_combine_engine &);

  // public data members
  static const bool 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> (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.

```
(typename  seed1, 
                        typename  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> (It & first, It 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

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

`additive_combine_engine` public member functions

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

See the warning on the corresponding constructor.
```
void (typename  seed1, 
          typename  seed2);
```
Seeds an additive_combine generator, using seed1 and seed2 as the seeds to the first and second base generators, respectively.
```
template<typename It> void (It & first, It 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> void (Iter first, Iter last);

Fills a range with random values

```
void (boost::uintmax_t z);
```
Advances the state of the generator by z.

`additive_combine_engine` friend functions

```
template<typename CharT, typename Traits> 
  CharT, Traits > & 
  (CharT, Traits > & os, 
             const additive_combine_engine & 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> 
  CharT, Traits > & 
  (CharT, Traits > & is, 
             const additive_combine_engine & r);

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

bool (const additive_combine_engine & x, 
                const additive_combine_engine & y);

Returns: true iff the two additive_combine_engines will produce the same sequence of values.

bool (const additive_combine_engine & lhs, 
                const additive_combine_engine & rhs);

Returns: true iff the two additive_combine_engines will produce different sequences of values.