# Standard library header <random> (C++11)

From cppreference.com
< cpp‎ | header

This header is part of the pseudo-random number generation library.

### Includes
<initializer_list> (C++11) | std::initializer_list class template
### Concepts
##### Uniform random bit generator requirements
uniform_random_bit_generator (C++20) | specifies that a type qualifies as a uniform random bit generator (concept)
### Classes
##### Random number engines
linear_congruential_engine (C++11) | implements linear congruential algorithm (class template)
mersenne_twister_engine (C++11) | implements Mersenne twister algorithm (class template)
subtract_with_carry_engine (C++11) | implements a subtract-with-carry (lagged Fibonacci) algorithm (class template)
##### Random number engine adaptors
discard_block_engine (C++11) | discards some output of a random number engine (class template)
independent_bits_engine (C++11) | packs the output of a random number engine into blocks of a specified number of bits (class template)
shuffle_order_engine (C++11) | delivers the output of a random number engine in a different order (class template)
##### Predefined generators
`minstd_rand0` (C++11) | std::linear_congruential_engine<std::uint_fast32_t, 16807, 0, 2147483647> Discovered in 1969 by Lewis, Goodman and Miller, adopted as "Minimal standard" in 1988 by Park and Miller
`minstd_rand` (C++11) | std::linear_congruential_engine<std::uint_fast32_t, 48271, 0, 2147483647> Newer "Minimum standard", recommended by Park, Miller, and Stockmeyer in 1993
`mt19937`(C++11) | std::mersenne_twister_engine<std::uint_fast32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253> 32-bit Mersenne Twister by Matsumoto and Nishimura, 1998
`mt19937_64`(C++11) | std::mersenne_twister_engine<std::uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9, 29, 0x5555555555555555, 17, 0x71d67fffeda60000, 37, 0xfff7eee000000000, 43, 6364136223846793005> 64-bit Mersenne Twister by Matsumoto and Nishimura, 2000
`ranlux24_base` (C++11) | std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24>
`ranlux48_base` (C++11) | std::subtract_with_carry_engine<std::uint_fast64_t, 48, 5, 12>
`ranlux24`(C++11) | std::discard_block_engine<std::ranlux24_base, 223, 23> 24-bit RANLUX generator by Martin LÃ¼scher and Fred James, 1994
`ranlux48`(C++11) | std::discard_block_engine<std::ranlux48_base, 389, 11> 48-bit RANLUX generator by Martin LÃ¼scher and Fred James, 1994
`knuth_b` (C++11) | std::shuffle_order_engine<std::minstd_rand0, 256>
`default_random_engine`(C++11) | implementation-defined
##### Non-deterministic random numbers
random_device (C++11) | non-deterministic random number generator using hardware entropy source (class)
##### Uniform distributions
uniform_int_distribution (C++11) | produces integer values evenly distributed across a range (class template)
uniform_real_distribution (C++11) | produces real values evenly distributed across a range (class template)
##### Bernoulli distributions
bernoulli_distribution (C++11) | produces bool values on a Bernoulli distribution. (class)
binomial_distribution (C++11) | produces integer values on a binomial distribution. (class template)
negative_binomial_distribution (C++11) | produces integer values on a negative binomial distribution. (class template)
geometric_distribution (C++11) | produces integer values on a geometric distribution. (class template)
##### Poisson distributions
poisson_distribution (C++11) | produces integer values on a Poisson distribution (class template)
exponential_distribution (C++11) | produces real values on an exponential distribution. (class template)
gamma_distribution (C++11) | produces real values on a gamma distribution. (class template)
weibull_distribution (C++11) | produces real values on a Weibull distribution. (class template)
extreme_value_distribution (C++11) | produces real values on an extreme value distribution. (class template)
##### Normal distributions
normal_distribution (C++11) | produces real values on a standard normal (Gaussian) distribution. (class template)
lognormal_distribution (C++11) | produces real values on a lognormal distribution. (class template)
chi_squared_distribution (C++11) | produces real values on a chi-squared distribution. (class template)
cauchy_distribution (C++11) | produces real values on a Cauchy distribution. (class template)
fisher_f_distribution (C++11) | produces real values on a Fisher's F-distribution. (class template)
student_t_distribution (C++11) | produces real values on a Student's t-distribution. (class template)
##### Sampling distributions
discrete_distribution (C++11) | produces random integers on a discrete distribution. (class template)
piecewise_constant_distribution (C++11) | produces real values distributed on constant subintervals. (class template)
piecewise_linear_distribution (C++11) | produces real values distributed on defined subintervals. (class template)
##### Utilities
seed_seq (C++11) | general-purpose bias-eliminating scrambled seed sequence generator (class)
### Functions
generate_canonical (C++11) | evenly distributes real values of given precision across `[`â0â`,` 1`)` (function template)

