RANDOM(3) | Library Functions Manual | RANDOM(3) |

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

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

December 9, 2014 | OpenBSD-current |