![]() |
Home | Libraries | People | FAQ | More |
boost::random::xor_combine_engine
// In header: <boost/random/xor_combine.hpp> template<typename URNG1, s1, typename URNG2, s2> class xor_combine_engine { public: // types typedef URNG1 ; typedef URNG2 ; typedef base1_type::result_type ; // construct/copy/destruct (); (const base1_type &, const base2_type &); (result_type); template<typename SeedSeq> (SeedSeq &); template<typename It> (It &, It); // public member functions void (); void (result_type); template<typename SeedSeq> void (SeedSeq &); template<typename It> void (It &, It); const base1_type & () ; const base2_type & () ; result_type (); template<typename Iter> void (Iter, Iter); void (boost::uintmax_t); // public static functions constexpr result_type (); constexpr result_type (); // friend functions template<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > &, const xor_combine_engine &); template<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > &, const xor_combine_engine &); bool (const xor_combine_engine &, const xor_combine_engine &); bool (const xor_combine_engine &, const xor_combine_engine &); // public data members static const bool has_fixed_range; static const int shift1; static const int shift2; };
Instantiations of xor_combine_engine
model a pseudo-random number generator . To produce its output it invokes each of the base generators, shifts their results and xors them together.
xor_combine_engine
public
construct/copy/destruct();
Constructors a
by default constructing both base generators. xor_combine_engine
(const base1_type & rng1, const base2_type & rng2);
Constructs a xor_combine
by copying two base generators.
(result_type v);
Constructs a
, seeding both base generators with xor_combine_engine
v
.
![]() |
Warning |
---|---|
The exact algorithm used by this function may change in the future. |
template<typename SeedSeq> (SeedSeq & seq);
Constructs a
, seeding both base generators with values produced by xor_combine_engine
seq
.
template<typename It> (It & first, It last);
Constructs a
, seeding both base generators with values from the iterator range [first, last) and changes first to point to the element after the last one used. If there are not enough elements in the range to seed both generators, throws xor_combine_engine
std::invalid_argument
.
xor_combine_engine
public member functionsvoid ();
Calls seed()
for both base generators.
void (result_type v);
seeds
both base generators with v
.
template<typename SeedSeq> void (SeedSeq & seq);
seeds
both base generators with values produced by seq
.
template<typename It> void (It & first, It last);
seeds both base generators with values from the iterator range [first, last) and changes first to point to the element after the last one used. If there are not enough elements in the range to seed both generators, throws std::invalid_argument
.
const base1_type & () ;
Returns the first base generator.
const base2_type & () ;
Returns the second base generator.
result_type ();
Returns the next value of the generator.
template<typename Iter> void (Iter first, Iter last);
Fills a range with random values
void (boost::uintmax_t z);
Advances the state of the generator by z
.
xor_combine_engine
public static functionsconstexpr result_type ();
Returns the smallest value that the generator can produce.
constexpr result_type ();
Returns the largest value that the generator can produce.
xor_combine_engine
friend functionstemplate<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > & os, const xor_combine_engine & s);
Writes the textual representation of the generator to a std::ostream
.
template<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > & is, const xor_combine_engine & s);
Reads the textual representation of the generator from a std::istream
.
bool (const xor_combine_engine & x, const xor_combine_engine & y);
Returns true if the two generators will produce identical sequences.
bool (const xor_combine_engine & lhs, const xor_combine_engine & rhs);
Returns true if the two generators will produce different sequences.