### Synopsis

    #include <initializer_list>

    namespace std {
      // uniform random bit generator requirements
      template<class G>
        concept uniform_random_bit_generator = /* see description */;

      // class template linear_congruential_engine
      template<class UIntType, UIntType a, UIntType c, UIntType m>
        class linear_congruential_engine;

      // class template mersenne_twister_engine
      template<class UIntType, size_t w, size_t n, size_t m, size_t r,
               UIntType a, size_t u, UIntType d, size_t s,
               UIntType b, size_t t,
               UIntType c, size_t l, UIntType f>
        class mersenne_twister_engine;

      // class template subtract_with_carry_engine
      template<class UIntType, size_t w, size_t s, size_t r>
        class subtract_with_carry_engine;

      // class template discard_block_engine
      template<class Engine, size_t p, size_t r>
        class discard_block_engine;

      // class template independent_bits_engine
      template<class Engine, size_t w, class UIntType>
        class independent_bits_engine;

      // class template shuffle_order_engine
      template<class Engine, size_t k>
        class shuffle_order_engine;

      // engines and engine adaptors with predefined parameters
      using minstd_rand0  = /* see description */;
      using minstd_rand   = /* see description */;
      using mt19937       = /* see description */;
      using mt19937_64    = /* see description */;
      using ranlux24_base = /* see description */;
      using ranlux48_base = /* see description */;
      using ranlux24      = /* see description */;
      using ranlux48      = /* see description */;
      using knuth_b       = /* see description */;

      using default_random_engine = /* see description */;

      // class random_device
      class random_device;

      // class seed_seq
      class seed_seq;

      // function template generate_canonical
      template<class RealType, size_t bits, class URBG>
        RealType generate_canonical(URBG& g);

      // class template uniform_int_distribution
      template<class IntType = int>
        class uniform_int_distribution;

      // class template uniform_real_distribution
      template<class RealType = double>
        class uniform_real_distribution;

      // class bernoulli_distribution
      class bernoulli_distribution;

      // class template binomial_distribution
      template<class IntType = int>
        class binomial_distribution;

      // class template geometric_distribution
      template<class IntType = int>
        class geometric_distribution;

      // class template negative_binomial_distribution
      template<class IntType = int>
        class negative_binomial_distribution;

      // class template poisson_distribution
      template<class IntType = int>
        class poisson_distribution;

      // class template exponential_distribution
      template<class RealType = double>
        class exponential_distribution;

      // class template gamma_distribution
      template<class RealType = double>
        class gamma_distribution;

      // class template weibull_distribution
      template<class RealType = double>
        class weibull_distribution;

      // class template extreme_value_distribution
      template<class RealType = double>
        class extreme_value_distribution;

      // class template normal_distribution
      template<class RealType = double>
        class normal_distribution;

      // class template lognormal_distribution
      template<class RealType = double>
        class lognormal_distribution;

      // class template chi_squared_distribution
      template<class RealType = double>
        class chi_squared_distribution;

      // class template cauchy_distribution
      template<class RealType = double>
        class cauchy_distribution;

      // class template fisher_f_distribution
      template<class RealType = double>
        class fisher_f_distribution;

      // class template student_t_distribution
      template<class RealType = double>
        class student_t_distribution;

      // class template discrete_distribution
      template<class IntType = int>
        class discrete_distribution;

      // class template piecewise_constant_distribution
      template<class RealType = double>
        class piecewise_constant_distribution;

      // class template piecewise_linear_distribution
      template<class RealType = double>
        class piecewise_linear_distribution;
    }

