Reference

+ Random numbers are required in a number of different problem domains, such + as +

+ numerics (simulation, Monte-Carlo integration) +
+ games (non-deterministic enemy behavior) +
+ security (key generation) +
+ testing (random coverage in white-box tests) +

+ The Boost Random Number Generator Library provides a framework for random + number generators with well-defined properties so that the generators can + be used in the demanding numerics and security domains. For a general introduction + to random numbers in numerics, see +

+ "Numerical Recipes in C: The art of scientific computing", + William H. Press, Saul A. Teukolsky, William A. Vetterling, Brian P. + Flannery, 2nd ed., 1992, pp. 274-328 +

+ Depending on the requirements of the problem domain, different variations + of random number generators are appropriate: +

+ non-deterministic random number generator +
+ pseudo-random number generator +
+ quasi-random number generator +

+ All variations have some properties in common, the concepts (in the STL + sense) is called UniformRandomNumberGenerator. + This concept will be defined in a subsequent section. +

+ The goals for this library are the following: +

+ allow easy integration of third-party random-number generators +
+ provide easy-to-use front-end classes which model popular distributions +
+ provide maximum efficiency +

+Uniform + Random Number Generator +

+ A uniform random number generator provides a sequence of random numbers + uniformly distributed on a given range. The range can be compile-time fixed + or available (only) after run-time construction of the object. +

+ The tight lower bound of some (finite) set S is the + (unique) member l in S, so that for all v in S, l <= v holds. Likewise, + the tight upper bound of some (finite) set S is the + (unique) member u in S, so that for all v in S, v <= u holds. +

+ In the following table, X denotes a number generator class returning objects + of type T, and v is a const value of X. +

Table 21.1. UniformRandomNumberGenerator requirements

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + expression + +	+ + return type + +	+ + pre/post-condition + +
+ + `X::result_type` + +	+ + `T` + +	+ + `std::numeric_limits<T>::is_specialized` is `true`, `T` + is LessThanComparable + +
+ + `u.operator()()` + +	+ + `T` + +	+ + - + +
+ + `v.min()` + +	+ + `T` + +	+ + tight lower bound on the set of all values returned by `operator()`. + The return value of this function shall not change during the + lifetime of the object. + +
+ + `v.max()` + +	+ + `T` + +	+ + if `std::numeric_limits<T>::is_integer`, tight upper bound + on the set of all values returned by `operator()`, otherwise, the smallest representable + number larger than the tight upper bound on the set of all values + returned by `operator()`. In any case, the return value + of this function shall not change during the lifetime of the + object. + +

+ The member functions min, + max, and operator() + shall have amortized constant time complexity. +

+ + + + + +

Note

+ For integer generators (i.e. integer T), + the generated values x + fulfill min() + <= x + <= max(), for non-integer generators (i.e. non-integer + T), the generated values + x fulfill min() <= x < max(). +

+ Rationale: The range description with min and max serves two purposes. + First, it allows scaling of the values to some canonical range, such + as [0..1). Second, it describes the significant bits of the values, which + may be relevant for further processing. +

+ The range is a closed interval [min,max] for integers, because the underlying + type may not be able to represent the half-open interval [min,max+1). + It is a half-open interval [min, max) for non-integers, because this + is much more practical for borderline cases of continuous distributions. +

+ + + + + +

Note

+ The UniformRandomNumberGenerator + concept does not require operator()(long) and thus it does not fulfill the RandomNumberGenerator (std:25.2.11 + [lib.alg.random.shuffle]) requirements. Use the random_number_generator + adapter for that. +

+ Rationale: operator()(long) + is not provided, because mapping the output of some generator with integer + range to a different integer range is not trivial. +

+Non-deterministic + Uniform Random Number Generator +

+ A non-deterministic uniform random number generator is a UniformRandomNumberGenerator + that is based on some stochastic process. Thus, it provides a sequence + of truly-random numbers. Examples for such processes are nuclear decay, + noise of a Zehner diode, tunneling of quantum particles, rolling a die, + drawing from an urn, and tossing a coin. Depending on the environment, + inter-arrival times of network packets or keyboard events may be close + approximations of stochastic processes. +

+ The class random_device + is a model for a non-deterministic random number generator. +

+ + + + + +

Note

+ This type of random-number generator is useful for security applications, + where it is important to prevent an outside attacker from guessing the + numbers and thus obtaining your encryption or authentication key. Thus, + models of this concept should be cautious not to leak any information, + to the extent possible by the environment. For example, it might be advisable + to explicitly clear any temporary storage as soon as it is no longer + needed. +

