![]() |
Home | Libraries | People | FAQ | More |
boost::random::additive_combine_engine
// In header: <boost/random/additive_combine.hpp> template<typename MLCG1, typename MLCG2> class additive_combine_engine { public: // types typedef MLCG1 ; typedef MLCG2 ; typedef ; // construct/copy/destruct (); (); template<typename SeedSeq> (SeedSeq &); (typename , typename ); template<typename It> (It &, It); // public static functions constexpr (); constexpr (); // public member functions void (); void (); template<typename SeedSeq> void (SeedSeq &); void (typename , typename ); template<typename It> void (It &, It); (); template<typename Iter> void (Iter, Iter); void (boost::uintmax_t); // friend functions template<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > &, const additive_combine_engine &); template<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > &, const additive_combine_engine &); bool (const additive_combine_engine &, const additive_combine_engine &); bool (const additive_combine_engine &, const additive_combine_engine &); // public data members static const bool has_fixed_range; };
An instantiation of class template additive_combine_engine
models a pseudo-random number generator . It combines two multiplicative linear_congruential_engine number generators, i.e. those with c
= 0. It is described in
"Efficient and Portable Combined Random Number Generators", Pierre L'Ecuyer, Communications of the ACM, Vol. 31, No. 6, June 1988, pp. 742-749, 774
The template parameters MLCG1 and MLCG2 shall denote two different linear_congruential_engine number generators, each with c = 0. Each invocation returns a random number X(n) := (MLCG1(n) - MLCG2(n)) mod (m1 - 1), where m1 denotes the modulus of MLCG1.
additive_combine_engine
public
construct/copy/destruct();
Constructs an
using the default constructors of the two base generators. additive_combine_engine
( seed);
Constructs an
, using seed as the constructor argument for both base generators. additive_combine_engine
template<typename SeedSeq> (SeedSeq & seq);
Constructs an
, using seq as the constructor argument for both base generators.additive_combine_engine
![]() |
Warning |
---|---|
The semantics of this function are liable to change. A |
(typename seed1, typename seed2);
Constructs an
, using additive_combine_engine
seed1
and seed2
as the constructor argument to the first and second base generators, respectively.
template<typename It> (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.additive_combine_engine
Throws: std::invalid_argument
if the input range is too small.
Exception Safety: Basic
additive_combine_engine
public member functionsvoid ();
Seeds an
using the default seeds of the two base generators. additive_combine_engine
void ( seed);
Seeds an
, using additive_combine_engine
seed
as the seed for both base generators.
template<typename SeedSeq> void (SeedSeq & seq);
Seeds an
, using additive_combine_engine
seq
to seed both base generators.
See the warning on the corresponding constructor.
void (typename seed1, typename seed2);
Seeds an additive_combine
generator, using seed1
and seed2
as the seeds to the first and second base generators, respectively.
template<typename It> void (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.additive_combine_engine
Throws: std::invalid_argument
if the input range is too small.
Exception Safety: Basic
();
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
.
additive_combine_engine
friend functionstemplate<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > & os, const additive_combine_engine & r);
Writes the state of an
to a additive_combine_engine
std::ostream
. The textual representation of an
is the textual representation of the first base generator followed by the textual representation of the second base generator. additive_combine_engine
template<typename CharT, typename Traits> CharT, Traits > & (CharT, Traits > & is, const additive_combine_engine & r);
Reads the state of an
from a additive_combine_engine
std::istream
.
bool (const additive_combine_engine & x, const additive_combine_engine & y);
Returns: true iff the two additive_combine_engines
will produce the same sequence of values.
bool (const additive_combine_engine & lhs, const additive_combine_engine & rhs);
Returns: true iff the two additive_combine_engines
will produce different sequences of values.