LAPACK  3.9.1
LAPACK: Linear Algebra PACKage

◆ slaran()

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.
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 66 of file slaran.f.

67 *
68 * -- LAPACK auxiliary routine --
69 * -- LAPACK is a software package provided by Univ. of Tennessee, --
70 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
71 *
72 * .. Array Arguments ..
73  INTEGER ISEED( 4 )
74 * ..
75 *
76 * =====================================================================
77 *
78 * .. Parameters ..
79  INTEGER M1, M2, M3, M4
80  parameter( m1 = 494, m2 = 322, m3 = 2508, m4 = 2549 )
81  REAL ONE
82  parameter( one = 1.0e+0 )
83  INTEGER IPW2
84  REAL R
85  parameter( ipw2 = 4096, r = one / ipw2 )
86 * ..
87 * .. Local Scalars ..
88  INTEGER IT1, IT2, IT3, IT4
89  REAL RNDOUT
90 * ..
91 * .. Intrinsic Functions ..
92  INTRINSIC mod, real
93 * ..
94 * .. Executable Statements ..
95  10 CONTINUE
96 *
97 * multiply the seed by the multiplier modulo 2**48
98 *
99  it4 = iseed( 4 )*m4
100  it3 = it4 / ipw2
101  it4 = it4 - ipw2*it3
102  it3 = it3 + iseed( 3 )*m4 + iseed( 4 )*m3
103  it2 = it3 / ipw2
104  it3 = it3 - ipw2*it2
105  it2 = it2 + iseed( 2 )*m4 + iseed( 3 )*m3 + iseed( 4 )*m2
106  it1 = it2 / ipw2
107  it2 = it2 - ipw2*it1
108  it1 = it1 + iseed( 1 )*m4 + iseed( 2 )*m3 + iseed( 3 )*m2 +
109  $ iseed( 4 )*m1
110  it1 = mod( it1, ipw2 )
111 *
112 * return updated seed
113 *
114  iseed( 1 ) = it1
115  iseed( 2 ) = it2
116  iseed( 3 ) = it3
117  iseed( 4 ) = it4
118 *
119 * convert 48-bit integer to a real number in the interval (0,1)
120 *
121  rndout = r*( real( it1 )+r*( real( it2 )+r*( real( it3 )+r*
122  $ ( real( it4 ) ) ) ) )
123 *
124  IF (rndout.EQ.1.0) THEN
125 * If a real number has n bits of precision, and the first
126 * n bits of the 48-bit integer above happen to be all 1 (which
127 * will occur about once every 2**n calls), then SLARAN will
128 * be rounded to exactly 1.0. In IEEE single precision arithmetic,
129 * this will happen relatively often since n = 24.
130 * Since SLARAN is not supposed to return exactly 0.0 or 1.0
131 * (and some callers of SLARAN, such as CLARND, depend on that),
132 * the statistically correct thing to do in this situation is
133 * simply to iterate again.
134 * N.B. the case SLARAN = 0.0 should not be possible.
135 *
136  GOTO 10
137  END IF
138 *
139  slaran = rndout
140  RETURN
141 *
142 * End of SLARAN
143 *
real function slaran(ISEED)
SLARAN
Definition: slaran.f:67
Here is the caller graph for this function: