drand48(3C)                                           drand48(3C)



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

     SYNOPSIS
          double drand48()

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

          long lrand48()

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

          long mrand48()

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

          void srand48(seedval)
          long seedval;

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

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

     DESCRIPTION
          This family of functions generates pseudo-random numbers us-
          ing 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 in-
                                                              31
          tegers uniformly distributed over the interval [0, 2  ).

          Functions mrand48 and jrand48 return signed long integers
                                                     31   31
          uniformly distributed over the interval [-2  , 2  ).  Func-
          tions srand48,seed48, and lcong48 are initialization entry
          points, one of which should be invoked before
          drand48,lrand48, or mrand48 is called.  (Although it is not
          recommended practice, constant default initializer values
          are 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 re-
          quire an initialization entry point to be called first.



     April, 1990                                                     1

     drand48(3C)                                           drand48(3C)



          All the routines work by generating a sequence of 48-bit in-
          teger values, X , according to the linear congruential for-
                         i
          mula

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

                             48
          The parameter m = 2  ; 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 = 5DEECE66D   =-273673163155
                            16               8
               c = B   = 13 .
                    16     8

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

          The functions drand48, lrand48, and mrand48 store the last
          48-bit X  generated in an internal buffer; that is why they
                  i
          must be initialized prior to being invoked.  The functions
          erand48 , nrand48, and jrand48 require the calling program
          to provide storage for the successive X  values in the array
                                                 i
          specified as an argument when the functions are invoked.
          That is why these routines do not have to be initialized;
          the calling program merely has to place the desired initial
          value of X  into the array and pass it as an argument.  By
                    i
          using different arguments, functions erand48, nrand48, and
          jrand48 allow separate modules of a large program to gen-
          erate several independent streams of pseudo-random numbers,
          i.e., the sequence of numbers in each stream does not depend
          upon how many times the routines have been called to gen-
          erate numbers for the other streams.

          The initializer function srand48 sets the high-order 32 bits
          of X  to the 32 bits contained in its argument.  The low-
              i
          order 16 bits of X  are set to the arbitrary value 330E  .
                            i                                    16

          The initializer function seed48 sets the value of X  to the
                                                             i
          48-bit value specified in the argument array.  The previous
          value of X  is copied into a 48-bit internal buffer, used
                    i
          only by seed48.  A pointer to this buffer is the value re-
          turned by seed48 . The returned pointer, which can be ig-
          nored if not needed, is useful if a program is to be res-
          tarted from a given point at some future time.  Use the
          pointer to get and store the last X  value; then use this
                                             i
          value to reinitialize via seed48 when the program is res-
          tarted.





     2                                                     April, 1990

     drand48(3C)                                           drand48(3C)



          The initialization function lcong48 allows the user to
          specify the initial X , the multiplier value a, and the ad-
                               i
          dend value c.  Argument array elements param[0-2] specify
          X , elements param[3-5] specify the multiplier a, and
           i
          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.

     NOTES
          The routines are coded in portable C.  The source code for
          the portable version can even be used on computers which do
          not have floating-point arithmetic.  In such a situation,
          functions drand48 and erand48 do not exist; instead, they
          are replaced by the following two functions:

               long irand48 (m)
               unsigned short m;

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

          Functions irand48 and krand48 return non-negative long in-
          tegers uniformly distributed over the interval [0, m-1].

     SEE ALSO
          rand(3C).




























     April, 1990                                                     3