Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
drand48(3C)		 Standard C Library Functions		   drand48(3C)

NAME
       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 xi[3] );

       long lrand48(void);

       long nrand48(unsigned short xi[3] );

       long mrand48(void);

       long jrand48(unsigned short xi[3] );

       void srand48(long seedval);

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

       void lcong48(unsigned short param[7] );

DESCRIPTION
       This family of functions	 generates  pseudo-random  numbers  using  the
       well-known linear congruential algorithm	and 48-bit integer arithmetic.

       Functions  drand48() and	erand48() return non-negative double-precision
       floating-point values uniformly distributed  over  the  interval	 [0.0,
       1.0).

       Functions  lrand48()  and  nrand48()  return non-negative long integers
       uniformly distributed over the interval [0, 2**31].

       Functions mrand48() and jrand48() return	signed long integers uniformly
       distributed over	the interval [-2**31 , 2**31 ].

       Functions  srand48(),  seed48(),	and lcong48() are initialization entry
       points, one  of	which  should  be  invoked  before  either  drand48(),
       lrand48(),  or  mrand48()  is  called.  (Although it is not recommended
       practice, constant default initializer values will be supplied automat-
       ically  if drand48(), lrand48(),	or mrand48() is	called without a prior
       call to an initialization entry point.) Functions erand48(), nrand48(),
       and jrand48() do	not require an initialization entry point to be	called
       first.

       All the routines	work by	generating a sequence of 48-bit	 integer  val-
       ues, Xi , according to the linear congruential formula

	       X n+1= (aX n+c)	mod m n>=0.

       The  parameter m	= 2**48; hence 48-bit integer arithmetic is performed.
       Unless lcong48()	has been invoked, the multiplier value aand the	addend
       value care given	by

		 a = 5DEECE66D16 = 2736731631558

		 c = B16 = 138 .

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

       The functions drand48(),	lrand48(), and mrand48() store the last	48-bit
       Xi generated in an internal buffer. Xi must be initialized prior	to be-
       ing invoked. The	functions erand48(), nrand48(),	and jrand48()  require
       the  calling program to provide storage for the successive Xi values in
       the array specified as an argument  when	 the  functions	 are  invoked.
       These  routines do not have to be initialized; the calling program must
       place the desired initial value of Xi into the array and	pass it	as  an
       argument. By using different arguments, functions erand48(), nrand48(),
       and jrand48() allow separate modules of a  large	 program  to  generate
       several	independent streams of pseudo-random numbers, that is, the se-
       quence of numbers in each stream	will not depend	upon  how  many	 times
       the  routines  have  been  called  to  generate	numbers	 for the other
       streams.

       The initializer function	srand48() sets the high-order 32 bits of Xi to
       the  32 bits contained in its argument. The low-order 16	bits of	Xi are
       set to the arbitrary value 330E16 .

       The initializer function	seed48() sets the value	of Xi  to  the	48-bit
       value  specified	in the argument	array. In addition, the	previous value
       of Xi is	copied into a 48-bit internal buffer, used only	 by  seed48(),
       and  a  pointer	to this	buffer is the value returned by	seed48(). This
       returned	pointer, which can just	be ignored if not needed, is useful if
       a  program is to	be restarted from a given point	at some	future time --
       use the pointer to get at and store the last Xi	value,	and  then  use
       this   value  to	 reinitialize  using  seed48()	when  the  program  is
       restarted.

       The initialization function lcong48() allows the	user  to  specify  the
       initial Xi the multiplier value a, and the addend value c. Argument ar-
       ray elements param[0-2] specify Xi, param[3-5] specify  the  multiplier
       a, and param[6] specifies the 16-bit addend c. After lcong48() has been
       called, a subsequent call to either srand48() or	seed48() will  restore
       the  ``standard''  multiplier  and  addend  values,  a and c, specified
       above.

ATTRIBUTES
       See attributes(5) for descriptions of the following attributes:

       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Standard			   |
       +-----------------------------+-----------------------------+
       |MT-Level		     |Safe			   |
       +-----------------------------+-----------------------------+

SEE ALSO
       rand(3C), attributes(5),	standards(5)

SunOS 5.10			  24 Jul 2002			   drand48(3C)

NAME | SYNOPSIS | DESCRIPTION | ATTRIBUTES | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=drand48&sektion=3c&manpath=SunOS+5.10>

home | help