An Analysis of an Open Source Binomial Random Variate Generation Algorithm ^†

Abstract

The binomial distribution is the probability distribution of the number of successes for a sequence of n independent trials with success probability p. Efficiently generating binomial random variates is important in many modeling and simulation applications, such as in medicine, risk management, and fraud and anomaly detection, among others. A variety of algorithms exist for generating binomial random variates. This paper concerns the algorithm chosen for $\rho \mu$, an open source Java library for efficient randomization, which uses a hybrid of two existing binomial random variate algorithms: the BTPE Algorithm (Binomial, Triangle, Parallelogram, Exponential) and the inverse transform for cases that BTPE cannot handle. BTPE uses rejection sampling, and BTPE’s authors originally provided an analytical formula for the expected number of iterations in terms of n and p. That expression is complicated to interpret in practical contexts. I explore BTPE by instrumenting $\rho \mu$’s implementation to empirically analyze its acceptance/rejection behavior to gain further insights into its runtime performance. Although the number of iterations depends upon n and p, my experiments show that the average number of iterations is always under two, and that the average number of random uniform variates required to generate a single random binomial is under four (two per iteration). Thus, when analyzing the runtime of a simulation algorithm that includes steps generating random binomials, one can consider such steps to have a constant runtime.

1. Introduction

The binomial distribution is the probability distribution of the number of successes for a sequence of n independent Bernoulli trials with success probability p [1]. Binomial random variates are important in many modeling and simulation [2] applications, such as in medicine [3,4,5,6], risk management [7,8], fraud and anomaly detection [9], among others [10], and many algorithms exist for their efficient generation [2,11,12,13,14,15].

The focus of this paper is on the algorithm chosen for generating binomial random variates for the $\rho \mu$ library [16]. The open source Java library $\rho \mu$ [16] provides enhanced random number generation atop what the Java API itself includes. Java 17 introduced a hierarchy of random number generator interfaces and several new random number generators, among other new randomization features [17]. The core functionality of $\rho \mu$ is provided through a hierarchy of wrapper classes, which corresponds with the hierarchy of random number generator interfaces introduced in Java 17. In some cases, $\rho \mu$’s classes override the behavior of Java’s random number generators with faster algorithms, such as for random integers subject to a bound or generating random Gaussians, while in other cases, $\rho \mu$ adds functionality not built into the Java API’s classes, such as additional distributions, i.e., the binomial, among others [16]. The $\rho \mu$ library provides efficient random number generation to other libraries, such as JavaPermutationTools [18] and Chips-n-Salsa [19].

Motivation: What is the computational cost to generate a random value from a binomial distribution $B(n,p)$? Answering this question is important for analyses of algorithms that rely upon binomial random variates. To generate binomial random variates, $\rho \mu$ [16] utilizes a combination of the BTPE Algorithm (Binomial, Triangle, Parallelogram, Exponential) [11] and the inverse transform [11,15] for cases that cannot be handled by BTPE. The runtime of the inverse transform is $O\left(np\right)$ [11,15]. However, BTPE’s runtime does not appear to grow in the same way, if at all. BTPE uses acceptance–rejection sampling [20]. BTPE’s authors originally provided an analytical formula for the expected number of acceptance–rejection iterations in terms of n and p. Interpreting that expression is less than practical. In order to further understand the computational efficiency of binomial random variate generation, I instrumented $\rho \mu$’s implementation of BTPE to empirically analyze its acceptance–rejection behavior to gain further insight into its runtime performance. Although the number of iterations depends upon n and p, my experiments show that the average number of iterations is always under two, and that the average number of uniform random variates required to generate a single random binomial is under four. Thus, when analyzing the runtime of a simulation algorithm that includes steps generating random binomials, one can consider such steps to have a constant runtime.

I explain the experimental methodology in Section 2, and I present the results in Section 3. The source code of the experiments, the raw and processed data, and the analysis are available on GitHub. The source code for $\rho \mu$ is also on GitHub. I conclude with a discussion in Section 4.

