Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.
PrevUpHomeNext

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.


PrevUpHomeNext