![]() |
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 ; typedef ; typedef ; // construct/copy/destruct (); (); template<typename SeedSeq> (); (, ); template<typename It> (, ); // public static functions (); (); // public member functions (); (); template<typename SeedSeq> (); (, ); template<typename It> (, ); (); template<typename Iter> (, ); (); // friend functions template<typename CharT, typename Traits> (, additive_combine_engine &); template<typename CharT, typename Traits> (, additive_combine_engine &); (additive_combine_engine &, additive_combine_engine &); (additive_combine_engine &, additive_combine_engine &); // public data members static 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> ( 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 |
( seed1, 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> ( first, 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 functions();
Seeds an
using the default seeds of the two base generators. additive_combine_engine
( seed);
Seeds an
, using additive_combine_engine
seed
as the seed for both base generators.
template<typename SeedSeq> ( seq);
Seeds an
, using additive_combine_engine
seq
to seed both base generators.
See the warning on the corresponding constructor.
( seed1, seed2);
Seeds an additive_combine
generator, using seed1
and seed2
as the seeds to the first and second base generators, respectively.
template<typename It> ( first, 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> ( first, last);
Fills a range with random values
( z);
Advances the state of the generator by z
.
additive_combine_engine
friend functionstemplate<typename CharT, typename Traits> ( os, 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> ( is, additive_combine_engine & r);
Reads the state of an
from a additive_combine_engine
std::istream
.
(additive_combine_engine & x, additive_combine_engine & y);
Returns: true iff the two additive_combine_engines
will produce the same sequence of values.
(additive_combine_engine & lhs, additive_combine_engine & rhs);
Returns: true iff the two additive_combine_engines
will produce different sequences of values.