2. Methods

2.1. Binomial Random Variate Generation

The $\rho \mu$ library [16] generates binomial random variates primarily using BTPE [11], falling back on the inverse transform [11,15] when $np$ is small. BTPE divides the distribution into four parts, using triangular functions in the middle and exponential functions in the tails, and uses acceptance–rejection sampling [20]. For complete details of BTPE, which are beyond the scope of this paper, I refer the reader to the article that introduced it [11].

2.2. Expected Acceptance–Rejection Iterations

To generate a random value from a binomial distribution $B(n,p)$, each acceptance–rejection iteration of BTPE generates two random values from $U(0,1)$, i.e., uniformly distributed over the interval $[0.0,1.0)$. When they introduced BTPE, Kachitvichyanukul and Schmeiser determined that the expected number of iterations of BTPE is [11]:

$$\left(\genfrac{}{}{0pt}{}{n}{M}\right)r^M{(1-r)}^{n-M}{\int }_{-\infty }^{\infty }t\left(x\right)dx,$$

(1)

where $r=min(p,1-p)$, $M=\lfloor nr+r\rfloor$ and $t\left(x\right)$ is BTPE’s majorizing function (see [11] for details of $t\left(x\right)$). Since each iteration generates two random uniform values from $U(0,1)$, the expected number of uniform variates required by BTPE is thus:

$$2\left(\genfrac{}{}{0pt}{}{n}{M}\right)r^M{(1-r)}^{n-M}{\int }_{-\infty }^{\infty }t\left(x\right)dx.$$

(2)

2.3. Empirical Methodology

It is not obvious whether Equations (1) and (2) grow with n, grow with $np$, grow with $nr$, etc.? Furthermore, if so, how quickly? BTPE is fast. Despite being a 35-year-old algorithm, it is one of the best available for all but the smallest $np$. I set out to empirically explore the runtime behavior of BTPE to provide a practical perspective to Equations (1) and (2).

To accomplish this, I wrapped an instance of Java’s SplittableRandom class, which implements the splitmix [21] pseudorandom number generator, in order to instrument it to count the number of calls to its nextDouble() method, which generates uniform random floating-point values in the interval $[0.0,1.0)$. This wrapped random number generator is then used as the source of randomness for $\rho \mu$’s implementation of BTPE.

I consider $n\in \{2^5,2^6,\dots ,2^{20}\}$. BTPE is only relevant for $nr\ge 10$. Thus, $p\ge \frac{10}{n}$. For a given n, consider $p\in \{\frac{10}{n},\frac{16}{n},\frac{32}{n},\dots ,\frac{1}{2},\dots ,\frac{n-32}{n},\frac{n-16}{n},\frac{n-10}{n}\}$. For each combination of n and p, I use BTPE to generate 10,000 binomial random variates, and I compute the average number of uniform variates per binomial, with 95% confidence intervals. I use Equation (2) to predict the number of uniform variates for each case, and test significance with a t-test.

I used OpenJDK 17 on a Windows 10 PC with a 3.4 GHz AMD A10-5700 CPU and 8 GB RAM. The experiments used $\rho \mu$ 3.1.1. The source code for the experiments is on GitHub at https://github.com/cicirello/btpe-iterations (accessed on 8 August 2023), as well as for $\rho \mu$ at https://github.com/cicirello/rho-mu (accessed on 8 August 2023).

3. Results

Table 1. Average number of calls to $U(0,1)$ by $\rho \mu$’s BTPE implementation for n = 1,048,576.

