**random**,

**srandom**,

**srandom_deterministic**,

**srandomdev**,

**initstate**,

**setstate**
—

pseudo-random number generator; routines
for changing generators
**#include
<stdlib.h>**
`long`
**random**(

`void`);

`void`
**srandom**(

`unsigned
int seed`);

`void`
**srandom_deterministic**(

`unsigned
int seed`);

`void`
**srandomdev**(

`void`);

`char *`
**initstate**(

`unsigned
int seed`,

`char
*state`,

`size_t
n`);

`char *`
**setstate**(

`char
*state`);

Standards insist
that this interface return deterministic results. Unsafe usage is very common,
so OpenBSD changed the subsystem to return
non-deterministic results by default.

To satisfy portable code,

**srandom**() or

**srandomdev**() may be called to initialize the
subsystem. In

OpenBSD the

`seed` variable is ignored, and strong random
number results will be provided from

arc4random(3). In other
systems, the

`seed` variable primes a
simplistic deterministic algorithm.

If the standardized behavior is required

**srandom_deterministic**() can be substituted for

**srandom**(), then subsequent

**random**() calls will return results using the
deterministic algorithm.

In non-deterministic (default) mode, the

**random**()
function returns results from

arc4random(3) in the range
from 0 to (2**31)-1.

In deterministic mode, the

**random**() function uses a
non-linear additive feedback random number generator employing a default table
of size 31 long integers to return successive pseudo-random numbers in the
range from 0 to (2**31)-1. The period of this random number generator is very
large, approximately 16*((2**31)-1), but the results are a deterministic
sequence from the seed.

The

**initstate**() routine allows a state array,
passed in as an argument, to be initialized for future use. The size of the
state array (in bytes) is used by

**initstate**() to
decide how sophisticated a random number generator it should use — the
more state, the better the random numbers will be. (Current
"optimal" values for the amount of state information are 8, 32, 64,
128, and 256 bytes; other amounts will be rounded down to the nearest known
amount. Using less than 8 bytes will cause an error.) The seed for the
initialization (which specifies a starting point for the random number
sequence, and provides for restarting at the same point) is also an argument.
The

**initstate**() function returns a pointer to the
previous state information array.

Once a state has been initialized, the

**setstate**()
routine provides for rapid switching between states. The

**setstate**() function returns a pointer to the
previous state array; its argument state array is used for further random
number generation until the next call to

**initstate**() or

**setstate**().

Once a state array has been initialized, it may be restarted at a different
point either by calling

**initstate**() (with the
desired seed, the state array, and its size) or by calling both

**setstate**() (with the state array) and

**srandom**() (with the desired seed). The advantage
of calling both

**setstate**() and

**srandom**() is that the size of the state array
does not have to be remembered after it is initialized.

Use of

**srandom_deterministic**(),

**initstate**(), or

**setstate**() forces the subsystem into
deterministic mode.

If

**initstate**() is called with less than 8 bytes of
state information, or if

**setstate**() detects that
the state information has been garbled, error messages are printed on the
standard error output.

arc4random(3),

drand48(3),

rand(3),

random(4)
The

**random**(),

**initstate**(), and

**setstate**() functions conform to

X/Open Portability Guide Issue 4,
Version 2 (“XPG4.2”).

The

**srandom**() function does not conform to

X/Open Portability Guide Issue 4,
Version 2 (“XPG4.2”), intentionally.

The

**srandomdev**() function is an extension.

The

**srandom_deterministic**() function is an

OpenBSD extension.

These functions appeared in

4.2BSD.

Earl T. Cohen