## Pseudo-random number generation.

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.

#### Functions

### seed() -> ran()

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

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

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

`A1 = A2 = A3 = integer()`

`seed({`

is equivalent to
`seed(`

.

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

`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

`N = integer() >= 1`

Returns, for a specified integer

,
a random integer uniformly distributed between `1`

and

, updating the state in the process
dictionary.

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

`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}

`N = integer() >= 1`

`State0 = State1 = ran()`

Returns, for a specified integer

and a
state, a random integer uniformly distributed between `1`

and

, 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.