p	$\mathit{\rho }\mathit{\mu }$ Mean	Predicted	t-Test p-Value
0.0000095367	$3.81\pm 0.051$	3.80	0.74
0.0000152588	$3.42\pm 0.043$	3.45	0.21
0.0000305176	$2.99\pm 0.034$	2.94	0.01
0.0000610352	$2.60\pm 0.025$	2.63	0.06
0.0001220703	$2.48\pm 0.021$	2.49	0.54
0.0002441406	$2.35\pm 0.018$	2.33	0.17
0.0004882812	$2.29\pm 0.016$	2.30	0.41
0.0009765625	$2.26\pm 0.015$	2.26	0.95
0.001953125	$2.25\pm 0.015$	2.26	0.48
0.00390625	$2.27\pm 0.015$	2.27	0.90
0.0078125	$2.27\pm 0.015$	2.28	0.27
0.015625	$2.29\pm 0.016$	2.29	0.61
0.03125	$2.30\pm 0.016$	2.30	0.65
0.0625	$2.29\pm 0.016$	2.30	0.17
0.125	$2.29\pm 0.016$	2.31	0.06
0.25	$2.30\pm 0.016$	2.31	0.24
0.5	$2.31\pm 0.017$	2.31	0.58
0.75	$2.31\pm 0.016$	2.31	0.60
0.875	$2.31\pm 0.016$	2.31	0.87
0.9375	$2.30\pm 0.016$	2.30	0.75
0.96875	$2.29\pm 0.016$	2.30	0.57
0.984375	$2.28\pm 0.016$	2.29	0.10
0.9921875	$2.27\pm 0.015$	2.28	0.29
0.99609375	$2.27\pm 0.015$	2.27	0.94
0.998046875	$2.26\pm 0.015$	2.26	0.58
0.9990234375	$2.25\pm 0.015$	2.26	0.47
0.9995117188	$2.29\pm 0.016$	2.30	0.63
0.9997558594	$2.33\pm 0.017$	2.33	0.62
0.9998779297	$2.48\pm 0.021$	2.49	0.28
0.9999389648	$2.63\pm 0.025$	2.63	0.73
0.9999694824	$2.95\pm 0.033$	2.94	0.78
0.9999847412	$3.44\pm 0.043$	3.45	0.75
0.9999904633	$3.84\pm 0.053$	3.80	0.17

,

Table 2. Average number of calls to $U(0,1)$ by $\rho \mu$’s BTPE implementation for n = 32,768.

p	$\mathit{\rho }\mathit{\mu }$ Mean	Predicted	t-Test p-Value
0.0003051758	$3.81\pm 0.052$	3.80	0.73
0.0004882812	$3.48\pm 0.044$	3.45	0.13
0.0009765625	$2.96\pm 0.033$	2.94	0.50
0.001953125	$2.62\pm 0.025$	2.63	0.51
0.00390625	$2.48\pm 0.021$	2.49	0.15
0.0078125	$2.34\pm 0.017$	2.34	0.81
0.015625	$2.27\pm 0.015$	2.27	0.55
0.03125	$2.26\pm 0.015$	2.26	0.92
0.0625	$2.25\pm 0.015$	2.26	0.57
0.125	$2.28\pm 0.015$	2.28	0.43
0.25	$2.29\pm 0.016$	2.28	0.59
0.5	$2.29\pm 0.016$	2.30	0.08
0.75	$2.30\pm 0.016$	2.28	0.16
0.875	$2.27\pm 0.016$	2.28	0.62
0.9375	$2.26\pm 0.015$	2.26	0.76
0.96875	$2.26\pm 0.015$	2.26	0.53
0.984375	$2.28\pm 0.015$	2.27	0.15
0.9921875	$2.32\pm 0.017$	2.34	0.04
0.99609375	$2.48\pm 0.021$	2.49	0.22
0.998046875	$2.62\pm 0.025$	2.63	0.69
0.9990234375	$2.98\pm 0.034$	2.94	0.08
0.9995117188	$3.45\pm 0.044$	3.45	0.81
0.9996948242	$3.78\pm 0.051$	3.80	0.53

,

Table 3. Average number of calls to $U(0,1)$ by $\rho \mu$’s BTPE implementation for $n=1024$.