#### Concept `uniform_random_bit_generator`

    namespace std {
      template<class G>
        concept uniform_random_bit_generator =
          invocable<G&> && unsigned_integral<invoke_result_t<G&>> &&
          requires {
            { G::min() } -> same_as<invoke_result_t<G&>>;
            { G::max() } -> same_as<invoke_result_t<G&>>;
            requires bool_constant<(G::min() < G::max())>::value;
          };
    }

#### Class template std::linear_congruential_engine

    namespace std {
      template<class UIntType, UIntType a, UIntType c, UIntType m>
        class linear_congruential_engine {
        public:
          // types
          using result_type = UIntType;

          // engine characteristics
          static constexpr result_type multiplier = a;
          static constexpr result_type increment = c;
          static constexpr result_type modulus = m;
          static constexpr result_type min() { return c == 0u ? 1u: 0u; }
          static constexpr result_type max() { return m - 1u; }
          static constexpr result_type default_seed = 1u;

          // constructors and seeding functions
          linear_congruential_engine() : linear_congruential_engine(default_seed) {}
          explicit linear_congruential_engine(result_type s);
          template<class Sseq> explicit linear_congruential_engine(Sseq& q);
          void seed(result_type s = default_seed);
          template<class Sseq> void seed(Sseq& q);

          // equality operators
          friend bool operator==(const linear_congruential_engine& x,
                                 const linear_congruential_engine& y);

          // generating functions
          result_type operator()();
          void discard(unsigned long long z);

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const linear_congruential_engine& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, linear_congruential_engine& x);
        };
    }

#### Class template std::mersenne_twister_engine

    namespace std {
      template<class UIntType, size_t w, size_t n, size_t m, size_t r,
               UIntType a, size_t u, UIntType d, size_t s,
               UIntType b, size_t t,
               UIntType c, size_t l, UIntType f>
        class mersenne_twister_engine {
        public:
          // types
          using result_type = UIntType;

          // engine characteristics
          static constexpr size_t word_size = w;
          static constexpr size_t state_size = n;
          static constexpr size_t shift_size = m;
          static constexpr size_t mask_bits = r;
          static constexpr UIntType xor_mask = a;
          static constexpr size_t tempering_u = u;
          static constexpr UIntType tempering_d = d;
          static constexpr size_t tempering_s = s;
          static constexpr UIntType tempering_b = b;
          static constexpr size_t tempering_t = t;
          static constexpr UIntType tempering_c = c;
          static constexpr size_t tempering_l = l;
          static constexpr UIntType initialization_multiplier = f;
          static constexpr result_type min() { return 0; }
          static constexpr result_type max() { return /* pow(2, w) - 1 */; }
          static constexpr result_type default_seed = 5489u;

          // constructors and seeding functions
          mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
          explicit mersenne_twister_engine(result_type value);
          template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
          void seed(result_type value = default_seed);
          template<class Sseq> void seed(Sseq& q);

          // equality operators
          friend bool operator==(const mersenne_twister_engine& x, const mersenne_twister_engine& y);

          // generating functions
          result_type operator()();
          void discard(unsigned long long z);

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const mersenne_twister_engine& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, mersenne_twister_engine& x);
        };
    }

#### Class template std::subtract_with_carry_engine

    namespace std {
      template<class UIntType, size_t w, size_t s, size_t r>
        class subtract_with_carry_engine {
        public:
          // types
          using result_type = UIntType;

          // engine characteristics
          static constexpr size_t word_size = w;
          static constexpr size_t short_lag = s;
          static constexpr size_t long_lag = r;
          static constexpr result_type min() { return 0; }
          static constexpr result_type max() { return /* pow(2, w) - 1 */; }
          static constexpr result_type default_seed = 19780503u;

          // constructors and seeding functions
          subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
          explicit subtract_with_carry_engine(result_type value);
          template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
          void seed(result_type value = default_seed);
          template<class Sseq> void seed(Sseq& q);

          // equality operators
          friend bool operator==(const subtract_with_carry_engine& x,
                                 const subtract_with_carry_engine& y);

          // generating functions
          result_type operator()();
          void discard(unsigned long long z);

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const subtract_with_carry_engine& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, subtract_with_carry_engine& x);
        };
    }