+Pseudo-Random + Number Generator +

+ A pseudo-random number generator is a UniformRandomNumberGenerator + which provides a deterministic sequence of pseudo-random numbers, based + on some algorithm and internal state. Linear + congruential and inversive + congruential generators are examples of such pseudo-random + number generators. Often, these generators are very sensitive to + their parameters. In order to prevent wrong implementations from being + used, an external testsuite should check that the generated sequence and + the validation value provided do indeed match. +

+ Donald E. Knuth gives an extensive overview on pseudo-random number generation + in his book "The Art of Computer Programming, Vol. 2, 3rd edition, + Addison-Wesley, 1997". The descriptions for the specific generators + contain additional references. +

+ + + + + +

	Note
	+ Because the state of a pseudo-random number generator is necessarily + finite, the sequence of numbers returned by the generator will loop eventually. +

+ In addition to the UniformRandomNumberGenerator + requirements, a pseudo-random number generator has some additional requirements. + In the following table, X + denotes a pseudo-random number generator class returning objects of type + T, x + is a value of T, u is a value of X, + and v is a const value + of X. +

Table 21.2. PseudoRandomNumberGenerator requirements

+++++ + + + + + + + + + + + + + + + + + + + + + + +

+ + expression + +	+ + return type + +	+ + pre/post-condition + +
+ + `X()` + +	+ + - + +	+ + creates a generator in some implementation-defined state. Note: + Several generators thusly created may possibly produce dependent + or identical sequences of random numbers. + +
+ + `X(...)` + +	+ + - + +	+ + creates a generator with user-provided state; the implementation + shall specify the constructor argument(s) + +
+ + `u.seed(...)` + +	+ + `void` + +	+ + sets the current state according to the argument(s); at least + functions with the same signature as the non-default constructor(s) + shall be provided. + +

+ + + + + +

	Note
	+ The seed member function is similar to the assign member function in + STL containers. However, the naming did not seem appropriate. +

+ Classes which model a pseudo-random number generator shall also model + EqualityComparable, + i.e. implement operator==. + Two pseudo-random number generators are defined to be equivalent + if they both return an identical sequence of numbers starting from a given + state. +

+ Classes which model a pseudo-random number generator should also model + the Streamable concept, i.e. implement operator<< and operator>>. If so, operator<< writes all current state of the + pseudo-random number generator to the given ostream + so that operator>> + can restore the state at a later time. The state shall be written in a + platform-independent manner, but it is assumed that the locales + used for writing and reading be the same. The pseudo-random number generator + with the restored state and the original at the just-written state shall + be equivalent. +

+ Classes which model a pseudo-random number generator should also model + the CopyConstructible + and Assignable concepts. + However, note that the sequences of the original and the copy are strongly + correlated (in fact, they are identical), which may make them unsuitable + for some problem domains. Thus, copying pseudo-random number generators + is discouraged; they should always be passed by (non-const) reference. +

+ The classes rand48, + minstd_rand, and + mt19937 are models + for a pseudo-random number generator. +

+ + + + + +

Note

+ This type of random-number generator is useful for numerics, games and + testing. The non-zero arguments constructor(s) and the seed() + member function(s) allow for a user-provided state to be installed in + the generator. This is useful for debugging Monte-Carlo algorithms and + analyzing particular test scenarios. The Streamable concept allows to + save/restore the state of the generator, for example to re-run a test + suite at a later time. +

+Random + Distribution +

+ A random distribution produces random numbers distributed according to + some distribution, given uniformly distributed random values as input. + In the following table, X + denotes a random distribution class returning objects of type T, u + is a value of X, x is a (possibly const) value of X, and e + is an lvalue of an arbitrary type that meets the requirements of a UniformRandomNumberGenerator, + returning values of type U. +

Table 21.3. Random distribution requirements (in addition to CopyConstructible, + and Assignable)

++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + expression + +	+ + return type + +	+ + pre/post-condition + +	+ + complexity + +
+ + `X::result_type` + +	+ + `T` + +	+ + - + +	+ + compile-time + +
+ + `u.reset()` + +	+ + `void` + +	+ + subsequent uses of `u` + do not depend on values produced by any engine prior to invoking + `reset`. + +	+ + constant + +
+ + `u(e)` + +	+ + `T` + +	+ + the sequence of numbers returned by successive invocations with + the same object `e` + is randomly distributed with some probability density function + `p(x)` + +	+ + amortized constant number of invocations of `e` + +
+ + `os << + x` + +	+ + `std::ostream&` + +	+ + writes a textual representation for the parameters and additional + internal data of the distribution `x` + to `os`. post: + The `os.fmtflags` and fill character + are unchanged. + +	+ + O(size of state) + +
+ + `is >> + u` + +	+ + `std::istream&` + +	+ + restores the parameters and additional internal data of the distribution + `u`. pre: `is` provides a textual representation + that was previously written by `operator<<` post: The `is.fmtflags` are unchanged. + +	+ + O(size of state) + +