p	$\mathit{\rho }\mathit{\mu }$ Mean	Predicted	t-Test p-Value
0.009765625	$3.82\pm 0.051$	3.80	0.42
0.015625	$3.49\pm 0.045$	3.46	0.16
0.03125	$2.94\pm 0.033$	2.97	0.06
0.0625	$2.70\pm 0.027$	2.69	0.53
0.125	$2.52\pm 0.022$	2.52	0.38
0.25	$2.36\pm 0.018$	2.34	0.09
0.5	$2.30\pm 0.016$	2.32	0.11
0.75	$2.35\pm 0.018$	2.34	0.36
0.875	$2.54\pm 0.022$	2.52	0.30
0.9375	$2.67\pm 0.026$	2.69	0.14
0.96875	$3.00\pm 0.034$	2.97	0.05
0.984375	$3.41\pm 0.043$	3.46	0.05
0.990234375	$3.79\pm 0.051$	3.80	0.74

and

Table 4. Average number of calls to $U(0,1)$ by $\rho \mu$’s BTPE implementation for $n=32$.

p	$\mathit{\rho }\mathit{\mu }$ Mean	Predicted	t-Test p-Value
0.3125	$3.83\pm 0.052$	3.84	0.76
0.5	$3.58\pm 0.046$	3.60	0.46
0.6875	$3.78\pm 0.050$	3.84	0.03

show the results for $n\in \{2^5,2^{10},2^{15},2^{20}\}$. These were chosen as representative cases. The raw and processed data for all cases are available on GitHub at https://github.com/cicirello/btpe-iterations (accessed on 8 August 2023). The empirical results confirm the analytical prediction of Equation (2). For all cases, there is no significant difference between the analytical prediction and the empirically computed means. t-test p-values are above 0.05 in almost all cases (well above in most cases). The small number of cases where the t-test p-values are less than 0.05 are explained by random chance. Due to random chance alone, at level 0.05, we should expect this for approximately 5% of cases. This occurred in 3 of the 72 cases represented in the tables (approximately 4% of cases).

Across all cases, the analytical prediction from Equation (2) indicates a maximum expected number of uniform variates of approximately 3.84 ($n=32$ and $p=0.3125$). The empirical maximum mean was 3.84 and the minimum was 2.25. Thus, although the average number of uniform variates needed by BTPE to generate one binomial variate fluctuates with n and p, it remains less than four even for very large n.

4. Discussion and Conclusions

Modeling and simulation applications in many domains require efficiently generating binomial random variates. The runtime of some algorithms for such generation grows with n or with $np$. For example, the average runtime of the inverse transform approach is $O\left(np\right)$. Other algorithms are quite fast even for large $np$, such as BTPE. BTPE’s runtime does vary based on n and p, as analyzed by its authors. However, in the empirical investigation in this paper, I complement the existing analytical results by showing that the average number of acceptance–rejection iterations is always less than two, even for large n and $np$, and that the average number of uniform variates needed to generate a single binomial is less than four. Thus, if generating a binomial random variate is a step of another algorithm, such steps can be treated as $O\left(1\right)$ in average case runtime analyses.

One limitation of this empirical study, as well as in the analytical expression of Equation (2), is that it considers the average case. The acceptance–rejection sampling cycle of BTPE can potentially run for longer. For example, during the experiments, the maximum number of uniform variates generated while producing a single binomial was 38 (19 iterations), compared to the average of less than 4. Longer runs of BTPE are not common. For example, during this study, 2.88 million binomial random variates were generated, and longer runs of BTPE were relatively rare occurrences. However, if you are analyzing the algorithmic complexity of an algorithm that uses BTPE as a subroutine, this result limits you to an average case analysis of that algorithm, rather than a worst case analysis. We may explore in the future whether it may be possible to compute an upper bound on the number of acceptance–rejection sampling iterations to resolve this limitation.