#### Class template std::discard_block_engine

    namespace std {
      template<class Engine, size_t p, size_t r>
        class discard_block_engine {
        public:
          // types
          using result_type = typename Engine::result_type;

          // engine characteristics
          static constexpr size_t block_size = p;
          static constexpr size_t used_block = r;
          static constexpr result_type min() { return Engine::min(); }
          static constexpr result_type max() { return Engine::max(); }

          // constructors and seeding functions
          discard_block_engine();
          explicit discard_block_engine(const Engine& e);
          explicit discard_block_engine(Engine&& e);
          explicit discard_block_engine(result_type s);
          template<class Sseq> explicit discard_block_engine(Sseq& q);
          void seed();
          void seed(result_type s);
          template<class Sseq> void seed(Sseq& q);

          // equality operators
          friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);

          // generating functions
          result_type operator()();
          void discard(unsigned long long z);

          // property functions
          const Engine& base() const noexcept { return e; };

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const discard_block_engine& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, discard_block_engine& x);

        private:
          Engine e;   // exposition only
          int n;      // exposition only
        };
    }

#### Class template std::independent_bits_engine

    namespace std {
      template<class Engine, size_t w, class UIntType>
        class independent_bits_engine {
        public:
          // types
          using result_type = UIntType;

          // engine characteristics
          static constexpr result_type min() { return 0; }
          static constexpr result_type max() { return /* pow(2, w) - 1 */; }

          // constructors and seeding functions
          independent_bits_engine();
          explicit independent_bits_engine(const Engine& e);
          explicit independent_bits_engine(Engine&& e);
          explicit independent_bits_engine(result_type s);
          template<class Sseq> explicit independent_bits_engine(Sseq& q);
          void seed();
          void seed(result_type s);
          template<class Sseq> void seed(Sseq& q);

          // equality operators
          friend bool operator==(const independent_bits_engine& x, const independent_bits_engine& y);

          // generating functions
          result_type operator()();
          void discard(unsigned long long z);

          // property functions
          const Engine& base() const noexcept { return e; };

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const independent_bits_engine& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, independent_bits_engine& x);

        private:
          Engine e;   // exposition only
        };
    }

#### Class template std::shuffle_order_engine

    namespace std {
      template<class Engine, size_t k>
        class shuffle_order_engine {
        public:
          // types
          using result_type = typename Engine::result_type;

          // engine characteristics
          static constexpr size_t table_size = k;
          static constexpr result_type min() { return Engine::min(); }
          static constexpr result_type max() { return Engine::max(); }

          // constructors and seeding functions
          shuffle_order_engine();
          explicit shuffle_order_engine(const Engine& e);
          explicit shuffle_order_engine(Engine&& e);
          explicit shuffle_order_engine(result_type s);
          template<class Sseq> explicit shuffle_order_engine(Sseq& q);
          void seed();
          void seed(result_type s);
          template<class Sseq> void seed(Sseq& q);

          // equality operators
          friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);

          // generating functions
          result_type operator()();
          void discard(unsigned long long z);

          // property functions
          const Engine& base() const noexcept { return e; };

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const shuffle_order_engine& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, shuffle_order_engine& x);

        private:
          Engine e;           // exposition only
          result_type V[k];   // exposition only
          result_type Y;      // exposition only
        };
    }

#### Engines and engine adaptors with predefined parameters

    namespace std {
      using minstd_rand0 =
            linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>;
      using minstd_rand =
            linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>;
      using mt19937 =
            mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
             0x9908'b0df, 11, 0xffff'ffff, 7, 0x9d2c'5680, 15, 0xefc6'0000, 18, 1'812'433'253>; //'
      using mt19937_64 =
            mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
             0xb502'6f5a'a966'19e9, 29, 0x5555'5555'5555'5555, 17,
             0x71d6'7fff'eda6'0000, 37, 0xfff7'eee0'0000'0000, 43, 6'364'136'223'846'793'005>; //'
      using ranlux24_base =
            subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
      using ranlux48_base =
            subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
      using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
      using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
      using knuth_b = shuffle_order_engine<minstd_rand0,256>;
      using default_random_engine = /* implementation-defined */;
    }

