# rand

## Pseudo random number generation.

This module provides a random number generator. The module contains
a number of algorithms. The uniform distribution algorithms use the

The following algorithms are provided:

`exsplus`

Xorshift116+, 58 bits precision and period of 2^116-1

`exs64`

Xorshift64*, 64 bits precision and a period of 2^64-1

`exs1024`

Xorshift1024*, 64 bits precision and a period of 2^1024-1

The default algorithm is `exsplus`

. If a specific algorithm is
required, ensure to always use
`seed/1`

to initialize the state.

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 or be an explicit argument and return value.

The functions with implicit state use the process dictionary
variable `rand_seed`

to remember the current state.

If a process calls
`uniform/0`

or
`uniform/1`

without
setting a seed first, `seed/1`

is called automatically with the default algorithm and creates a
non-constant seed.

The functions with explicit state never use the process dictionary.

*Examples:*

Simple use; creates and seeds the default algorithm with a non-constant seed if not already done:

R0 = rand:uniform(), R1 = rand:uniform(),

Use a specified algorithm:

_ = rand:seed(exs1024), R2 = rand:uniform(),

Use a specified algorithm with a constant seed:

_ = rand:seed(exs1024, {123, 123534, 345345}), R3 = rand:uniform(),

Use the functional API with a non-constant seed:

S0 = rand:seed_s(exsplus), {R4, S1} = rand:uniform_s(S0),

Create a standard normal deviate:

{SND0, S2} = rand:normal_s(S1),

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

.

#### Types

### alg() = exs64 | exsplus | exs1024

### state()

Algorithm-dependent state.

### export_state()

Algorithm-dependent state that can be printed or saved to file.

#### Functions

### export_seed() -> undefined | export_state()

Returns the random number state in an external format.
To be used with `seed/1`

.

### export_seed_s(X1 :: state()) -> export_state()

Returns the random number generator state in an external format.
To be used with `seed/1`

.

### normal() -> float()

Returns a standard normal deviate float (that is, the mean is 0 and the standard deviation is 1) and updates the state in the process dictionary.

### normal_s(State0 :: state()) -> {float(), NewS :: state()}

Returns, for a specified state, a standard normal deviate float (that is, the mean is 0 and the standard deviation is 1) and a new state.

### seed(AlgOrExpState :: alg() | export_state()) -> state()

Seeds random number generation with the specifed algorithm and
time-dependent data if

Otherwise recreates the exported seed in the process dictionary,
and returns the state. See also
`export_seed/0`

.

### seed(Alg :: alg(), S0 :: {integer(), integer(), integer()}) ->

state()

Seeds random number generation with the specified algorithm and integers in the process dictionary and returns the state.

### seed_s(AlgOrExpState :: alg() | export_state()) -> state()

Seeds random number generation with the specifed algorithm and
time-dependent data if

Otherwise recreates the exported seed and returns the state.
See also
`export_seed/0`

.

### seed_s(Alg :: alg(), S0 :: {integer(), integer(), integer()}) ->

state()

Seeds random number generation with the specified algorithm and integers and returns the state.

### uniform() -> X :: float()

Returns a random float uniformly distributed in the value
range `0.0 < `

and
updates the state in the process dictionary.

### uniform(N :: integer() >= 1) -> X :: integer() >= 1

Returns, for a specified integer

,
a random integer uniformly distributed in the value range
`1 <= `

and
updates the state in the process dictionary.