---
name: "random"
section: "3erl"
platform: "linux"
package: "erlang-manpages"
version: "1:25.2.3+dfsg-1+deb12u4"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/random/3erl"
---

# random(3erl)

Pseudo-random number generation.

## NAME

random - Pseudo-random number generation.

## DESCRIPTION

This module provides a random number generator. The method is attributed to B.A. Wichmann and I.D. Hill in 'An efficient and portable pseudo-random number generator', Journal of Applied Statistics. AS183. 1982. Also Byte March 1987.

The algorithm is a modification of the version attributed to Richard A. O'Keefe in the standard Prolog library.

Every time a random number is requested, a state is used to calculate it, and a new state is produced. The state can either be implicit (kept in the process dictionary) or be an explicit argument and return value. In this implementation, the state (the type *ran()*) consists of a tuple of three integers.

**Note:**

This random number generator is not cryptographically strong. If a strong cryptographic random number generator is needed, use one of functions in the *crypto* module, for example, *crypto:strong\_rand\_bytes/1*.

**Note:**

The improved *rand* module is to be used instead of this module.

## DATA TYPES

```
ran() = {integer(), integer(), integer()}
```

The state.

## EXPORTS

```
seed() -> ran()
```

Seeds random number generation with default (fixed) values in the process dictionary and returns the old state.

```
seed(SValue) -> undefined | ran()
```

Types:

SValue = {A1, A2, A3} \| integer()\
 A1 = A2 = A3 = integer()\

*seed({A1, A2, A3})* is equivalent to *seed(A1, A2, A3)*.

```
seed(A1, A2, A3) -> undefined | ran()
```

Types:

A1 = A2 = A3 = integer()\

Seeds random number generation with integer values in the process dictionary and returns the old state.

The following is an easy way of obtaining a unique value to seed with:

```
random:seed(erlang:phash2([node()]),
            erlang:monotonic_time(),
            erlang:unique_integer())
```

For details, see *erlang:phash2/1*, *erlang:node/0*, *erlang:monotonic\_time/0*, and *erlang:unique\_integer/0*.

```
seed0() -> ran()
```

Returns the default state.

```
uniform() -> float()
```

Returns a random float uniformly distributed between *0.0* and *1.0*, updating the state in the process dictionary.

```
uniform(N) -> integer() >= 1
```

Types:

N = integer() \>= 1\

Returns, for a specified integer *N \>= 1*, a random integer uniformly distributed between *1* and *N*, updating the state in the process dictionary.

```
uniform_s(State0) -> {float(), State1}
```

Types:

State0 = State1 = ran()\

Returns, for a specified state, a random float uniformly distributed between *0.0* and *1.0*, and a new state.

```
uniform_s(N, State0) -> {integer(), State1}
```

Types:

N = integer() \>= 1\
 State0 = State1 = ran()\

Returns, for a specified integer *N \>= 1* and a state, a random integer uniformly distributed between *1* and *N*, and a new state.

## NOTE

Some of the functions use the process dictionary variable *random\_seed* to remember the current seed.

If a process calls *uniform/0* or *uniform/1* without setting a seed first, *seed/0* is called automatically.

The implementation changed in Erlang/OTP R15. Upgrading to R15 breaks applications that expect a specific output for a specified seed. The output is still deterministic number series, but different compared to releases older than R15. Seed *{0,0,0}* does, for example, no longer produce a flawed series of only zeros.