```
drand48,  erand48,  lrand48,  nrand48,  mrand48,  jrand48,
srand48, seed48, lcong48 - generate uniformly  distributed
pseudo-random numbers

```

## SYNOPSIS

```       #include <stdlib.h>

double drand48(void);

double erand48(unsigned short int xsubi[3]);

long int lrand48(void);

long int nrand48(unsigned short int xsubi[3]);

long int mrand48(void);

long int jrand48(unsigned short int xsubi[3]);

void srand48(long int seedval);

unsigned short int *seed48(unsignedshortint seed16v [3]);

void lcong48(unsigned short int param[7]);

```

## DESCRIPTION

```       These  functions  generate pseudo-random numbers using the
linear congruential algorithm and  48-bit  integer  arith­
metic.

The  drand48() and erand48() functions return non-negative
double-precision  floating-point  values  uniformly   dis­
tributed between [0.0, 1.0).

The  lrand48() and nrand48() functions return non-negative
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 ini­
tialization functions,  one  of  which  should  be  called
before using drand48(), lrand48() or mrand49().  The func­
tions 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  for­
mula:

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

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 func­
tions erand48(), nrand48() and jrand48() require the call­
ing program to provide storage for the successive Xi  val­
ues  in  the array argument xsubi.  The functions are ini­
tialized 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.

```

## CONFORMING TO

```       SVID 3

```

## NOTES

```       These  functions  are  declared  obsolete by SVID 3, which
states that rand(3) should be used instead.

```

```       rand(3), random(3)