Class template lagged_fibonacci

Class template lagged_fibonacci_engine

boost::random::lagged_fibonacci_engine

Synopsis

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

template<typename UIntType,  w,  p,  q> 
class lagged_fibonacci_engine {
public:
  // types
  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;
  static  word_size;
  static  long_lag;
  static  short_lag;
  static  default_seed;
};

Description

Instantiations of class template lagged_fibonacci_engine model a pseudo-random number generator . It uses a lagged Fibonacci algorithm with two lags p and q: x(i) = x(i-p) + x(i-q) (mod 2^w) with p > q.

`lagged_fibonacci_engine` public construct/copy/destruct

```
();
```
Creates a new lagged_fibonacci_engine and calls seed().
```
( value);
```
Creates a new lagged_fibonacci_engine and calls seed(value).
```
template<typename SeedSeq> ( seq);
```
Creates a new lagged_fibonacci_engine and calls seed(seq).
```
template<typename It> ( first,  last);
```
Creates a new lagged_fibonacci_engine and calls seed(first, last).

`lagged_fibonacci_engine` public static functions

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

`lagged_fibonacci_engine` public member functions

```
 ();
```
Calls seed(default_seed).
```
 ( value);
```
Sets the state of the generator to values produced by a minstd_rand0 generator.
```
template<typename SeedSeq>  ( seq);
```
Sets the state of the generator using values produced by seq.
```
template<typename It>  ( first,  last);
```
Sets the state of the generator to values from the iterator range [first, last). If there are not enough elements in the range [first, last) throws std::invalid_argument.
```
 ();
```
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.

`lagged_fibonacci_engine` friend functions

template<typename CharT, typename Traits> 
   
  ( os, 
              f);

Writes the textual representation of the generator to a std::ostream.

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

Reads the textual representation of the generator from a std::istream.

```
 ( x_, 
                 y_);
```
Returns true if the two generators will produce identical sequences of outputs.
```
 ( lhs, 
                 rhs);
```
Returns true if the two generators will produce different sequences of outputs.

Class template lagged_fibonacci_engine

Synopsis

Description

lagged_fibonacci_engine public construct/copy/destruct

lagged_fibonacci_engine public static functions

lagged_fibonacci_engine public member functions

lagged_fibonacci_engine friend functions

`lagged_fibonacci_engine` public construct/copy/destruct

`lagged_fibonacci_engine` public static functions

`lagged_fibonacci_engine` public member functions

`lagged_fibonacci_engine` friend functions