29 Numerics library [numerics]

A uniform_­int_­distribution random number distribution produces random integers i, $a\le i\le b$, distributed according to the constant discrete probability function

$$P(i|a,b)=1/(b-a+1)\text{.}$$

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

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

    // 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;
  };

A uniform_­real_­distribution random number distribution produces random numbers x, $a\le x<b$, distributed according to the constant probability density function

$$p(x|a,b)=1/(b-a)\text{.}$$

[ Note: This implies that $p(x|a,b)$ is undefined when a == b.  — end note ]

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

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

    // 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;
  };

A bernoulli_­distribution random number distribution produces bool values b distributed according to the discrete probability function

$$P\left(b|p\right)=\{\begin{array}{ccc}p& \text{if}& b=\text{true}\\ 1-p& \text{if}& b=\text{false}\end{array}\text{.}$$

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

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

  // 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;
};

A binomial_­distribution random number distribution produces integer values $i\ge 0$ distributed according to the discrete probability function

$$P(i|t,p)=(\frac{t}{i})\cdot p^i\cdot (1-p{)}^{t-i}\text{.}$$

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

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

    // 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;
  };

A geometric_­distribution random number distribution produces integer values $i\ge 0$ distributed according to the discrete probability function

$$P\left(i|p\right)=p\cdot (1-p{)}^i\text{.}$$

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

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

    // 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;
  };

A negative_­binomial_­distribution random number distribution produces random integers $i\ge 0$ distributed according to the discrete probability function

$$P(i|k,p)=(\frac{k+i-1}{i})\cdot p^k\cdot (1-p{)}^i\text{.}$$

[ Note: This implies that $P(i|k,p)$ is undefined when p == 1.  — end note ]

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

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

    // 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;
  };

A poisson_­distribution random number distribution produces integer values $i\ge 0$ distributed according to the discrete probability function

$$P\left(i|\mu \right)=\frac{e^{-\mu }{\mu }^i}{i!}\text{.}$$

The distribution parameter μ is also known as this distribution's mean.

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

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

    // 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;
  };

An exponential_­distribution random number distribution produces random numbers $x>0$ distributed according to the probability density function

$$p\left(x|\lambda \right)=\lambda e^{-\lambda x}\text{.}$$

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

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

    // 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;
  };

A gamma_­distribution random number distribution produces random numbers $x>0$ distributed according to the probability density function

$$p(x|\alpha ,\beta )=\frac{e^{-x/\beta }}{{\beta }^{\alpha }\cdot \Gamma \left(\alpha \right)}\cdot x^{\alpha -1}\text{.}$$

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

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

    // 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;
  };

A weibull_­distribution random number distribution produces random numbers $x\ge 0$ distributed according to the probability density function

$$p(x|a,b)=\frac{a}{b}\cdot {\left(\frac{x}{b}\right)}^{a-1}\cdot \exp (-{\left(\frac{x}{b}\right)}^a)\text{.}$$

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

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

    // 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;
  };

An extreme_­value_­distribution random number distribution produces random numbers x distributed according to the probability density function274

$$p(x|a,b)=\frac{1}{b}\cdot \exp (\frac{a-x}{b}-\exp \left(\frac{a-x}{b}\right))\text{.}$$

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

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

    // 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;
  };

A normal_­distribution random number distribution produces random numbers x distributed according to the probability density function

$$p(x|\mu ,\sigma )=\frac{1}{\sigma \sqrt{2\pi }}\cdot \exp (-\frac{(x-\mu {)}^2}{2{\sigma }^2})\text{.}$$

The distribution parameters μ and σ are also known as this distribution's mean and standard deviation.

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

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

    // 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;
  };

A lognormal_­distribution random number distribution produces random numbers $x>0$ distributed according to the probability density function

$$p(x|m,s)=\frac{1}{sx\sqrt{2\pi }}\cdot \exp (-\frac{(\ln x-m{)}^2}{2s^2})\text{.}$$

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

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

    // 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;
  };

A chi_­squared_­distribution random number distribution produces random numbers x>0 distributed according to the probability density function

$$p\left(x|n\right)=\frac{x^{\left(n/2\right)-1}\cdot e^{-x/2}}{\Gamma \left(n/2\right)\cdot 2^{n/2}}\text{.}$$

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

    // constructor and reset functions
    explicit chi_squared_distribution(RealType n = 1);
    explicit chi_squared_distribution(const param_type& parm);
    void reset();

    // 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;
  };

A cauchy_­distribution random number distribution produces random numbers x distributed according to the probability density function