#### Class std::random_device

    namespace std {
      class random_device {
      public:
        // types
        using result_type = unsigned int;

        // generator characteristics
        static constexpr result_type min() { return numeric_limits<result_type>::min(); }
        static constexpr result_type max() { return numeric_limits<result_type>::max(); }

        // constructors
        random_device() : random_device(/* implementation-defined */) {}
        explicit random_device(const string& token);

        // generating functions
        result_type operator()();

        // property functions
        double entropy() const noexcept;

        // no copy functions
        random_device(const random_device&) = delete;
        void operator=(const random_device&) = delete;
      };
    }

#### Class std::seed_seq

    namespace std {
      class seed_seq {
      public:
        // types
        using result_type = uint_least32_t;

        // constructors
        seed_seq() noexcept;
        template<class T>
          seed_seq(initializer_list<T> il);
        template<class InputIt>
          seed_seq(InputIt begin, InputIt end);

        // generating functions
        template<class RandomAccessIt>
          void generate(RandomAccessIt begin, RandomAccessIt end);

        // property functions
        size_t size() const noexcept;
        template<class OutputIt>
          void param(OutputIt dest) const;

        // no copy functions
        seed_seq(const seed_seq&) = delete;
        void operator=(const seed_seq&) = delete;

      private:
        vector<result_type> v;        // exposition only
      };
    }

#### Class template std::uniform_int_distribution

    namespace std {
      template<class IntType = int>
        class uniform_int_distribution {
        public:
          // types
          using result_type = IntType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          uniform_int_distribution() : uniform_int_distribution(0) {}
          explicit uniform_int_distribution(IntType a,
                                            IntType b = numeric_limits<IntType>::max());
          explicit uniform_int_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const uniform_int_distribution& x, const uniform_int_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          result_type a() const;
          result_type b() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const uniform_int_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, uniform_int_distribution& x);
        };
    }

#### Class template std::uniform_real_distribution

    namespace std {
      template<class RealType = double>
        class uniform_real_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          uniform_real_distribution() : uniform_real_distribution(0.0) {}
          explicit uniform_real_distribution(RealType a, RealType b = 1.0);
          explicit uniform_real_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const uniform_real_distribution& x,
                                 const uniform_real_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          result_type a() const;
          result_type b() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const uniform_real_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, uniform_real_distribution& x);
        };
    }

#### Class std::bernoulli_distribution

    namespace std {
      class bernoulli_distribution {
      public:
        // types
        using result_type = bool;
        using param_type  = /* unspecified */;

        // constructors and reset functions
        bernoulli_distribution() : bernoulli_distribution(0.5) {}
        explicit bernoulli_distribution(double p);
        explicit bernoulli_distribution(const param_type& parm);
        void reset();

        // equality operators
        friend bool operator==(const bernoulli_distribution& x, const bernoulli_distribution& y);

        // generating functions
        template<class URBG>
          result_type operator()(URBG& g);
        template<class URBG>
          result_type operator()(URBG& g, const param_type& parm);

        // property functions
        double p() const;
        param_type param() const;
        void param(const param_type& parm);
        result_type min() const;
        result_type max() const;

        // inserters and extractors
        template<class CharT, class Traits>
          friend basic_ostream<CharT, Traits>&
            operator<<(basic_ostream<CharT, Traits>& os, const bernoulli_distribution& x);
        template<class CharT, class Traits>
          friend basic_istream<CharT, Traits>&
            operator>>(basic_istream<CharT, Traits>& is, bernoulli_distribution& x);
      };
    }

#### Class template std::binomial_distribution

    namespace std {
      template<class IntType = int>
        class binomial_distribution {
        public:
          // types
          using result_type = IntType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          binomial_distribution() : binomial_distribution(1) {}
          explicit binomial_distribution(IntType t, double p = 0.5);
          explicit binomial_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const binomial_distribution& x, const binomial_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          IntType t() const;
          double p() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const binomial_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, binomial_distribution& x);
        };
    }

