Discrete Random Variables

Point Mass Distribution

Definition

$X$ has a point mass distribution at $a$, written $X\sim {\delta }_a$, if $\mathbf{P}(X=a)=1$ in which case

$$F(x)=\{\begin{array}{ll}0& x<a,\\ 1& x\ge a.\end{array}$$

The probability mass function is $f(x)=1$ for $x=a$, and 0 otherwise.

Discrete Uniform Distribution

https://en.wikipedia.org/wiki/Discrete_uniform_distribution

Definition

Let $k>1$ be a given integer. Suppose $X$ has a probability mass function given by

$$f(x)=\{\begin{array}{ll}1/k& \text{for}x=1,\dots ,k\\ 0& \text{otherwise.}\end{array}$$

We then say that $X$ has a uniform distribution on $\{1,\dots ,k\}$.

Bernoulli Distribution

https://en.wikipedia.org/wiki/Bernoulli_distribution

Definition

Let $X$ represent a binary coin flip. Then $\mathbf{P}(X=1)=p$ and $\mathbf{P}(X=0)=1-p$ for some $p\in [0,1]$. We say that $X$ has a Bernoulli distribution written $X\sim \text{Bernoulli}(p)$. The probability mass function is given by

$$f(x)=p^x(1-p{)}^{1-x}$$

for $x\in \{0,1\}$.

Generating Bernoulli Samples

template <typename T>
auto bernoulli(T p, Generator gen) -> T {
    const auto u = uniform_real_sample(0, 1, gen);
    return static_cast<T>(u < p);
}

Binomial Distribution

https://en.wikipedia.org/wiki/Binomial_distribution

Definition

The probability of getting exactly $x$ successes in $n$ independent Bernoulli trials (with the same rate $p$) is given by the probability mass function

$$f(x)=\left(\genfrac{}{}{0ex}{}{n}{x}\right)p^x(1-p{)}^{n-x}$$

for $x=0,1,\dots ,n$. A random variable $X$ with this mass function is called a Binomial random variable, and we write $X\sim \text{Binomial}(n,p)$.

Theorem

If $X_1\sim \text{Binomial}(n_1,p)$ and $X_2\sim \text{Binomial}(n_2,p)$, then $X_1+X_2\sim \text{Binomial}(n_1+n_2,p)$.

Generating Binomial Samples

template <typename T>
auto binomial(T p, T n, Generator gen) -> T {
    T sum{};
    for (auto _ : std::views::iota(0, n)) {
        const auto u = uniform_real_sample(0, 1, gen);
        sum += static_cast<T>(u < p);
    }
}

Geometric Distribution

https://en.wikipedia.org/wiki/Geometric_distribution

Definition

The Geometric distribution is either one of the two discrete probability distributions:

• The probability distribution of the number $X$ of Bernoulli trials needed to get one success, supported on $\mathcal{N}=\{1,2,\dots \}$
• The probability distribution of the number $Y=X-1$ of failures before the first success, supported on ${\mathbb{N}}_0=\{0,1,\dots \}$.

If the probability of success on each trial is $p$, then the probability that the $k$-th trial is the first success is

$$\mathbf{P}(X=k)=(1-p{)}^{k-1}p,$$

for $k=1,2,\dots$. The above form of the geometric distribution is used for modeling the number of trials up to and including the first success. By contrast, the following form of the geometric distribution is used for modeling the number of failures until the first success

$$\mathbf{P}(Y=k)=\mathbf{P}(X=k+1)=(1-p{)}^{k}p,$$

for $k=0,1,\dots$.

Generating Geometric Samples

template <typename T>
auto geometric(T p, Generator gen) -> T {
    const auto u = uniform_real_sample(0, 1, gen);
    return p == 1 ? 1 : std::ceil(std::log1p(-u) / std::log1p(-p));
}

Poisson Distribution

https://en.wikipedia.org/wiki/Poisson_distribution

Definition

A discrete random variable $X$ is said to have a Poisson distribution with parameter $\lambda >0$, denoted as $X\sim \text{Poisson}(\lambda )$, if it has the probability mass function given by

$$f(x)=\mathbf{P}(X=x)=\frac{{\lambda }^x{e}^{-\lambda }}{x!},$$

where $k=\{0,1,\dots \}$ is the number of occurrences. The Poisson distribution is often used as a model for the counts of rare events.

Theorem

If $X_1\sim \text{Poisson}({\lambda }_1)$ and $X_2\sim \text{Poisson}({\lambda }_2)$, then $X_1+X_2\sim \text{Poisson}({\lambda }_1+{\lambda }_2)$.

Generating Poisson Samples

Devroye, Luc, and Luc Devroye. “Discrete univariate distributions.” Non-Uniform Random Variate Generation (1986): 485-553.

template <typename T>
auto poisson(T lambda, Generator gen) -> T {
    T x{};
    auto p = std::exp(-lambda);
    auto s = p;
    const auto u = uniform_real_sample(static_cast<T>(0), static_cast<T>(1), gen);
    while (u > s) {
        ++x;
        p *= lambda / x;
        s += p;
    }
    return x;
}