#include <stdlib.h>double drand48(void);double erand48(unsigned shortxsubi[3]);long int lrand48(void);long int nrand48(unsigned shortxsubi[3]);long int mrand48(void);long int jrand48(unsigned shortxsubi[3]);void srand48(long intseedval);unsigned short *seed48(unsigned shortseed16v[3]);void lcong48(unsigned shortparam[7]);

Feature Test Macro Requirements for glibc (see
**feature_test_macros**(7)):

All functions shown above: _SVID_SOURCE || _XOPEN_SOURCE

The
**drand48**()
and
**erand48**()
functions return nonnegative
double-precision floating-point values uniformly distributed between
[0.0, 1.0).

The
**lrand48**()
and
**nrand48**()
functions return nonnegative
long integers uniformly distributed between 0 and 2^31.

The
**mrand48**()
and
**jrand48**()
functions return signed long
integers uniformly distributed between -2^31 and 2^31.

The
**srand48**(),
**seed48**()
and
**lcong48**()
functions are
initialization functions, one of which should be called before using
**drand48**(),
**lrand48**()
or
**mrand48**().
The functions
**erand48**(),
**nrand48**()
and
**jrand48**()
do not require
an initialization function to be called first.

All the functions work by generating a sequence of 48-bit integers,
*Xi*, according to the linear congruential formula:

**Xn+1 = (aXn + c) mod m, where n >= 0**

The parameter *m* = 2^48, hence 48-bit integer arithmetic is performed.
Unless
**lcong48**()
is called, *a* and *c* are given by:

**a = 0x5DEECE66D****c = 0xB**

The value returned by any of the functions
**drand48**(),
**erand48**(),
**lrand48**(),
**nrand48**(),
**mrand48**()
or
**jrand48**()
is
computed by first generating the next 48-bit *Xi* in the sequence.
Then the appropriate number of bits, according to the type of data item to
be returned, is copied from the high-order bits of *Xi* and transformed
into the returned value.

The functions
**drand48**(),
**lrand48**()
and
**mrand48**()
store
the last 48-bit *Xi* generated in an internal buffer.
The functions
**erand48**(),
**nrand48**()
and
**jrand48**()
require the calling
program to provide storage for the successive *Xi* values in the array
argument *xsubi*.
The functions are initialized by placing the initial
value of *Xi* into the array before calling the function for the first
time.

The initializer function
**srand48**()
sets the high order 32-bits of
*Xi* to the argument *seedval*.
The low order 16-bits are set
to the arbitrary value 0x330E.

The initializer function
**seed48**()
sets the value of *Xi* to
the 48-bit value specified in the array argument *seed16v*.
The
previous value of *Xi* is copied into an internal buffer and a
pointer to this buffer is returned by
**seed48**().

The initialization function
**lcong48**()
allows the user to specify
initial values for *Xi*, *a* and *c*.
Array argument
elements *param[0-2]* specify *Xi*, *param[3-5]* specify
*a*, and *param[6]* specifies *c*.
After
**lcong48**()
has been called, a subsequent call to either
**srand48**()
or
**seed48**()
will restore the standard values of *a* and *c*.

- NAME
- SYNOPSIS
- DESCRIPTION
- CONFORMING TO
- NOTES
- SEE ALSO
- COLOPHON

Time: 21:45:16 GMT, April 16, 2011