Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Class template independent_bits_engine

boost::random::independent_bits_engine

Synopsis

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

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

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

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

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

  // friend functions
  template<typename CharT, typename Traits> 
    CharT, Traits > & 
    (CharT, Traits > &, 
               const independent_bits_engine &);
  template<typename CharT, typename Traits> 
    CharT, Traits > & 
    (CharT, Traits > &, 
               const independent_bits_engine &);
  bool (const independent_bits_engine &, 
                  const independent_bits_engine &);
  bool (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. ();

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

  2. ( seed);

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

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

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

  4. (const base_type & base_arg);

    Constructs an independent_bits_engine by copying base.

  5. template<typename It> (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. constexpr result_type ();

    Returns the smallest value that the generator can produce.

  2. constexpr result_type ();

    Returns the largest value that the generator can produce.

independent_bits_engine public member functions

  1. void ();

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

  2. void ( seed);

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

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

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

  4. template<typename It> void (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 ();

    Returns the next value of the generator.

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

    Fills a range with random values

  7. void (boost::uintmax_t z);

    Advances the state of the generator by z.

  8. const base_type & () ;

independent_bits_engine friend functions

  1. template<typename CharT, typename Traits> 
      CharT, Traits > & 
      (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> 
      CharT, Traits > & 
      (CharT, Traits > & is, 
                 const independent_bits_engine & r);

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

  3. bool (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. bool (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