...one of the most highly
regarded and expertly designed C++ library projects in the
world.
— Herb Sutter and Andrei
Alexandrescu, C++
Coding Standards
boost::random::independent_bits_engine
// 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; };
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/destructindependent_bits_engine();
Constructs an
using the default constructor of the base generator. independent_bits_engine
explicit independent_bits_engine(result_type seed);
Constructs an
, using seed as the constructor argument for both base generators. independent_bits_engine
template<typename SeedSeq> explicit independent_bits_engine(SeedSeq & seq);
Constructs an
, using seq as the constructor argument for the base generator. independent_bits_engine
independent_bits_engine(const base_type & base_arg);
Constructs an
by copying independent_bits_engine
base
.
template<typename It> independent_bits_engine(It & first, It last);
Contructs an
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.independent_bits_engine
Throws: std::invalid_argument
if the input range is too small.
Exception Safety: Basic
independent_bits_engine
public member functionsvoid seed();
Seeds an
using the default seed of the base generator. independent_bits_engine
void seed(result_type seed);
Seeds an
, using independent_bits_engine
seed
as the seed for the base generator.
template<typename SeedSeq> void seed(SeedSeq & seq);
Seeds an
, using independent_bits_engine
seq
to seed the base generator.
template<typename It> void seed(It & first, It last);
Seeds an
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.independent_bits_engine
Throws: std::invalid_argument
if the input range is too small.
Exception Safety: Basic
result_type operator()();
Returns the next value of the generator.
template<typename Iter> void generate(Iter first, Iter last);
Fills a range with random values
void discard(boost::uintmax_t z);
Advances the state of the generator by z
.
const base_type & base() const;
independent_bits_engine
friend functionstemplate<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.
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
from a independent_bits_engine
std::istream
.
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.
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.