![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to drand48.3l CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / 630 / man / src / p_man / man3|
Return to drand48.3l CVS log | Up to [Research Unix] / researchv10dc / 630 / man / src / p_man / man3 |
1.1 root 1: .TH DRAND48 3L "630 MTG"
2: .SH NAME
3: drand48, erand48, lrand48, nrand48, mrand48, jrand48, srand48, seed48, lcong48 \- generate uniformly distributed pseudo-random numbers
4: .SH SYNOPSIS
5: .EQ
6: delim $$
7: .EN
8: .B double drand48 ( )
9: .sp
10: \f3double erand48 ( xsubi )\f1
11: .br
12: \f3unsigned short xsubi [3];\f1
13: .sp
14: .B long lrand48 ( )
15: .sp
16: \f3long nrand48 ( xsubi )\f1
17: .br
18: \f3unsigned short xsubi [3];\f1
19: .sp
20: .B long mrand48 ( )
21: .sp
22: \f3long jrand48 ( xsubi )\f1
23: .br
24: \f3unsigned short xsubi [3];\f1
25: .sp
26: .B void srand48 (seedval)
27: .br
28: .B long seedval;
29: .sp
30: .B unsigned short \(**seed48 (seed16v)
31: .br
32: .B unsigned short seed16v[3];
33: .sp
34: .B void lcong48 (param)
35: .br
36: .B unsigned short param[7];
37: .SH DESCRIPTION
38: .EQ
39: delim $$
40: .EN
41: This family of functions generates pseudo-random numbers using the
42: well-known linear congruential algorithm and 48-bit integer arithmetic.
43: .PP
44: Functions
45: .I drand48\^
46: and
47: .I erand48\^
48: return non-negative double-precision floating-point values
49: uniformly distributed over the interval $[0.0,~1.0).$
50: .PP
51: Functions
52: .I lrand48\^
53: and
54: .I nrand48\^
55: return non-negative long integers uniformly distributed over the
56: interval $[0,~2 sup 31 ).$
57: .PP
58: Functions
59: .I mrand48\^
60: and
61: .I jrand48\^
62: return signed long integers uniformly distributed over the interval
63: $[-2 sup 31 ,~2 sup 31 ).$
64: .PP
65: Functions
66: .I srand48, seed48\^
67: and
68: .I lcong48\^
69: are initialization entry points, one of which should be invoked before
70: either
71: .I drand48, lrand48\^
72: or
73: .I mrand48\^
74: is called.
75: (Although it is not recommended practice,
76: constant default initializer values will be supplied automatically if
77: .I drand48, lrand48\^
78: or
79: .I mrand48\^
80: is called without a prior call to an initialization entry point.)
81: Functions
82: .I erand48, nrand48\^
83: and
84: .I jrand48\^
85: do not require an initialization entry point to be called first.
86: .PP
87: All the routines work by generating a sequence of 48-bit integer values,
88: $X sub i ,$ according to the linear congruential formula
89: .PP
90: .ce
91: .EQ I
92: X sub{n+1}~=~(aX sub n^+^c) sub{roman mod~m}~~~~~~~~n>=0.
93: .EN
94: .PP
95: The parameter $m^=^2 sup 48$; hence 48-bit integer arithmetic is
96: performed.
97: Unless
98: .I lcong48\^
99: has been invoked, the multiplier value $a$ and the addend value $c$
100: are given by
101: .PP
102: .RS 6
103: .EQ I
104: a~mark =~roman 5DEECE66D^sub 16~=~roman 273673163155^sub 8
105: .EN
106: .br
107: .EQ I
108: c~lineup =~roman B^sub 16~=~roman 13^sub 8 .
109: .EN
110: .RE
111: .PP
112: The value returned by any of the functions
113: .I drand48, erand48, lrand48, nrand48, mrand48\^
114: or
115: .I jrand48\^
116: is computed by first generating the next 48-bit $X sub i$ in the sequence.
117: Then the appropriate number of bits, according to the type of data item
118: to be returned, are copied from the high-order (leftmost) bits of $X sub i$
119: and transformed into the returned value.
120: .PP
121: The functions
122: .I drand48, lrand48\^
123: and
124: .I mrand48\^
125: store the last 48-bit $X sub i$ generated in an internal buffer,
126: and must be initialized prior to being invoked.
127: The functions
128: .I erand48, nrand48\^
129: and
130: .I jrand48\^
131: require the calling program to provide storage for the
132: successive $X sub i$ values in the array
133: specified as an argument when the functions are invoked.
134: These routines do not have to be initialized; the calling
135: program must place the desired initial value of $X sub i$ into the
136: array and pass it as an argument.
137: By using different
138: arguments, functions
139: .I erand48, nrand48\^
140: and
141: .I jrand48\^
142: allow separate modules of a large program to generate several
143: .I independent\^
144: streams of pseudo-random numbers, i.e., the sequence of numbers
145: in each stream will
146: .I not\^
147: depend upon how many times the routines have been called to generate
148: numbers for the other streams.
149: .PP
150: The initializer function
151: .I srand48\^
152: sets the high-order 32 bits of $X sub i$ to the 32 bits contained in
153: its argument.
154: The low-order 16 bits of $X sub i$ are set to the arbitrary value
155: $roman 330E sub 16 .$
156: .PP
157: The initializer function
158: .I seed48\^
159: sets the value of $X sub i$ to the 48-bit value specified in the
160: argument array.
161: In addition, the previous value of $X sub i$ is copied into a 48-bit
162: internal buffer, used only by
163: .I seed48,\^
164: and a pointer to this buffer is the value returned by
165: .I seed48.\^
166: This returned pointer, which can just be ignored if not needed, is useful
167: if a program is to be restarted from a given point at some future time
168: \(em use the pointer to get at and store the last $X sub i$ value, and
169: then use this value to reinitialize via
170: .I seed48\^
171: when the program is restarted.
172: .PP
173: The initialization function
174: .I lcong48\^
175: allows the user to specify the initial $X sub i ,$ the multiplier value
176: $a,$ and the addend value $c.$
177: Argument array elements
178: .I param[0-2]\^
179: specify $X sub i ,$
180: .I param[3-5]\^
181: specify the multiplier $a,$ and
182: .I param[6]\^
183: specifies the 16-bit addend $c.$
184: After
185: .I lcong48\^
186: has been called, a subsequent call to either
187: .I srand48\^
188: or
189: .I seed48\^
190: will restore the ``standard'' multiplier and addend values, $a$ and $c,$
191: specified on the previous page.
192: .SH "SEE ALSO"
193: rand(3L).
194: .Ee
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.