#### Class template std::geometric_distribution

    namespace std {
      template<class IntType = int>
        class geometric_distribution {
        public:
          // types
          using result_type = IntType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          geometric_distribution() : geometric_distribution(0.5) {}
          explicit geometric_distribution(double p);
          explicit geometric_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const geometric_distribution& x, const geometric_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          double p() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const geometric_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, geometric_distribution& x);
        };
    }

#### Class template std::negative_binomial_distribution

    namespace std {
      template<class IntType = int>
        class negative_binomial_distribution {
        public:
          // types
          using result_type = IntType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          negative_binomial_distribution() : negative_binomial_distribution(1) {}
          explicit negative_binomial_distribution(IntType k, double p = 0.5);
          explicit negative_binomial_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const negative_binomial_distribution& x,
                                 const negative_binomial_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          IntType k() const;
          double p() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const negative_binomial_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, negative_binomial_distribution& x);
        };
    }

#### Class template std::poisson_distribution

    namespace std {
      template<class IntType = int>
        class poisson_distribution {
        public:
          // types
          using result_type = IntType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          poisson_distribution() : poisson_distribution(1.0) {}
          explicit poisson_distribution(double mean);
          explicit poisson_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const poisson_distribution& x, const poisson_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          double mean() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const poisson_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, poisson_distribution& x);
        };
    }

#### Class template std::exponential_distribution

    namespace std {
      template<class RealType = double>
        class exponential_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          exponential_distribution() : exponential_distribution(1.0) {}
          explicit exponential_distribution(RealType lambda);
          explicit exponential_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const exponential_distribution& x, const exponential_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType lambda() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const exponential_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, exponential_distribution& x);
      };
    }

#### Class template std::gamma_distribution

    namespace std {
      template<class RealType = double>
        class gamma_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          gamma_distribution() : gamma_distribution(1.0) {}
          explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
          explicit gamma_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const gamma_distribution& x, const gamma_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType alpha() const;
          RealType beta() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const gamma_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, gamma_distribution& x);
        };
    }

#### Class template std::weibull_distribution

    namespace std {
      template<class RealType = double>
        class weibull_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          weibull_distribution() : weibull_distribution(1.0) {}
          explicit weibull_distribution(RealType a, RealType b = 1.0);
          explicit weibull_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const weibull_distribution& x, const weibull_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType a() const;
          RealType b() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const weibull_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, weibull_distribution& x);
        };
    }

#### Class template std::extreme_value_distribution

    namespace std {
      template<class RealType = double>
        class extreme_value_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          extreme_value_distribution() : extreme_value_distribution(0.0) {}
          explicit extreme_value_distribution(RealType a, RealType b = 1.0);
          explicit extreme_value_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const extreme_value_distribution& x,
                                 const extreme_value_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType a() const;
          RealType b() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const extreme_value_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, extreme_value_distribution& x);
        };
    }

#### Class template std::normal_distribution

    namespace std {
      template<class RealType = double>
        class normal_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          normal_distribution() : normal_distribution(0.0) {}
          explicit normal_distribution(RealType mean, RealType stddev = 1.0);
          explicit normal_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const normal_distribution& x, const normal_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType mean() const;
          RealType stddev() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const normal_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, normal_distribution& x);
        };
    }

#### Class template std::lognormal_distribution

    namespace std {
      template<class RealType = double>
        class lognormal_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          lognormal_distribution() : lognormal_distribution(0.0) {}
          explicit lognormal_distribution(RealType m, RealType s = 1.0);
          explicit lognormal_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const lognormal_distribution& x, const lognormal_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType m() const;
          RealType s() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const lognormal_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, lognormal_distribution& x);
        };
    }

#### Class template std::chi_squared_distribution

    namespace std {
      template<class RealType = double>
        class chi_squared_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          chi_squared_distribution() : chi_squared_distribution(1.0) {}
          explicit chi_squared_distribution(RealType n);
          explicit chi_squared_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const chi_squared_distribution& x, const chi_squared_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType n() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const chi_squared_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, chi_squared_distribution& x);
        };
    }