+ Additional requirements: The sequence of numbers produced by repeated invocations + of x(e) does + not change whether or not os + << x + is invoked between any of the invocations x(e). + If a textual representation is written using os + << x + and that representation is restored into the same or a different object + y of the same type using + is >> + y, repeated invocations of y(e) produce the same sequence of random numbers + as would repeated invocations of x(e). +

+Generators +

+ This library provides several pseudo-random + number generators. The quality of a pseudo + random number generator crucially depends on both the algorithm and + its parameters. This library implements the algorithms as class templates + with template value parameters, hidden in namespace + boost::random. Any particular choice of parameters + is represented as the appropriately specializing typedef + in namespace boost. +

+ Pseudo-random + number generators should not be constructed (initialized) frequently + during program execution, for two reasons. First, initialization requires + full initialization of the internal state of the generator. Thus, generators + with a lot of internal state (see below) are costly to initialize. Second, + initialization always requires some value used as a "seed" for + the generated sequence. It is usually difficult to obtain several good seed + values. For example, one method to obtain a seed is to determine the current + time at the highest resolution available, e.g. microseconds or nanoseconds. + When the pseudo-random + number generator is initialized again with the then-current time as + the seed, it is likely that this is at a near-constant (non-random) distance + from the time given as the seed for first initialization. The distance could + even be zero if the resolution of the clock is low, thus the generator re-iterates + the same sequence of random numbers. For some applications, this is inappropriate. +

+ Note that all pseudo-random + number generators described below are CopyConstructible + and Assignable. Copying + or assigning a generator will copy all its internal state, so the original + and the copy will generate the identical sequence of random numbers. Often, + such behavior is not wanted. In particular, beware of the algorithms from + the standard library such as std::generate. + They take a functor argument by value, thereby invoking the copy constructor + when called. +

+ The following table gives an overview of some characteristics of the generators. + The cycle length is a rough estimate of the quality of the generator; the + approximate relative speed is a performance measure, higher numbers mean + faster random number generation. +

Table 21.4. generators

