## table of contents

- bookworm 1:25.2.3+dfsg-1
- testing 1:25.3.2.8+dfsg-1
- unstable 1:25.3.2.8+dfsg-1
- experimental 1:26.2.1+dfsg-1

random(3erl) | Erlang Module Definition | random(3erl) |

# 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:**

*crypto*module, for example,

*crypto:strong_rand_bytes/1*.

**Note:**

*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:

A1 = A2 = A3 = integer()

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

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

Types:

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:

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:

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:

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.

stdlib 5.2 | Ericsson AB |