real function slaran ( integer, dimension( 4 ) ISEED )

SLARAN

Purpose:

 SLARAN returns a random real number from a uniform (0,1)
 distribution.

Parameters

[in,out]

ISEED

          ISEED is INTEGER array, dimension (4)
          On entry, the seed of the random number generator; the array
          elements must be between 0 and 4095, and ISEED(4) must be
          odd.
          On exit, the seed is updated.

Author: Univ. of Tennessee; Univ. of California Berkeley; Univ. of Colorado Denver; NAG Ltd.

Date: November 2011

Further Details:

  This routine uses a multiplicative congruential method with modulus
  2**48 and multiplier 33952834046453 (see G.S.Fishman,
  'Multiplicative congruential random number generators with modulus
  2**b: an exhaustive analysis for b = 32 and a partial analysis for
  b = 48', Math. Comp. 189, pp 331-344, 1990).

  48-bit integers are stored in 4 integer array elements with 12 bits
  per element. Hence the routine is portable across machines with
  integers of 32 bits or more.

Definition at line 69 of file slaran.f.

 *
 *  -- LAPACK auxiliary routine (version 3.4.0) --
 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
 *     November 2011
 *
 *     .. Array Arguments ..
       INTEGER            iseed( 4 )
 *     ..
 *
 *  =====================================================================
 *
 *     .. Parameters ..
       INTEGER            m1, m2, m3, m4
       parameter                ( m1 = 494, m2 = 322, m3 = 2508, m4 = 2549 )
       REAL               one
       parameter                ( one = 1.0e+0 )
       INTEGER            ipw2
       REAL               r
       parameter                ( ipw2 = 4096, r = one / ipw2 )
 *     ..
 *     .. Local Scalars ..
       INTEGER            it1, it2, it3, it4
       REAL               rndout
 *     ..
 *     .. Intrinsic Functions ..
       INTRINSIC          mod, real
 *     ..
 *     .. Executable Statements ..
   10  CONTINUE
 *
 *     multiply the seed by the multiplier modulo 2**48
 *
       it4 = iseed( 4 )*m4
       it3 = it4 / ipw2
       it4 = it4 - ipw2*it3
       it3 = it3 + iseed( 3 )*m4 + iseed( 4 )*m3
       it2 = it3 / ipw2
       it3 = it3 - ipw2*it2
       it2 = it2 + iseed( 2 )*m4 + iseed( 3 )*m3 + iseed( 4 )*m2
       it1 = it2 / ipw2
       it2 = it2 - ipw2*it1
       it1 = it1 + iseed( 1 )*m4 + iseed( 2 )*m3 + iseed( 3 )*m2 +
      $      iseed( 4 )*m1
       it1 = mod( it1, ipw2 )
 *
 *     return updated seed
 *
       iseed( 1 ) = it1
       iseed( 2 ) = it2
       iseed( 3 ) = it3
       iseed( 4 ) = it4
 *
 *     convert 48-bit integer to a real number in the interval (0,1)
 *
       rndout = r*( REAL( it1 )+r*( REAL( it2 )+r*( REAL( it3 )+r*
      $         ( REAL( IT4 ) ) ) ) )
 *
       IF (rndout.EQ.1.0) THEN
 *        If a real number has n bits of precision, and the first
 *        n bits of the 48-bit integer above happen to be all 1 (which
 *        will occur about once every 2**n calls), then SLARAN will
 *        be rounded to exactly 1.0. In IEEE single precision arithmetic,
 *        this will happen relatively often since n = 24.
 *        Since SLARAN is not supposed to return exactly 0.0 or 1.0
 *        (and some callers of SLARAN, such as CLARND, depend on that),
 *        the statistically correct thing to do in this situation is
 *        simply to iterate again.
 *        N.B. the case SLARAN = 0.0 should not be possible.
 *
          GOTO 10
       END IF
 *
       slaran = rndout
       RETURN
 *
 *     End of SLARAN
 *