# Generating Random Numbers

│
**Deutsch (de)** │
**English (en)** │
**suomi (fi)** │
**français (fr)** │

**Random numbers** are important resources for scientific applications, education, game development and visualization. They play a key role in numeric simulation.

Algorithm-generated random numbers are pseudo-random numbers. They belong to a (large) set of repeating numbers, whose sequence is impossible or at least difficult to predict. Unlike Delphi, that uses a linear congruential generator.(See Delphi compatible LCG Random), Free Pascal uses a MersenneTwister algorithm for its standard `random`

function as defined in RTL. Before its first use, FPC's random number generator has to be initialized with a single call of the `randomize`

function, which sets the seed of the generator. Preferably this is done in the launch phase of the program.

Alternatively, on Unix- and Linux-based systems, the virtual devices `/dev/random`

and `/dev/urandom`

are available. They generate (pseudo) random numbers based on hardware.

A third option is to use random numbers from external sources, either from specialised hardware devices or from public sources, e.g. based on radioactive decay data.

## Contents

## Uniform Distribution

The continuous uniform distribution (also referred to as rectangular distribution) represents a family of symmetric probability distributions. Here, for each member of the family all intervals of the same length on the distribution's support are equally probable.

The standard RTL function `random`

generates random numbers that fulfill a uniform distribution. If called without parameter `random`

delivers a floating point pseudorandom number in the interval [0, 1), i.e. 0 <= result < 1. if `random`

is called with a longint argument L it delivers a longint random in the interval [0, L).

A further set of uniformly distributed random number generators is presented in `Marsaglia's pseudo random number generators.`

Uniformly distributed random numbers are not useful for every application. In order to create random numbers of other distributions special algorithms are necessary:

## Normal (Gaussian) Distribution

One of the more common algorithms to produce normally distributed random numbers from uniformly distributed random numbers is the Box-Müller approach. The following function calculates Gaussian-distributed random numbers:

```
function rnorm (mean, sd: real): real;
{Calculates Gaussian random numbers according to the Box-Müller approach}
var
u1, u2: real;
begin
u1 := random;
u2 := random;
rnorm := mean * abs(1 + sqrt(-2 * (ln(u1))) * cos(2 * pi * u2) * sd);
end;
```

The same algorithm is used by the randg randg function from the RTL math unit:

`function randg(mean,stddev: float): float;`

## Exponential Distribution

An exponential distribution occurs frequently in real-world problems. A classical example is the distribution of waiting times between independent Poisson-random events, e.g. the radioactive decay of nuclei [Press et al. 1989].

The following function delivers a single real random number out of an exponential distribution. *Rate* is the inverse of the mean, and the constant *RESOLUTION* determines the granularity of generated random numbers.

```
function randomExp(a, rate: real): real;
const
RESOLUTION = 1000;
var
unif: real;
begin
if rate = 0 then
randomExp := NaN
else
begin
repeat
unif := random(RESOLUTION) / RESOLUTION;
until unif <> 0;
randomExp := a - rate * ln(unif);
end;
end;
```

## Gamma Distribution

The gamma distribution is a two-parameter family of continuous random distributions. It is a generalization of both the exponential distribution and the Erlang distribution. Possible applications of the gamma distribution include modelling and simulation of waiting lines, or queues, and actuarial science.

The following function delivers a single real random number out of a gamma distribution. The shape of the distribution is defined by the parameters *a*, *b* and *c*. The function makes use of the function **randomExp** as defined above.

```
function randomGamma(a, b, c: real): real;
const
RESOLUTION = 1000;
T = 4.5;
D = 1 + ln(T);
var
unif: real;
A2, B2, C2, Q, p, y: real;
p1, p2, v, w, z: real;
found: boolean;
begin
A2 := 1 / sqrt(2 * c - 1);
B2 := c - ln(4);
Q := c + 1 / A2;
C2 := 1 + c / exp(1);
found := False;
if c < 1 then
begin
repeat
repeat
unif := random(RESOLUTION) / RESOLUTION;
until unif > 0;
p := C2 * unif;
if p > 1 then
begin
repeat
unif := random(RESOLUTION) / RESOLUTION;
until unif > 0;
y := -ln((C2 - p) / c);
if unif <= power(y, c - 1) then
begin
randomGamma := a + b * y;
found := True;
end;
end
else
begin
y := power(p, 1 / c);
if unif <= exp(-y) then
begin
randomGamma := a + b * y;
found := True;
end;
end;
until found;
end
else if c = 1 then
{ Gamma distribution becomes exponential distribution, if c = 1 }
begin
randomGamma := randomExp(a, b);
end
else
begin
repeat
repeat
p1 := random(RESOLUTION) / RESOLUTION;
until p1 > 0;
repeat
p2 := random(RESOLUTION) / RESOLUTION;
until p2 > 0;
v := A2 * ln(p1 / (1 - p1));
y := c * exp(v);
z := p1 * p1 * p2;
w := B2 + Q * v - y;
if (w + D - T * z >= 0) or (w >= ln(z)) then
begin
randomGamma := a + b * y;
found := True;
end;
until found;
end;
end;
```

