Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Headers

Header <boost/random/additive_combine.hpp>
Header <boost/random/bernoulli_distribution.hpp>
Header <boost/random/beta_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/generate_canonical.hpp>
Header <boost/random/geometric_distribution.hpp>
Header <boost/random/hyperexponential_distribution.hpp>
Header <boost/random/independent_bits.hpp>
Header <boost/random/inversive_congruential.hpp>
Header <boost/random/lagged_fibonacci.hpp>
Header <boost/random/laplace_distribution.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/non_central_chi_squared_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/traits.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>
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;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class bernoulli_distribution;
  }
}
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 RealType = double> class chi_squared_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 exponential_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class extreme_value_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 RealT = double> class hyperexponential_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename Engine, std::size_t w, typename UIntType> 
      class independent_bits_engine;
  }
}
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;
  }
}
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;
  }
}
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;
  }
}
namespace boost {
  namespace random {
    template<typename UIntType, int w, int k, int q, int s> 
      class linear_feedback_shift_engine;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class lognormal_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 IntType = int, typename RealType = double> 
      class negative_binomial_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> 
      class non_central_chi_squared_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class normal_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double, typename WeightType = double> 
      class piecewise_constant_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class piecewise_linear_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename IntType = int, typename RealType = double> 
      class poisson_distribution;
  }
}
namespace boost {
  namespace random {
    class random_device;
  }
}
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 {
    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;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class student_t_distribution;
  }
}
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;
  }
}
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 {
    namespace traits {
      template<typename T> struct make_unsigned;
      template<typename T> struct make_unsigned_or_unbounded;
      template<typename T> struct is_integral;
      template<typename T> struct is_signed;
    }
  }
}
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 IntType = int> class uniform_int_distribution;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double, 
             typename Cont = std::vector<RealType> > 
      class uniform_on_sphere;
  }
}
namespace boost {
  namespace random {
    template<typename RealType = double> class uniform_real_distribution;
  }
}
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;
  }
}

PrevUpHomeNext