+++++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + generator + +	+ + length of cycle + +	+ + approx. memory requirements + +	+ + approx. speed compared to fastest + +	+ + comment + +
+ + `minstd_rand0` + +	+ + 2³¹-2 + +	+ + `sizeof(int32_t)` + +	+ + 16% + +	+ + - + +
+ + `minstd_rand` + +	+ + 2³¹-2 + +	+ + `sizeof(int32_t)` + +	+ + 16% + +	+ + - + +
+ + `rand48` + +	+ + 2⁴⁸-1 + +	+ + `sizeof(uint64_t)` + +	+ + 64% + +	+ + - + +
+ + `ecuyer1988` + +	+ + approx. 2⁶¹ + +	+ + `2*sizeof(int32_t)` + +	+ + 7% + +	+ + - + +
+ + `knuth_b` + +	+ + ? + +	+ + `257*sizeof(uint32_t)` + +	+ + 12% + +	+ + - + +
+ + `kreutzer1986` + +	+ + ? + +	+ + `1368*sizeof(uint32_t)` + +	+ + 37% + +	+ + - + +
+ + `taus88` + +	+ + ~2⁸⁸ + +	+ + `3*sizeof(uint32_t)` + +	+ + 100% + +	+ + - + +
+ + `hellekalek1995` + +	+ + 2³¹-1 + +	+ + `sizeof(int32_t)` + +	+ + 2% + +	+ + good uniform distribution in several dimensions + +
+ + `mt11213b` + +	+ + 2¹¹²¹³-1 + +	+ + `352*sizeof(uint32_t)` + +	+ + 100% + +	+ + good uniform distribution in up to 350 dimensions + +
+ + `mt19937` + +	+ + 2¹⁹⁹³⁷-1 + +	+ + `625*sizeof(uint32_t)` + +	+ + 93% + +	+ + good uniform distribution in up to 623 dimensions + +
+ + `mt19937_64` + +	+ + 2¹⁹⁹³⁷-1 + +	+ + `312*sizeof(uint64_t)` + +	+ + 38% + +	+ + good uniform distribution in up to 311 dimensions + +
+ + `lagged_fibonacci607` + +	+ + ~2³²⁰⁰⁰ + +	+ + `607*sizeof(double)` + +	+ + 59% + +	+ + - + +
+ + `lagged_fibonacci1279` + +	+ + ~2⁶⁷⁰⁰⁰ + +	+ + `1279*sizeof(double)` + +	+ + 59% + +	+ + - + +
+ + `lagged_fibonacci2281` + +	+ + ~2¹²⁰⁰⁰⁰ + +	+ + `2281*sizeof(double)` + +	+ + 61% + +	+ + - + +
+ + `lagged_fibonacci3217` + +	+ + ~2¹⁷⁰⁰⁰⁰ + +	+ + `3217*sizeof(double)` + +	+ + 62% + +	+ + - + +
+ + `lagged_fibonacci4423` + +	+ + ~2²³⁰⁰⁰⁰ + +	+ + `4423*sizeof(double)` + +	+ + 59% + +	+ + - + +
+ + `lagged_fibonacci9689` + +	+ + ~2⁵¹⁰⁰⁰⁰ + +	+ + `9689*sizeof(double)` + +	+ + 61% + +	+ + - + +
+ + `lagged_fibonacci19937` + +	+ + ~2^1050000 + +	+ + `19937*sizeof(double)` + +	+ + 59% + +	+ + - + +
+ + `lagged_fibonacci23209` + +	+ + ~2^1200000 + +	+ + `23209*sizeof(double)` + +	+ + 61% + +	+ + - + +
+ + `lagged_fibonacci44497` + +	+ + ~2^2300000 + +	+ + `44497*sizeof(double)` + +	+ + 59% + +	+ + - + +
+ + `ranlux3` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(int)` + +	+ + 5% + +	+ + - + +
+ + `ranlux4` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(int)` + +	+ + 3% + +	+ + - + +
+ + `ranlux64_3` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(int64_t)` + +	+ + 5% + +	+ + - + +
+ + `ranlux64_4` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(int64_t)` + +	+ + 3% + +	+ + - + +
+ + `ranlux3_01` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(float)` + +	+ + 5% + +	+ + - + +
+ + `ranlux4_01` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(float)` + +	+ + 3% + +	+ + - + +
+ + `ranlux64_3_01` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(double)` + +	+ + 5% + +	+ + - + +
+ + `ranlux64_4_01` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(double)` + +	+ + 3% + +	+ + - + +
+ + `ranlux24` + +	+ + ~10¹⁷¹ + +	+ + `24*sizeof(uint32_t)` + +	+ + 5% + +	+ + - + +
+ + `ranlux48` + +	+ + ~10¹⁷¹ + +	+ + `12*sizeof(uint64_t)` + +	+ + 3% + +	+ + - + +

+ As observable from the table, there is generally a quality/performance/memory + trade-off to be decided upon when choosing a random-number generator. The + multitude of generators provided in this library allows the application programmer + to optimize the trade-off with regard to his application domain. Additionally, + employing several fundamentally different random number generators for a + given application of Monte Carlo simulation will improve the confidence in + the results. +

+ If the names of the generators don't ring any bell and you have no idea which + generator to use, it is reasonable to employ mt19937 + for a start: It is fast and has acceptable quality. +

+ + + + + +

	Note
	+ These random number generators are not intended for use in applications + where non-deterministic random numbers are required. See `random_device` + for a choice of (hopefully) non-deterministic random number generators. +

+Distributions +

+ In addition to the random + number generators, this library provides distribution functions which + map one distribution (often a uniform distribution provided by some generator) + to another. +

+ Usually, there are several possible implementations of any given mapping. + Often, there is a choice between using more space, more invocations of the + underlying source of random numbers, or more time-consuming arithmetic such + as trigonometric functions. This interface description does not mandate any + specific implementation. However, implementations which cannot reach certain + values of the specified distribution or otherwise do not converge statistically + to it are not acceptable. +

Table 21.5. Uniform Distributions

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + distribution + +	+ + explanation + +	+ + example + +
+ + `uniform_smallint` + +	+ + discrete uniform distribution on a small set of integers (much + smaller than the range of the underlying generator) + +	+ + drawing from an urn + +
+ + `uniform_int_distribution` + +	+ + discrete uniform distribution on a set of integers; the underlying + generator may be called several times to gather enough randomness + for the output + +	+ + drawing from an urn + +
+ + `uniform_01` + +	+ + continuous uniform distribution on the range [0,1); important basis + for other distributions + +	+ + - + +
+ + `uniform_real_distribution` + +	+ + continuous uniform distribution on some range [min, max) of real + numbers + +	+ + for the range [0, 2pi): randomly dropping a stick and measuring + its angle in radians (assuming the angle is uniformly distributed) + +

