| Home | Libraries | People | FAQ | More

## Class template independent_bits_engine

boost::random::independent_bits_engine

## Synopsis

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

    template<typename Engine, std::size_t w, typename UIntType>
    class independent_bits_engine {
    public:
      // types
      typedef Engine   base_type;
      typedef UIntType result_type;

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

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

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

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

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

## Description

An instantiation of class template `independent_bits_engine` model a pseudo-random number generator . It generates random numbers distributed between [0, 2^w) by combining one or more invocations of the base engine.

Requires: 0 < w <= std::numeric_limits<UIntType>::digits

### `independent_bits_engine` public construct/copy/destruct

1.     independent_bits_engine();

   Constructs an ``independent_bits_engine`` using the default constructor of the base generator.

2.     explicit independent_bits_engine(result_type seed);

   Constructs an ``independent_bits_engine``, using seed as the constructor argument for both base generators.

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

   Constructs an ``independent_bits_engine``, using seq as the constructor argument for the base generator.

4.     independent_bits_engine(const base_type & base_arg);

   Constructs an ``independent_bits_engine`` by copying `base`.

5.     template<typename It> independent_bits_engine(It & first, It last);

   Contructs an ``independent_bits_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

### `independent_bits_engine` public static functions

1.     static result_type min();

   Returns the smallest value that the generator can produce.

2.     static result_type max();

   Returns the largest value that the generator can produce.

### `independent_bits_engine` public member functions

1.     void seed();

   Seeds an ``independent_bits_engine`` using the default seed of the base generator.

2.     void seed(result_type seed);

   Seeds an ``independent_bits_engine``, using `seed` as the seed for the base generator.

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

   Seeds an ``independent_bits_engine``, using `seq` to seed the base generator.

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

   Seeds an ``independent_bits_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

5.     result_type operator()();

   Returns the next value of the generator.

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

   Fills a range with random values

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

   Advances the state of the generator by `z`.

8.     const base_type & base() const;

### `independent_bits_engine` friend functions

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

   Writes the textual representation if the generator to a `std::ostream`. The textual representation of the engine is the textual representation of the base engine.

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

   Reads the state of an ``independent_bits_engine`` from a `std::istream`.

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

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

4.     friend bool operator!=(const independent_bits_engine & lhs,
                              const independent_bits_engine & rhs);

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