#### Class template std::cauchy_distribution

    namespace std {
      template<class RealType = double>
        class cauchy_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          cauchy_distribution() : cauchy_distribution(0.0) {}
          explicit cauchy_distribution(RealType a, RealType b = 1.0);
          explicit cauchy_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const cauchy_distribution& x, const cauchy_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType a() const;
          RealType b() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const cauchy_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, cauchy_distribution& x);
        };

#### Class template std::fisher_f_distribution

    namespace std {
      template<class RealType = double>
        class fisher_f_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          fisher_f_distribution() : fisher_f_distribution(1.0) {}
          explicit fisher_f_distribution(RealType m, RealType n = 1.0);
          explicit fisher_f_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const fisher_f_distribution& x, const fisher_f_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType m() const;
          RealType n() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const fisher_f_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, fisher_f_distribution& x);
        };
    }

#### Class template std::student_t_distribution

    namespace std {
      template<class RealType = double>
        class student_t_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          student_t_distribution() : student_t_distribution(1.0) {}
          explicit student_t_distribution(RealType n);
          explicit student_t_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const student_t_distribution& x, const student_t_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          RealType n() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

           // inserters and extractors
           template<class CharT, class Traits>
             friend basic_ostream<CharT, Traits>&
               operator<<(basic_ostream<CharT, Traits>& os, const student_t_distribution& x);
           template<class CharT, class Traits>
             friend basic_istream<CharT, Traits>&
               operator>>(basic_istream<CharT, Traits>& is, student_t_distribution& x);
        };
    }

#### Class template std::discrete_distribution

    namespace std {
      template<class IntType = int>
        class discrete_distribution {
        public:
          // types
          using result_type = IntType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          discrete_distribution();
          template<class InputIt>
            discrete_distribution(InputIt firstW, InputIt lastW);
          discrete_distribution(initializer_list<double> wl);
          template<class UnaryOperation>
            discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
          explicit discrete_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const discrete_distribution& x, const discrete_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          vector<double> probabilities() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const discrete_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, discrete_distribution& x);
        };
    }

#### Class template std::piecewise_constant_distribution

    namespace std {
       template<class RealType = double>
        class piecewise_constant_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          piecewise_constant_distribution();
          template<class InputItB, class InputItW>
            piecewise_constant_distribution(InputItB firstB, InputItB lastB, InputItW firstW);
          template<class UnaryOperation>
            piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);
          template<class UnaryOperation>
            piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax,
                                            UnaryOperation fw);
          explicit piecewise_constant_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const piecewise_constant_distribution& x,
                                 const piecewise_constant_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          vector<result_type> intervals() const;
          vector<result_type> densities() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const piecewise_constant_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, piecewise_constant_distribution& x);
        };
    }

#### Class template std::piecewise_linear_distribution

    namespace std {
      template<class RealType = double>
        class piecewise_linear_distribution {
        public:
          // types
          using result_type = RealType;
          using param_type  = /* unspecified */;

          // constructors and reset functions
          piecewise_linear_distribution();
          template<class InputItB, class InputItW>
            piecewise_linear_distribution(InputItB firstB, InputItB lastB, InputItW firstW);
          template<class UnaryOperation>
            piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
          template<class UnaryOperation>
            piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax,
                                          UnaryOperation fw);
          explicit piecewise_linear_distribution(const param_type& parm);
          void reset();

          // equality operators
          friend bool operator==(const piecewise_linear_distribution& x,
                                 const piecewise_linear_distribution& y);

          // generating functions
          template<class URBG>
            result_type operator()(URBG& g);
          template<class URBG>
            result_type operator()(URBG& g, const param_type& parm);

          // property functions
          vector<result_type> intervals() const;
          vector<result_type> densities() const;
          param_type param() const;
          void param(const param_type& parm);
          result_type min() const;
          result_type max() const;

          // inserters and extractors
          template<class CharT, class Traits>
            friend basic_ostream<CharT, Traits>&
              operator<<(basic_ostream<CharT, Traits>& os, const piecewise_linear_distribution& x);
          template<class CharT, class Traits>
            friend basic_istream<CharT, Traits>&
              operator>>(basic_istream<CharT, Traits>& is, piecewise_linear_distribution& x);
        };
    }

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/header/random&oldid=146888"