namespace boost {
namespace random {
template<typename RealType = double> class beta_distribution;
}
}
namespace boost {
namespace random {
template<typename IntType = int, typename RealType = double>
class binomial_distribution;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class cauchy_distribution;
}
}
namespace boost {
namespace random {
template<typename UniformRandomNumberGenerator, std::size_t p,
std::size_t r>
class discard_block_engine;
}
}
namespace boost {
namespace random {
template<typename IntType = int, typename WeightType = double>
class discrete_distribution;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class fisher_f_distribution;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class gamma_distribution;
}
}
namespace boost {
namespace random {
template<typename RealType, std::size_t bits, typename URNG>
RealType generate_canonical(URNG &);
}
}
namespace boost {
namespace random {
template<typename IntType = int, typename RealType = double>
class geometric_distribution;
}
}
namespace boost {
namespace random {
template<typename Engine, std::size_t w, typename UIntType>
class independent_bits_engine;
}
}
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;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class laplace_distribution;
}
}
BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD
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;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class normal_distribution;
}
}
namespace boost {
namespace random {
template<typename IntType = int, typename RealType = double>
class poisson_distribution;
}
}
namespace boost {
namespace random {
template<typename URNG, typename IntType = long>
class random_number_generator;
}
}
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;
}
}
namespace boost {
namespace random {
class seed_seq;
}
}
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;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class triangle_distribution;
}
}
namespace boost {
namespace random {
template<typename RealType = double> class uniform_01;
}
}
namespace boost {
namespace random {
template<typename RealType = double,
typename Cont = std::vector<RealType> >
class uniform_on_sphere;
}
}
namespace boost {
namespace random {
template<typename IntType = int> class uniform_smallint;
}
}
namespace boost {
template<typename Engine, typename Distribution> class variate_generator;
}
namespace boost {
namespace random {
template<typename RealType = double> class weibull_distribution;
}
}
namespace boost {
namespace random {
template<typename URNG1, int s1, typename URNG2, int s2>
class xor_combine_engine;
}
}