Table 21.6. Bernoulli Distributions

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + distribution + +	+ + explanation + +	+ + example + +
+ + `bernoulli_distribution` + +	+ + Bernoulli experiment: discrete boolean valued distribution with + configurable probability + +	+ + tossing a coin (p=0.5) + +
+ + `binomial_distribution` + +	+ + counts outcomes of repeated Bernoulli experiments + +	+ + tossing a coin 20 times and counting how many front sides are shown + +
+ + `geometric_distribution` + +	+ + measures distance between outcomes of repeated Bernoulli experiments + +	+ + throwing a die several times and counting the number of tries until + a "6" appears for the first time + +
+ + `negative_binomial_distribution` + +	+ + Counts the number of failures of repeated Bernoulli experiments + required to get some constant number of successes. + +	+ + flipping a coin and counting the number of heads that show up before + we get 3 tails + +

Table 21.7. Poisson Distributions

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + distribution + +	+ + explanation + +	+ + example + +
+ + `poisson_distribution` + +	+ + poisson distribution + +	+ + counting the number of alpha particles emitted by radioactive matter + in a fixed period of time + +
+ + `exponential_distribution` + +	+ + exponential distribution + +	+ + measuring the inter-arrival time of alpha particles emitted by + radioactive matter + +
+ + `gamma_distribution` + +	+ + gamma distribution + +	+ + - + +
+ + `weibull_distribution` + +	+ + weibull distribution + +	+ + - + +
+ + `extreme_value_distribution` + +	+ + extreme value distribution + +	+ + - + +

Table 21.8. Normal Distributions

+++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ + distribution + +	+ + explanation + +	+ + example + +
+ + `normal_distribution` + +	+ + counts outcomes of (infinitely) repeated Bernoulli experiments + +	+ + tossing a coin 10000 times and counting how many front sides are + shown + +
+ + `lognormal_distribution` + +	+ + lognormal distribution (sometimes used in simulations) + +	+ + measuring the job completion time of an assembly line worker + +
+ + `chi_squared_distribution` + +	+ + chi-squared distribution + +	+ + - + +
+ + `cauchy_distribution` + +	+ + Cauchy distribution + +	+ + - + +
+ + `fisher_f_distribution` + +	+ + Fisher F distribution + +	+ + - + +
+ + `student_t_distribution` + +	+ + Student t distribution + +	+ + - + +

Table 21.9. Sampling Distributions

+++++ + + + + + + + + + + + + + + + + + + + + + + +

+ + distribution + +	+ + explanation + +	+ + example + +
+ + `discrete_distribution` + +	+ + discrete distribution with specific probabilities + +	+ + rolling an unfair die + +
+ + `piecewise_constant_distribution` + +	+ + - + +	+ + - + +
+ + `piecewise_linear_distribution` + +	+ + - + +	+ + - + +

Table 21.10. Miscellaneous Distributions

+++++ + + + + + + + + + + + + + + + + + +

+ + distribution + +	+ + explanation + +	+ + example + +
+ + `triangle_distribution` + +	+ + triangle distribution + +	+ + - + +
+ + `uniform_on_sphere` + +	+ + uniform distribution on a unit sphere of arbitrary dimension + +	+ + choosing a random point on Earth (assumed to be a sphere) where + to spend the next vacations + +

+
+

+Headers

Header <boost/random/additive_combine.hpp>
Header <boost/random/bernoulli_distribution.hpp>
Header <boost/random/binomial_distribution.hpp>
Header <boost/random/cauchy_distribution.hpp>
Header <boost/random/chi_squared_distribution.hpp>
Header <boost/random/discard_block.hpp>
Header <boost/random/discrete_distribution.hpp>
Header <boost/random/exponential_distribution.hpp>
Header <boost/random/extreme_value_distribution.hpp>
Header <boost/random/fisher_f_distribution.hpp>
Header <boost/random/gamma_distribution.hpp>
Header <boost/random/geometric_distribution.hpp>
Header <boost/random/independent_bits.hpp>
Header <boost/random/inversive_congruential.hpp>
Header <boost/random/lagged_fibonacci.hpp>
Header <boost/random/linear_congruential.hpp>
Header <boost/random/linear_feedback_shift.hpp>
Header <boost/random/lognormal_distribution.hpp>
Header <boost/random/mersenne_twister.hpp>
Header <boost/random/negative_binomial_distribution.hpp>
Header <boost/random/normal_distribution.hpp>
Header <boost/random/piecewise_constant_distribution.hpp>
Header <boost/random/piecewise_linear_distribution.hpp>
Header <boost/random/poisson_distribution.hpp>
Header <boost/random/random_device.hpp>
Header <boost/random/random_number_generator.hpp>
Header <boost/random/ranlux.hpp>
Header <boost/random/seed_seq.hpp>
Header <boost/random/shuffle_order.hpp>
Header <boost/random/student_t_distribution.hpp>
Header <boost/random/subtract_with_carry.hpp>
Header <boost/random/taus88.hpp>
Header <boost/random/triangle_distribution.hpp>
Header <boost/random/uniform_01.hpp>
Header <boost/random/uniform_int_distribution.hpp>
Header <boost/random/uniform_on_sphere.hpp>
Header <boost/random/uniform_real_distribution.hpp>
Header <boost/random/uniform_smallint.hpp>
Header <boost/random/variate_generator.hpp>
Header <boost/random/weibull_distribution.hpp>
Header <boost/random/xor_combine.hpp>

