| Home | Libraries | People | FAQ | More

## Class rand48

boost::random::rand48

## Synopsis

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

    class rand48 {
    public:
      // types
      typedef boost::uint32_t result_type;

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

      // public static functions
      static uint32_t min();
      static uint32_t max();

      // public member functions
      void seed();
      void seed(result_type);
      template<typename It> void seed(It &, It);
      template<typename SeedSeq> void seed(SeedSeq &);
      uint32_t operator()();
      void discard(boost::uintmax_t);
      template<typename Iter> void generate(Iter, Iter);

      // friend functions
      template<typename CharT, typename Traits>
        friend std::basic_ostream< CharT, Traits > &
        operator<<(std::basic_ostream< CharT, Traits > &, const rand48 &);
      template<typename CharT, typename Traits>
        friend std::basic_istream< CharT, Traits > &
        operator>>(std::basic_istream< CharT, Traits > &, rand48 &);
      friend bool operator==(const rand48 &, const rand48 &);
      friend bool operator!=(const rand48 &, const rand48 &);

      // public data members
      static const bool has_fixed_range;
    };

## Description

Class `rand48` models a pseudo-random number generator . It uses the linear congruential algorithm with the parameters a = 0x5DEECE66D, c = 0xB, m = 2**48. It delivers identical results to the `lrand48()` function available on some systems (assuming lcong48 has not been called).

It is only available on systems where `uint64_t` is provided as an integral type, so that for example static in-class constants and/or enum definitions with large `uint64_t` numbers work.

### `rand48` public construct/copy/destruct

1.     rand48();

   Seeds the generator with the default seed.

2.     explicit rand48(result_type x0);

   Constructs a `rand48` generator with x(0) := (x0 << 16) | 0x330e.

3.     template<typename SeedSeq> explicit rand48(SeedSeq & seq);

   Seeds the generator with values produced by `seq.generate()`.

4.     template<typename It> rand48(It & first, It last);

   Seeds the generator using values from an iterator range, and updates first to point one past the last value consumed.

### `rand48` public static functions

1.     static uint32_t min();

   Returns the smallest value that the generator can produce

2.     static uint32_t max();

   Returns the largest value that the generator can produce

### `rand48` public member functions

1.     void seed();

   Seeds the generator with the default seed.

2.     void seed(result_type x0);

   Changes the current value x(n) of the generator to (x0 << 16) | 0x330e.

3.     template<typename It> void seed(It & first, It last);

   Seeds the generator using values from an iterator range, and updates first to point one past the last value consumed.

4.     template<typename SeedSeq> void seed(SeedSeq & seq);

   Seeds the generator with values produced by `seq.generate()`.

5.     uint32_t operator()();

   Returns the next value of the generator.

6.     void discard(boost::uintmax_t z);

   Advances the state of the generator by `z`.

7.     template<typename Iter> void generate(Iter first, Iter last);

   Fills a range with random values

### `rand48` friend functions

1.     template<typename CharT, typename Traits>
         friend std::basic_ostream< CharT, Traits > &
         operator<<(std::basic_ostream< CharT, Traits > & os, const rand48 & r);

   Writes a ``rand48`` to a `std::ostream`.

2.     template<typename CharT, typename Traits>
         friend std::basic_istream< CharT, Traits > &
         operator>>(std::basic_istream< CharT, Traits > & is, rand48 & r);

   Reads a ``rand48`` from a `std::istream`.

3.     friend bool operator==(const rand48 & x, const rand48 & y);

   Returns true if the two generators will produce identical sequences of values.

4.     friend bool operator!=(const rand48 & x, const rand48 & y);

   Returns true if the two generators will produce different sequences of values.