![]() |
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 first_base; typedef MLCG2 second_base; typedef MLCG1::result_type result_type; // construct/copy/destruct additive_combine_engine(); explicit additive_combine_engine(result_type); template<typename SeedSeq> explicit additive_combine_engine(SeedSeq &); additive_combine_engine(typename MLCG1::result_type, typename MLCG2::result_type); template<typename It> additive_combine_engine(It &, It); // public static functions static constexpr result_type min(); static constexpr result_type max(); // public member functions void seed(); void seed(result_type); template<typename SeedSeq> void seed(SeedSeq &); void seed(typename MLCG1::result_type, typename MLCG2::result_type); template<typename It> void seed(It &, It); result_type operator()(); template<typename Iter> void generate(Iter, Iter); void discard(boost::uintmax_t); // friend functions template<typename CharT, typename Traits> friend std::basic_ostream< CharT, Traits > & operator<<(std::basic_ostream< CharT, Traits > &, const additive_combine_engine &); template<typename CharT, typename Traits> friend std::basic_istream< CharT, Traits > & operator>>(std::basic_istream< CharT, Traits > &, const additive_combine_engine &); friend bool operator==(const additive_combine_engine &, const additive_combine_engine &); friend bool operator!=(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/destructadditive_combine_engine();
Constructs an using the default constructors of the two base generators. additive_combine_engine
explicit additive_combine_engine(result_type seed);
Constructs an , using seed as the constructor argument for both base generators. additive_combine_engine
template<typename SeedSeq> explicit additive_combine_engine(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 |
additive_combine_engine(typename MLCG1::result_type seed1, typename MLCG2::result_type seed2);
Constructs an , using additive_combine_engineseed1 and seed2 as the constructor argument to the first and second base generators, respectively.
template<typename It> additive_combine_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.additive_combine_engine
Throws: std::invalid_argument if the input range is too small.
Exception Safety: Basic
additive_combine_engine public member functionsvoid seed();
Seeds an using the default seeds of the two base generators. additive_combine_engine
void seed(result_type seed);
Seeds an , using additive_combine_engineseed as the seed for both base generators.
template<typename SeedSeq> void seed(SeedSeq & seq);
Seeds an , using additive_combine_engineseq to seed both base generators.
See the warning on the corresponding constructor.
void seed(typename MLCG1::result_type seed1, typename MLCG2::result_type 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 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.additive_combine_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.
additive_combine_engine friend functionstemplate<typename CharT, typename Traits> friend std::basic_ostream< CharT, Traits > & operator<<(std::basic_ostream< CharT, Traits > & os, const additive_combine_engine & r);
Writes the state of an to a additive_combine_enginestd::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> friend std::basic_istream< CharT, Traits > & operator>>(std::basic_istream< CharT, Traits > & is, const additive_combine_engine & r);
Reads the state of an from a additive_combine_enginestd::istream.
friend bool operator==(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.
friend bool operator!=(const additive_combine_engine & lhs, const additive_combine_engine & rhs);
Returns: true iff the two additive_combine_engines will produce different sequences of values.