+Header <boost/random/additive_combine.hpp>

namespace boost {
+  namespace random {
+    template<typename MLCG1, typename MLCG2> class additive_combine_engine;
+    typedef additive_combine_engine< linear_congruential_engine< uint32_t, 40014, 0, 2147483563 >, linear_congruential_engine< uint32_t, 40692, 0, 2147483399 >> ecuyer1988;
+  }
+}

+Header <boost/random/bernoulli_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class bernoulli_distribution;
+  }
+}

+Header <boost/random/binomial_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int, typename RealType = double> 
+      class binomial_distribution;
+  }
+}

+Header <boost/random/cauchy_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class cauchy_distribution;
+  }
+}

+Header <boost/random/chi_squared_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class chi_squared_distribution;
+  }
+}

+Header <boost/random/discard_block.hpp>

namespace boost {
+  namespace random {
+    template<typename UniformRandomNumberGenerator, std::size_t p, 
+             std::size_t r> 
+      class discard_block_engine;
+  }
+}

+Header <boost/random/discrete_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int, typename WeightType = double> 
+      class discrete_distribution;
+  }
+}

+Header <boost/random/exponential_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class exponential_distribution;
+  }
+}

+Header <boost/random/extreme_value_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class extreme_value_distribution;
+  }
+}

+Header <boost/random/fisher_f_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class fisher_f_distribution;
+  }
+}

+Header <boost/random/gamma_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class gamma_distribution;
+  }
+}

+Header <boost/random/geometric_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int, typename RealType = double> 
+      class geometric_distribution;
+  }
+}

+Header <boost/random/independent_bits.hpp>

namespace boost {
+  namespace random {
+    template<typename Engine, std::size_t w, typename UIntType> 
+      class independent_bits_engine;
+  }
+}

+Header <boost/random/inversive_congruential.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType, IntType a, IntType b, IntType p> 
+      class inversive_congruential_engine;
+    typedef inversive_congruential_engine< uint32_t, 9102, 2147483647-36884165, 2147483647 > hellekalek1995;
+  }
+}

+Header <boost/random/lagged_fibonacci.hpp>

namespace boost {
+  namespace random {
+    template<typename UIntType, int w, unsigned int p, unsigned int q> 
+      class lagged_fibonacci_engine;
+    template<typename RealType, int w, unsigned int p, unsigned int q> 
+      class lagged_fibonacci_01_engine;
+    typedef lagged_fibonacci_01_engine< double, 48, 607, 273 > lagged_fibonacci607;
+    typedef lagged_fibonacci_01_engine< double, 48, 1279, 418 > lagged_fibonacci1279;
+    typedef lagged_fibonacci_01_engine< double, 48, 2281, 1252 > lagged_fibonacci2281;
+    typedef lagged_fibonacci_01_engine< double, 48, 3217, 576 > lagged_fibonacci3217;
+    typedef lagged_fibonacci_01_engine< double, 48, 4423, 2098 > lagged_fibonacci4423;
+    typedef lagged_fibonacci_01_engine< double, 48, 9689, 5502 > lagged_fibonacci9689;
+    typedef lagged_fibonacci_01_engine< double, 48, 19937, 9842 > lagged_fibonacci19937;
+    typedef lagged_fibonacci_01_engine< double, 48, 23209, 13470 > lagged_fibonacci23209;
+    typedef lagged_fibonacci_01_engine< double, 48, 44497, 21034 > lagged_fibonacci44497;
+  }
+}