$$p(x|a,b)={\left(\pi b(1+{\left(\frac{x-a}{b}\right)}^2)\right)}^{-1}\text{.}$$

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

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

    // 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;
  };

A fisher_­f_­distribution random number distribution produces random numbers x≥0 distributed according to the probability density function

$$p(x|m,n)=\frac{\Gamma ((m+n)/2)}{\Gamma \left(m/2\right)\Gamma \left(n/2\right)}\cdot {\left(\frac{m}{n}\right)}^{m/2}\cdot x^{\left(m/2\right)-1}\cdot {(1+\frac{mx}{n})}^{-(m+n)/2}\text{.}$$

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

    // constructor and reset functions
    explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
    explicit fisher_f_distribution(const param_type& parm);
    void reset();

    // 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;
  };

A student_­t_­distribution random number distribution produces random numbers x distributed according to the probability density function

$$p\left(x|n\right)=\frac{1}{\sqrt{n\pi }}\cdot \frac{\Gamma ((n+1)/2)}{\Gamma \left(n/2\right)}\cdot {(1+\frac{x^2}{n})}^{-(n+1)/2}\text{.}$$

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

    // constructor and reset functions
    explicit student_t_distribution(RealType n = 1);
    explicit student_t_distribution(const param_type& parm);
    void reset();

    // 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;
  };

A discrete_­distribution random number distribution produces random integers i, $0\le i<n$, distributed according to the discrete probability function

$$P(i|p_0,\dots ,p_{n-1})=p_i\text{.}$$

Unless specified otherwise, the distribution parameters are calculated as: $p_k=w_k/S\text{for}k=0,\dots ,n-1$ , in which the values $w_k$, commonly known as the weights, shall be non-negative, non-NaN, and non-infinity. Moreover, the following relation shall hold: $0<S=w_0+\cdots +w_{n-1}$.

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

    // constructor and reset functions
    discrete_distribution();
    template<class InputIterator>
      discrete_distribution(InputIterator firstW, InputIterator 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();

    // 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;
  };

A piecewise_­constant_­distribution random number distribution produces random numbers x, $b_0\le x<b_n$, uniformly distributed over each subinterval $[b_i,b_{i+1})$ according to the probability density function

$$p(x|b_0,\dots ,b_n,{\rho }_0,\dots ,{\rho }_{n-1})={\rho }_i\text{,}\text{for}{b}_i\le x<b_{i+1}\text{.}$$

The $n+1$ distribution parameters $b_i$, also known as this distribution's interval boundaries, shall satisfy the relation $b_i<b_{i+1}$ for $i=0,\dots ,n-1$. Unless specified otherwise, the remaining n distribution parameters are calculated as:

$${\rho }_k=\frac{w_k}{S\cdot (b_{k+1}-b_k)}\text{for}k=0,\dots ,n-1,$$

in which the values $w_k$, commonly known as the weights, shall be non-negative, non-NaN, and non-infinity. Moreover, the following relation shall hold: $0<S=w_0+\cdots +w_{n-1}$.

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

    // constructor and reset functions
    piecewise_constant_distribution();
    template<class InputIteratorB, class InputIteratorW>
      piecewise_constant_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                      InputIteratorW 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();

    // 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;
  };

A piecewise_­linear_­distribution random number distribution produces random numbers x, $b_0\le x<b_n$, distributed over each subinterval $[b_i,b_{i+1})$ according to the probability density function

$$p(x|b_0,\dots ,b_n,{\rho }_0,\dots ,{\rho }_n)={\rho }_i\cdot \frac{b_{i+1}-x}{b_{i+1}-b_i}+{\rho }_{i+1}\cdot \frac{x-b_i}{b_{i+1}-b_i}\text{,}\text{for}{b}_i\le x<b_{i+1}\text{.}$$

The $n+1$ distribution parameters $b_i$, also known as this distribution's interval boundaries, shall satisfy the relation $b_i<b_{i+1}$ for $i=0,\dots ,n-1$. Unless specified otherwise, the remaining $n+1$ distribution parameters are calculated as ${\rho }_k=w_k/S\text{for}k=0,\dots ,n$, in which the values $w_k$, commonly known as the weights at boundaries, shall be non-negative, non-NaN, and non-infinity. Moreover, the following relation shall hold:

$$0<S=\frac{1}{2}\cdot \sum _{k=0}^{n-1}(w_k+w_{k+1})\cdot (b_{k+1}-b_k)\text{.}$$

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

    // constructor and reset functions
    piecewise_linear_distribution();
    template<class InputIteratorB, class InputIteratorW>
      piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                    InputIteratorW 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();

    // 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;
  };