## Erlang Distribution

The Erlang distribution is a two parameter family of continuous probability distributions. It is a generalization of the exponential distribution and a special case of the gamma distribution, where *c* is an integer. The Erlang distribution has been first described by Agner Krarup Erlang in order to model the time interval between telephone calls. It is used for queuing theory and for simulating waiting lines.

```
function randomErlang(mean: real; k: integer): real;
const
RESOLUTION = 1000;
var
i: integer;
unif, prod: real;
begin
if (mean <= 0) or (k < 1) then
randomErlang := NaN
else
begin
prod := 1;
for i := 1 to k do
begin
repeat
unif := random(RESOLUTION) / RESOLUTION;
until unif <> 0;
prod := prod * unif;
end;
randomErlang := -mean * ln(prod);
end;
end;
```

## Poisson Distribution

The Poisson distribution applies to integer values. It represents the probability of *k* successes, when the probability of a success in each trial is small and the rate of occurrence (the mean value) is constant.

```
function randomPoisson(mean: integer): integer;
{ Generator for Poisson distribution (Donald Knuth's algorithm) }
const
RESOLUTION = 1000;
var
k: integer;
b, l: real;
begin
assert(mean > 0, 'mean < 1');
k := 0;
b := 1;
l := exp(-mean);
while b > l do
begin
k := k + 1;
b := b * random(RESOLUTION) / RESOLUTION;
end;
randomPoisson := k - 1;
end;
```

## t Distribution

The t distribution (also referred to a Student's t distribution, since it was published by William Sealy Gosset in 1908 under the pseudonym *Student*) is a continuous probability distribution. Its shape is defined by one parameter, the degrees of freedom (*df*). In statistics, many estimators are t distributed. Therefore, Student's t-distribution plays a major role in a number of widely used statistical analyses, including Student's t-test for assessing the statistical significance of the difference between two sample means, the construction of confidence intervals for the difference between two population means, and in linear regression analysis. The t-distribution also arises in Bayesian analysis of data from a normal family.

The following algorithm depends on the RTL function `random`

and on the **randomChisq** function

```
function randomT(df: integer): real;
{ Generator for Student's t distribution }
begin
if df < 1 then
randomT := NaN
else begin
randomT := randg(0, 1) / sqrt(randomChisq(df) / df);
end;
end;
```

## Chi Squared Distribution

The chi squared distribution is a continuous distribution of random numbers with *df* degrees of freedom. It is the distribution of a sum of the squares of *df* independent standard normal random variables. The chi squared distribution has numerous applications in inferential statistics, e.g. in estimating variances and for chi-squared tests. It is a special gamma distribution with *c* = *df*/ 2 and *b* = 2. Therefore the following function depends on the function **randomGamma**.

```
function randomChisq(df: integer): real;
begin
if df < 1 then
randomChisq := NaN
else
randomChisq := randomGamma(0, 2, 0.5 * df);
end;
```

## F Distribution

The F distribution, also referred to as Fisher-Snedecor distribution, is a continuous probability distribution. It is used for F Test and ANOVA. It has two degrees of freedom that serve as shape parameters *v* and *w* and that are positive integers. The following function **randomF** makes use of **randomChisq**.

```
function randomF(v, w: integer): real;
begin
if (v < 1) or (w < 1) then
randomF := NaN
else
randomF := randomChisq(v) / v / (randomChisq(w) / w);
end;
```

## See also

- Dev random
- Functions for descriptive statistics
- Marsaglia's pseudo random number generators
- A simple implementation of the Mersenne twister
- Delphi compatible LCG Random

## References

- G. E. P. Box and Mervin E. Muller,
*A Note on the Generation of Random Normal Deviates*, The Annals of Mathematical Statistics (1958), Vol. 29, No. 2 pp. 610–611 - Dietrich, J. W. (2002). Der Hypophysen-Schilddrüsen-Regelkreis. Berlin, Germany: Logos-Verlag Berlin. ISBN 978-3-89722-850-4. OCLC 50451543.
- Press, W. H., B. P. Flannery, S. A. Teukolsky, W. T. Vetterling (1989). Numerical Recipes in Pascal. The Art of Scientific Computing, Cambridge University Press, ISBN 0-521-37516-9.
- Richard Saucier, Computer Generation of Statistical Distributions, ARL-TR-2168, US Army Research Laboratory, Aberdeen Proving Ground, MD, 21005-5068, March 2000.
- R.U. Seydel, Generating Random Numbers with Specified Distributions. In: Tools for Computational Finance, Universitext, DOI 10.1007/978-1-4471-2993-6_2, © Springer-Verlag London Limited 2012
- Christian Walck, Hand-book on STATISTICAL DISTRIBUTIONS for experimentalists, Internal Report SUF–PFY/96–01, University of Stockholm 2007