+Header <boost/random/linear_congruential.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType, IntType a, IntType c, IntType m> 
+      class linear_congruential_engine;
+    class rand48;
+    typedef linear_congruential_engine< uint32_t, 16807, 0, 2147483647 > minstd_rand0;
+    typedef linear_congruential_engine< uint32_t, 48271, 0, 2147483647 > minstd_rand;
+  }
+}

+Header <boost/random/linear_feedback_shift.hpp>

namespace boost {
+  namespace random {
+    template<typename UIntType, int w, int k, int q, int s> 
+      class linear_feedback_shift_engine;
+  }
+}

+Header <boost/random/lognormal_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class lognormal_distribution;
+  }
+}

+Header <boost/random/mersenne_twister.hpp>

namespace boost {
+  namespace random {
+    template<typename UIntType, std::size_t w, std::size_t n, std::size_t m, 
+             std::size_t r, UIntType a, std::size_t u, UIntType d, 
+             std::size_t s, UIntType b, std::size_t t, UIntType c, 
+             std::size_t l, UIntType f> 
+      class mersenne_twister_engine;
+    typedef mersenne_twister_engine< uint32_t, 32, 351, 175, 19, 0xccab8ee7, 11, 0xffffffff, 7, 0x31b6ab00, 15, 0xffe50000, 17, 1812433253 > mt11213b;
+    typedef mersenne_twister_engine< uint32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253 > mt19937;
+    typedef mersenne_twister_engine< uint64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ull, 29, 0x5555555555555555ull, 17, 0x71d67fffeda60000ull, 37, 0xfff7eee000000000ull, 43, 6364136223846793005ull > mt19937_64;
+  }
+}

+Header <boost/random/negative_binomial_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int, typename RealType = double> 
+      class negative_binomial_distribution;
+  }
+}

+Header <boost/random/normal_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class normal_distribution;
+  }
+}

+Header <boost/random/piecewise_constant_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double, typename WeightType = double> 
+      class piecewise_constant_distribution;
+  }
+}

+Header <boost/random/piecewise_linear_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class piecewise_linear_distribution;
+  }
+}

+Header <boost/random/poisson_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int, typename RealType = double> 
+      class poisson_distribution;
+  }
+}

+Header <boost/random/random_device.hpp>

namespace boost {
+  namespace random {
+    class random_device;
+  }
+}

+Header <boost/random/random_number_generator.hpp>

namespace boost {
+  namespace random {
+    template<typename URNG, typename IntType = long> 
+      class random_number_generator;
+  }
+}

+Header <boost/random/ranlux.hpp>

namespace boost {
+  namespace random {
+    typedef subtract_with_carry_engine< uint32_t, 24, 10, 24 > ranlux_base;
+    typedef subtract_with_carry_01_engine< float, 24, 10, 24 > ranlux_base_01;
+    typedef subtract_with_carry_01_engine< double, 48, 10, 24 > ranlux64_base_01;
+    typedef discard_block_engine< ranlux_base, 223, 24 > ranlux3;
+    typedef discard_block_engine< ranlux_base, 389, 24 > ranlux4;
+    typedef discard_block_engine< ranlux_base_01, 223, 24 > ranlux3_01;
+    typedef discard_block_engine< ranlux_base_01, 389, 24 > ranlux4_01;
+    typedef discard_block_engine< ranlux64_base_01, 223, 24 > ranlux64_3_01;
+    typedef discard_block_engine< ranlux64_base_01, 389, 24 > ranlux64_4_01;
+    typedef subtract_with_carry_engine< uint64_t, 48, 10, 24 > ranlux64_base;
+    typedef discard_block_engine< ranlux64_base, 223, 24 > ranlux64_3;
+    typedef discard_block_engine< ranlux64_base, 389, 24 > ranlux64_4;
+    typedef subtract_with_carry_engine< uint32_t, 24, 10, 24 > ranlux24_base;
+    typedef subtract_with_carry_engine< uint64_t, 48, 5, 12 > ranlux48_base;
+    typedef discard_block_engine< ranlux24_base, 223, 23 > ranlux24;
+    typedef discard_block_engine< ranlux48_base, 389, 11 > ranlux48;
+  }
+}

+Header <boost/random/seed_seq.hpp>

namespace boost {
+  namespace random {
+    class seed_seq;
+  }
+}

+Header <boost/random/shuffle_order.hpp>

namespace boost {
+  namespace random {
+    template<typename UniformRandomNumberGenerator, std::size_t k> 
+      class shuffle_order_engine;
+    typedef shuffle_order_engine< linear_congruential_engine< uint32_t, 1366, 150889, 714025 >, 97 > kreutzer1986;
+    typedef shuffle_order_engine< minstd_rand0, 256 > knuth_b;
+  }
+}

