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

#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?);

These functions generate pseudo-random numbers using the linear congruential algorithm and 48-bit integer arithmetic.

The **drand48()** and **erand48()** functions return non-negative double-precision floating-point values uniformly distributed 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 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

SVID 3

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

10 pages link to drand48(3):

This page is a man page (or other imported legacy content). We are unable to automatically determine the license status of this page.