Museum

Home

Lab Overview

Retrotechnology Articles

⇒ Online Manual

Media Vault

Software Library

Restoration Projects

Artifacts Sought

Related Articles

rand(3)



  drand48(3)                          CLIX                          drand48(3)



  NAME

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

  LIBRARY

    Standard C Library (libc.a)

  SYNOPSIS

    double drand48(
      void );

    double erand48(
      unsigned short xsubi[3] );

    longlrand48(
      void );

    longnrand48(
      unsigned short xsubi[3] );

    longmrand48(
      void );

    longjrand48(
      unsigned short xsubi[3] );

    void srand48(
      long seedval );

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

    void lcong48(
      unsigned short param[7] );

  PARAMETERS

    xsubi     For erand48, nrand48, and jrand48 the subi parameter specifies
              the initial 48 bit value for xsubi in the equation used to
              generate the random numbers.

    seedval   The value given in srand48 seedval sets the high order 32 bits
              of the initial value of xsubi used in the random number
              equation.

    seed16v   The seed seed16v sets the initial 48 bit value for xsubi used in
              the random number.




  2/94 - Intergraph Corporation                                              1






  drand48(3)                          CLIX                          drand48(3)



    param     The lcong48 param[0] - param[2] specifies the xsubi for the
              equation, param[3] - param[5] specify the multiplier 'a' to be
              used in the equation.  The param[6] specifies the addend 'c' to
              be used.

  DESCRIPTION

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

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

    The functions lrand48() and nrand48() return non-negative long integers
    uniformly distributed over the interval [0,2^31).

    The functions mrand48() and jrand48() return signed long integers
    uniformly distributed over the interval [-2^31,2^31).

    The 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 automatically 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 functions work by generating a sequence of 48-bit integer values,
    (xsubi, according to the linear congruential formula

                         Xn+1 = (aXn+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 a and the addend
    value c are 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
    generating the next 48-bit xsubi 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 xsubi and transformed into
    the returned value.

    The functions drand48(), lrand48() and mrand48() store the last 48-bit
    xsubi generated in an internal buffer, and must be initialized prior to
    being invoked.  The functions erand48(), nrand48() and jrand48() require
    the calling program to provide storage for the successive xsubi values in
    the array specified as an argument when the functions are invoked.  These



  2                                              Intergraph Corporation - 2/94






  drand48(3)                          CLIX                          drand48(3)



    functions do not have to be initialized; the calling program must place
    the desired initial value of xsubi into the array and pass it as an
    argument.  By using different arguments, the functions erand48(),
    nrand48() and jrand48() allow separate modules of a large program to
    generate several independent streams of pseudo-random numbers, that is,
    the sequence of numbers in each stream will not depend upon how many times
    the functions have been called to generate numbers for the other streams.

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

    The initializer function seed48() sets the value of xsubi to the 48-bit
    value specified in the argument array.  In addition, the previous value of
    xsubi 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 xsubi value, and then use this value
    to reinitialize with seed48() when the program is restarted.

    The initialization function lcong48() allows the user to specify the
    initial xsubi, the multiplier value a, and the addend value c.  Argument
    array elements param[0-2] specify xsubi, 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 on the
    previous page.

  EXAMPLES

    get_random (random)
         {
         double *random;
         double erand48();
         unsigned short xsubi[3];
         /* setup initial value of xi */
         xsubi[1] = 1024;
         xsubi[2] = 962;
         xsubi[3] = 2946;

         /* get the random number */
         *random = erand48(xsubi);
         }


  NOTES

    The source code for the portable version can be used on computers which do
    not have floating-point arithmetic.  In such a situation, functions
    drand48() and erand48() are replaced by the two new functions below.



  2/94 - Intergraph Corporation                                              3






  drand48(3)                          CLIX                          drand48(3)



    long irand48(
      unsigned short m );

    long krand48(
      unsigned short xsubi[3] ,
      unsigned short m );

  RETURN VALUES

    The functions irand48() and krand48() return non-negative long integers
    uniformly distributed over the interval [0,m-1].  The functions drand48
    and erand48 return non-negative double precision floating-point values
    uniformly distributed over the interval [0.0-1.0).  The functions lrand48
    and nrand48 return non-negative long integers uniformly distributed over
    the interval [0,2^31).  The functions mrand48 and jrand48 returns long
    signed integers uniformly distributed over the interval [-2^31,2^31).  The
    functions srand48 and lcong48 do not return a value.  The function seed48
    returns a pointer to the buffer storing the value to be used as Xi in the
    random number equation.

  RELATED INFORMATION

    Functions:  rand(3)































  4                                              Intergraph Corporation - 2/94




Typewritten Software • bear@typewritten.org • Edmonds, WA 98026