+Header <boost/random/student_t_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class student_t_distribution;
+  }
+}

+Header <boost/random/subtract_with_carry.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType, std::size_t w, std::size_t s, std::size_t r> 
+      class subtract_with_carry_engine;
+    template<typename RealType, std::size_t w, std::size_t s, std::size_t r> 
+      class subtract_with_carry_01_engine;
+  }
+}

+Header <boost/random/taus88.hpp>

namespace boost {
+  namespace random {
+    typedef xor_combine_engine< xor_combine_engine< linear_feedback_shift_engine< uint32_t, 32, 31, 13, 12 >, 0, linear_feedback_shift_engine< uint32_t, 32, 29, 2, 4 >, 0 >, 0, linear_feedback_shift_engine< uint32_t, 32, 28, 3, 17 >, 0 > taus88;
+  }
+}

+Header <boost/random/triangle_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class triangle_distribution;
+  }
+}

+Header <boost/random/uniform_01.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class uniform_01;
+  }
+}

+Header <boost/random/uniform_int_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int> class uniform_int_distribution;
+  }
+}

+Header <boost/random/uniform_on_sphere.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double, 
+             typename Cont = std::vector<RealType> > 
+      class uniform_on_sphere;
+  }
+}

+Header <boost/random/uniform_real_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class uniform_real_distribution;
+  }
+}

+Header <boost/random/uniform_smallint.hpp>

namespace boost {
+  namespace random {
+    template<typename IntType = int> class uniform_smallint;
+  }
+}

+Header <boost/random/variate_generator.hpp>

namespace boost {
+  template<typename Engine, typename Distribution> class variate_generator;
+}

+Header <boost/random/weibull_distribution.hpp>

namespace boost {
+  namespace random {
+    template<typename RealType = double> class weibull_distribution;
+  }
+}

+Header <boost/random/xor_combine.hpp>

namespace boost {
+  namespace random {
+    template<typename URNG1, int s1, typename URNG2, int s2> 
+      class xor_combine_engine;
+  }
+}

+Reference +

+Concepts +

+Introduction +

+Uniform + Random Number Generator +

+Non-deterministic + Uniform Random Number Generator +

+Pseudo-Random + Number Generator +

+Random + Distribution +

+Generators +

+Distributions +

+Headers

+Header <boost/random/additive_combine.hpp>

+Header <boost/random/bernoulli_distribution.hpp>

+Header <boost/random/binomial_distribution.hpp>

+Header <boost/random/cauchy_distribution.hpp>

+Header <boost/random/chi_squared_distribution.hpp>

+Header <boost/random/discard_block.hpp>

+Header <boost/random/discrete_distribution.hpp>

+Header <boost/random/exponential_distribution.hpp>

+Header <boost/random/extreme_value_distribution.hpp>

+Header <boost/random/fisher_f_distribution.hpp>

+Header <boost/random/gamma_distribution.hpp>

+Header <boost/random/geometric_distribution.hpp>

+Header <boost/random/independent_bits.hpp>

+Header <boost/random/inversive_congruential.hpp>

+Header <boost/random/lagged_fibonacci.hpp>

+Header <boost/random/linear_congruential.hpp>

+Header <boost/random/linear_feedback_shift.hpp>

+Header <boost/random/lognormal_distribution.hpp>

+Header <boost/random/mersenne_twister.hpp>

+Header <boost/random/negative_binomial_distribution.hpp>

+Header <boost/random/normal_distribution.hpp>

+Header <boost/random/piecewise_constant_distribution.hpp>

+Header <boost/random/piecewise_linear_distribution.hpp>

+Header <boost/random/poisson_distribution.hpp>

+Header <boost/random/random_device.hpp>

+Header <boost/random/random_number_generator.hpp>

+Header <boost/random/ranlux.hpp>

+Header <boost/random/seed_seq.hpp>

+Header <boost/random/shuffle_order.hpp>

+Header <boost/random/student_t_distribution.hpp>

+Header <boost/random/subtract_with_carry.hpp>

+Header <boost/random/taus88.hpp>

+Header <boost/random/triangle_distribution.hpp>

+Header <boost/random/uniform_01.hpp>

+Header <boost/random/uniform_int_distribution.hpp>

+Header <boost/random/uniform_on_sphere.hpp>

+Header <boost/random/uniform_real_distribution.hpp>

+Header <boost/random/uniform_smallint.hpp>

+Header <boost/random/variate_generator.hpp>

+Header <boost/random/weibull_distribution.hpp>

+Header <boost/random/xor_combine.hpp>