Python code coverage for Lib/random.py

#	count	content
1	n/a	"""Random variable generators.
2	n/a
3	n/a	integers
4	n/a	--------
5	n/a	uniform within range
6	n/a
7	n/a	sequences
8	n/a	---------
9	n/a	pick random element
10	n/a	pick random sample
11	n/a	pick weighted random sample
12	n/a	generate random permutation
13	n/a
14	n/a	distributions on the real line:
15	n/a	------------------------------
16	n/a	uniform
17	n/a	triangular
18	n/a	normal (Gaussian)
19	n/a	lognormal
20	n/a	negative exponential
21	n/a	gamma
22	n/a	beta
23	n/a	pareto
24	n/a	Weibull
25	n/a
26	n/a	distributions on the circle (angles 0 to 2pi)
27	n/a	---------------------------------------------
28	n/a	circular uniform
29	n/a	von Mises
30	n/a
31	n/a	General notes on the underlying Mersenne Twister core generator:
32	n/a
33	n/a	* The period is 2**19937-1.
34	n/a	* It is one of the most extensively tested generators in existence.
35	n/a	* The random() method is implemented in C, executes in a single Python step,
36	n/a	and is, therefore, threadsafe.
37	n/a
38	n/a	"""
39	n/a
40	n/a	from warnings import warn as _warn
41	n/a	from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
42	n/a	from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
43	n/a	from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
44	n/a	from os import urandom as _urandom
45	n/a	from _collections_abc import Set as _Set, Sequence as _Sequence
46	n/a	from hashlib import sha512 as _sha512
47	n/a	import itertools as _itertools
48	n/a	import bisect as _bisect
49	n/a
50	n/a	__all__ = ["Random","seed","random","uniform","randint","choice","sample",
51	n/a	"randrange","shuffle","normalvariate","lognormvariate",
52	n/a	"expovariate","vonmisesvariate","gammavariate","triangular",
53	n/a	"gauss","betavariate","paretovariate","weibullvariate",
54	n/a	"getstate","setstate", "getrandbits", "choices",
55	n/a	"SystemRandom"]
56	n/a
57	n/a	NV_MAGICCONST = 4 * _exp(-0.5)/_sqrt(2.0)
58	n/a	TWOPI = 2.0*_pi
59	n/a	LOG4 = _log(4.0)
60	n/a	SG_MAGICCONST = 1.0 + _log(4.5)
61	n/a	BPF = 53 # Number of bits in a float
62	n/a	RECIP_BPF = 2**-BPF
63	n/a
64	n/a
65	n/a	# Translated by Guido van Rossum from C source provided by
66	n/a	# Adrian Baddeley. Adapted by Raymond Hettinger for use with
67	n/a	# the Mersenne Twister and os.urandom() core generators.
68	n/a
69	n/a	import _random
70	n/a
71	n/a	class Random(_random.Random):
72	n/a	"""Random number generator base class used by bound module functions.
73	n/a
74	n/a	Used to instantiate instances of Random to get generators that don't
75	n/a	share state.
76	n/a
77	n/a	Class Random can also be subclassed if you want to use a different basic
78	n/a	generator of your own devising: in that case, override the following
79	n/a	methods: random(), seed(), getstate(), and setstate().
80	n/a	Optionally, implement a getrandbits() method so that randrange()
81	n/a	can cover arbitrarily large ranges.
82	n/a
83	n/a	"""
84	n/a
85	n/a	VERSION = 3 # used by getstate/setstate
86	n/a
87	n/a	def __init__(self, x=None):
88	n/a	"""Initialize an instance.
89	n/a
90	n/a	Optional argument x controls seeding, as for Random.seed().
91	n/a	"""
92	n/a
93	n/a	self.seed(x)
94	n/a	self.gauss_next = None
95	n/a
96	n/a	def seed(self, a=None, version=2):
97	n/a	"""Initialize internal state from hashable object.
98	n/a
99	n/a	None or no argument seeds from current time or from an operating
100	n/a	system specific randomness source if available.
101	n/a
102	n/a	If a is an int, all bits are used.
103	n/a
104	n/a	For version 2 (the default), all of the bits are used if a is a str,
105	n/a	bytes, or bytearray. For version 1 (provided for reproducing random
106	n/a	sequences from older versions of Python), the algorithm for str and
107	n/a	bytes generates a narrower range of seeds.
108	n/a
109	n/a	"""
110	n/a
111	n/a	if version == 1 and isinstance(a, (str, bytes)):
112	n/a	x = ord(a[0]) << 7 if a else 0
113	n/a	for c in a:
114	n/a	x = ((1000003 * x) ^ ord(c)) & 0xFFFFFFFFFFFFFFFF
115	n/a	x ^= len(a)
116	n/a	a = -2 if x == -1 else x
117	n/a
118	n/a	if version == 2 and isinstance(a, (str, bytes, bytearray)):
119	n/a	if isinstance(a, str):
120	n/a	a = a.encode()
121	n/a	a += _sha512(a).digest()
122	n/a	a = int.from_bytes(a, 'big')
123	n/a
124	n/a	super().seed(a)
125	n/a	self.gauss_next = None
126	n/a
127	n/a	def getstate(self):
128	n/a	"""Return internal state; can be passed to setstate() later."""
129	n/a	return self.VERSION, super().getstate(), self.gauss_next
130	n/a
131	n/a	def setstate(self, state):
132	n/a	"""Restore internal state from object returned by getstate()."""
133	n/a	version = state[0]
134	n/a	if version == 3:
135	n/a	version, internalstate, self.gauss_next = state
136	n/a	super().setstate(internalstate)
137	n/a	elif version == 2:
138	n/a	version, internalstate, self.gauss_next = state
139	n/a	# In version 2, the state was saved as signed ints, which causes
140	n/a	# inconsistencies between 32/64-bit systems. The state is
141	n/a	# really unsigned 32-bit ints, so we convert negative ints from
142	n/a	# version 2 to positive longs for version 3.
143	n/a	try:
144	n/a	internalstate = tuple(x % (2**32) for x in internalstate)
145	n/a	except ValueError as e:
146	n/a	raise TypeError from e
147	n/a	super().setstate(internalstate)
148	n/a	else:
149	n/a	raise ValueError("state with version %s passed to "
150	n/a	"Random.setstate() of version %s" %
151	n/a	(version, self.VERSION))
152	n/a
153	n/a	## ---- Methods below this point do not need to be overridden when
154	n/a	## ---- subclassing for the purpose of using a different core generator.
155	n/a
156	n/a	## -------------------- pickle support -------------------
157	n/a
158	n/a	# Issue 17489: Since __reduce__ was defined to fix #759889 this is no
159	n/a	# longer called; we leave it here because it has been here since random was
160	n/a	# rewritten back in 2001 and why risk breaking something.
161	n/a	def __getstate__(self): # for pickle
162	n/a	return self.getstate()
163	n/a
164	n/a	def __setstate__(self, state): # for pickle
165	n/a	self.setstate(state)
166	n/a
167	n/a	def __reduce__(self):
168	n/a	return self.__class__, (), self.getstate()
169	n/a
170	n/a	## -------------------- integer methods -------------------
171	n/a
172	n/a	def randrange(self, start, stop=None, step=1, _int=int):
173	n/a	"""Choose a random item from range(start, stop[, step]).
174	n/a
175	n/a	This fixes the problem with randint() which includes the
176	n/a	endpoint; in Python this is usually not what you want.
177	n/a
178	n/a	"""
179	n/a
180	n/a	# This code is a bit messy to make it fast for the
181	n/a	# common case while still doing adequate error checking.
182	n/a	istart = _int(start)
183	n/a	if istart != start:
184	n/a	raise ValueError("non-integer arg 1 for randrange()")
185	n/a	if stop is None:
186	n/a	if istart > 0:
187	n/a	return self._randbelow(istart)
188	n/a	raise ValueError("empty range for randrange()")
189	n/a
190	n/a	# stop argument supplied.
191	n/a	istop = _int(stop)
192	n/a	if istop != stop:
193	n/a	raise ValueError("non-integer stop for randrange()")
194	n/a	width = istop - istart
195	n/a	if step == 1 and width > 0:
196	n/a	return istart + self._randbelow(width)
197	n/a	if step == 1:
198	n/a	raise ValueError("empty range for randrange() (%d,%d, %d)" % (istart, istop, width))
199	n/a
200	n/a	# Non-unit step argument supplied.
201	n/a	istep = _int(step)
202	n/a	if istep != step:
203	n/a	raise ValueError("non-integer step for randrange()")
204	n/a	if istep > 0:
205	n/a	n = (width + istep - 1) // istep
206	n/a	elif istep < 0:
207	n/a	n = (width + istep + 1) // istep
208	n/a	else:
209	n/a	raise ValueError("zero step for randrange()")
210	n/a
211	n/a	if n <= 0:
212	n/a	raise ValueError("empty range for randrange()")
213	n/a
214	n/a	return istart + istep*self._randbelow(n)
215	n/a
216	n/a	def randint(self, a, b):
217	n/a	"""Return random integer in range [a, b], including both end points.
218	n/a	"""
219	n/a
220	n/a	return self.randrange(a, b+1)
221	n/a
222	n/a	def _randbelow(self, n, int=int, maxsize=1<<BPF, type=type,
223	n/a	Method=_MethodType, BuiltinMethod=_BuiltinMethodType):
224	n/a	"Return a random int in the range [0,n). Raises ValueError if n==0."
225	n/a
226	n/a	random = self.random
227	n/a	getrandbits = self.getrandbits
228	n/a	# Only call self.getrandbits if the original random() builtin method
229	n/a	# has not been overridden or if a new getrandbits() was supplied.
230	n/a	if type(random) is BuiltinMethod or type(getrandbits) is Method:
231	n/a	k = n.bit_length() # don't use (n-1) here because n can be 1
232	n/a	r = getrandbits(k) # 0 <= r < 2**k
233	n/a	while r >= n:
234	n/a	r = getrandbits(k)
235	n/a	return r
236	n/a	# There's an overridden random() method but no new getrandbits() method,
237	n/a	# so we can only use random() from here.
238	n/a	if n >= maxsize:
239	n/a	_warn("Underlying random() generator does not supply \n"
240	n/a	"enough bits to choose from a population range this large.\n"
241	n/a	"To remove the range limitation, add a getrandbits() method.")
242	n/a	return int(random() * n)
243	n/a	rem = maxsize % n
244	n/a	limit = (maxsize - rem) / maxsize # int(limit * maxsize) % n == 0
245	n/a	r = random()
246	n/a	while r >= limit:
247	n/a	r = random()
248	n/a	return int(r*maxsize) % n
249	n/a
250	n/a	## -------------------- sequence methods -------------------
251	n/a
252	n/a	def choice(self, seq):
253	n/a	"""Choose a random element from a non-empty sequence."""
254	n/a	try:
255	n/a	i = self._randbelow(len(seq))
256	n/a	except ValueError:
257	n/a	raise IndexError('Cannot choose from an empty sequence') from None
258	n/a	return seq[i]
259	n/a
260	n/a	def shuffle(self, x, random=None):
261	n/a	"""Shuffle list x in place, and return None.
262	n/a
263	n/a	Optional argument random is a 0-argument function returning a
264	n/a	random float in [0.0, 1.0); if it is the default None, the
265	n/a	standard random.random will be used.
266	n/a
267	n/a	"""
268	n/a
269	n/a	if random is None:
270	n/a	randbelow = self._randbelow
271	n/a	for i in reversed(range(1, len(x))):
272	n/a	# pick an element in x[:i+1] with which to exchange x[i]
273	n/a	j = randbelow(i+1)
274	n/a	x[i], x[j] = x[j], x[i]
275	n/a	else:
276	n/a	_int = int
277	n/a	for i in reversed(range(1, len(x))):
278	n/a	# pick an element in x[:i+1] with which to exchange x[i]
279	n/a	j = _int(random() * (i+1))
280	n/a	x[i], x[j] = x[j], x[i]
281	n/a
282	n/a	def sample(self, population, k):
283	n/a	"""Chooses k unique random elements from a population sequence or set.
284	n/a
285	n/a	Returns a new list containing elements from the population while
286	n/a	leaving the original population unchanged. The resulting list is
287	n/a	in selection order so that all sub-slices will also be valid random
288	n/a	samples. This allows raffle winners (the sample) to be partitioned
289	n/a	into grand prize and second place winners (the subslices).
290	n/a
291	n/a	Members of the population need not be hashable or unique. If the
292	n/a	population contains repeats, then each occurrence is a possible
293	n/a	selection in the sample.
294	n/a
295	n/a	To choose a sample in a range of integers, use range as an argument.
296	n/a	This is especially fast and space efficient for sampling from a
297	n/a	large population: sample(range(10000000), 60)
298	n/a	"""
299	n/a
300	n/a	# Sampling without replacement entails tracking either potential
301	n/a	# selections (the pool) in a list or previous selections in a set.
302	n/a
303	n/a	# When the number of selections is small compared to the
304	n/a	# population, then tracking selections is efficient, requiring
305	n/a	# only a small set and an occasional reselection. For
306	n/a	# a larger number of selections, the pool tracking method is
307	n/a	# preferred since the list takes less space than the
308	n/a	# set and it doesn't suffer from frequent reselections.
309	n/a
310	n/a	if isinstance(population, _Set):
311	n/a	population = tuple(population)
312	n/a	if not isinstance(population, _Sequence):
313	n/a	raise TypeError("Population must be a sequence or set. For dicts, use list(d).")
314	n/a	randbelow = self._randbelow
315	n/a	n = len(population)
316	n/a	if not 0 <= k <= n:
317	n/a	raise ValueError("Sample larger than population or is negative")
318	n/a	result = [None] * k
319	n/a	setsize = 21 # size of a small set minus size of an empty list
320	n/a	if k > 5:
321	n/a	setsize += 4 ** _ceil(_log(k * 3, 4)) # table size for big sets
322	n/a	if n <= setsize:
323	n/a	# An n-length list is smaller than a k-length set
324	n/a	pool = list(population)
325	n/a	for i in range(k): # invariant: non-selected at [0,n-i)
326	n/a	j = randbelow(n-i)
327	n/a	result[i] = pool[j]
328	n/a	pool[j] = pool[n-i-1] # move non-selected item into vacancy
329	n/a	else:
330	n/a	selected = set()
331	n/a	selected_add = selected.add
332	n/a	for i in range(k):
333	n/a	j = randbelow(n)
334	n/a	while j in selected:
335	n/a	j = randbelow(n)
336	n/a	selected_add(j)
337	n/a	result[i] = population[j]
338	n/a	return result
339	n/a
340	n/a	def choices(self, population, weights=None, *, cum_weights=None, k=1):
341	n/a	"""Return a k sized list of population elements chosen with replacement.
342	n/a
343	n/a	If the relative weights or cumulative weights are not specified,
344	n/a	the selections are made with equal probability.
345	n/a
346	n/a	"""
347	n/a	random = self.random
348	n/a	if cum_weights is None:
349	n/a	if weights is None:
350	n/a	_int = int
351	n/a	total = len(population)
352	n/a	return [population[_int(random() * total)] for i in range(k)]
353	n/a	cum_weights = list(_itertools.accumulate(weights))
354	n/a	elif weights is not None:
355	n/a	raise TypeError('Cannot specify both weights and cumulative weights')
356	n/a	if len(cum_weights) != len(population):
357	n/a	raise ValueError('The number of weights does not match the population')
358	n/a	bisect = _bisect.bisect
359	n/a	total = cum_weights[-1]
360	n/a	return [population[bisect(cum_weights, random() * total)] for i in range(k)]
361	n/a
362	n/a	## -------------------- real-valued distributions -------------------
363	n/a
364	n/a	## -------------------- uniform distribution -------------------
365	n/a
366	n/a	def uniform(self, a, b):
367	n/a	"Get a random number in the range [a, b) or [a, b] depending on rounding."
368	n/a	return a + (b-a) * self.random()
369	n/a
370	n/a	## -------------------- triangular --------------------
371	n/a
372	n/a	def triangular(self, low=0.0, high=1.0, mode=None):
373	n/a	"""Triangular distribution.
374	n/a
375	n/a	Continuous distribution bounded by given lower and upper limits,
376	n/a	and having a given mode value in-between.
377	n/a
378	n/a	http://en.wikipedia.org/wiki/Triangular_distribution
379	n/a
380	n/a	"""
381	n/a	u = self.random()
382	n/a	try:
383	n/a	c = 0.5 if mode is None else (mode - low) / (high - low)
384	n/a	except ZeroDivisionError:
385	n/a	return low
386	n/a	if u > c:
387	n/a	u = 1.0 - u
388	n/a	c = 1.0 - c
389	n/a	low, high = high, low
390	n/a	return low + (high - low) * (u * c) ** 0.5
391	n/a
392	n/a	## -------------------- normal distribution --------------------
393	n/a
394	n/a	def normalvariate(self, mu, sigma):
395	n/a	"""Normal distribution.
396	n/a
397	n/a	mu is the mean, and sigma is the standard deviation.
398	n/a
399	n/a	"""
400	n/a	# mu = mean, sigma = standard deviation
401	n/a
402	n/a	# Uses Kinderman and Monahan method. Reference: Kinderman,
403	n/a	# A.J. and Monahan, J.F., "Computer generation of random
404	n/a	# variables using the ratio of uniform deviates", ACM Trans
405	n/a	# Math Software, 3, (1977), pp257-260.
406	n/a
407	n/a	random = self.random
408	n/a	while 1:
409	n/a	u1 = random()
410	n/a	u2 = 1.0 - random()
411	n/a	z = NV_MAGICCONST*(u1-0.5)/u2
412	n/a	zz = z*z/4.0
413	n/a	if zz <= -_log(u2):
414	n/a	break
415	n/a	return mu + z*sigma
416	n/a
417	n/a	## -------------------- lognormal distribution --------------------
418	n/a
419	n/a	def lognormvariate(self, mu, sigma):
420	n/a	"""Log normal distribution.
421	n/a
422	n/a	If you take the natural logarithm of this distribution, you'll get a
423	n/a	normal distribution with mean mu and standard deviation sigma.
424	n/a	mu can have any value, and sigma must be greater than zero.
425	n/a
426	n/a	"""
427	n/a	return _exp(self.normalvariate(mu, sigma))
428	n/a
429	n/a	## -------------------- exponential distribution --------------------
430	n/a
431	n/a	def expovariate(self, lambd):
432	n/a	"""Exponential distribution.
433	n/a
434	n/a	lambd is 1.0 divided by the desired mean. It should be
435	n/a	nonzero. (The parameter would be called "lambda", but that is
436	n/a	a reserved word in Python.) Returned values range from 0 to
437	n/a	positive infinity if lambd is positive, and from negative
438	n/a	infinity to 0 if lambd is negative.
439	n/a
440	n/a	"""
441	n/a	# lambd: rate lambd = 1/mean
442	n/a	# ('lambda' is a Python reserved word)
443	n/a
444	n/a	# we use 1-random() instead of random() to preclude the
445	n/a	# possibility of taking the log of zero.
446	n/a	return -_log(1.0 - self.random())/lambd
447	n/a
448	n/a	## -------------------- von Mises distribution --------------------
449	n/a
450	n/a	def vonmisesvariate(self, mu, kappa):
451	n/a	"""Circular data distribution.
452	n/a
453	n/a	mu is the mean angle, expressed in radians between 0 and 2*pi, and
454	n/a	kappa is the concentration parameter, which must be greater than or
455	n/a	equal to zero. If kappa is equal to zero, this distribution reduces
456	n/a	to a uniform random angle over the range 0 to 2*pi.
457	n/a
458	n/a	"""
459	n/a	# mu: mean angle (in radians between 0 and 2*pi)
460	n/a	# kappa: concentration parameter kappa (>= 0)
461	n/a	# if kappa = 0 generate uniform random angle
462	n/a
463	n/a	# Based upon an algorithm published in: Fisher, N.I.,
464	n/a	# "Statistical Analysis of Circular Data", Cambridge
465	n/a	# University Press, 1993.
466	n/a
467	n/a	# Thanks to Magnus Kessler for a correction to the
468	n/a	# implementation of step 4.
469	n/a
470	n/a	random = self.random
471	n/a	if kappa <= 1e-6:
472	n/a	return TWOPI * random()
473	n/a
474	n/a	s = 0.5 / kappa
475	n/a	r = s + _sqrt(1.0 + s * s)
476	n/a
477	n/a	while 1:
478	n/a	u1 = random()
479	n/a	z = _cos(_pi * u1)
480	n/a
481	n/a	d = z / (r + z)
482	n/a	u2 = random()
483	n/a	if u2 < 1.0 - d * d or u2 <= (1.0 - d) * _exp(d):
484	n/a	break
485	n/a
486	n/a	q = 1.0 / r
487	n/a	f = (q + z) / (1.0 + q * z)
488	n/a	u3 = random()
489	n/a	if u3 > 0.5:
490	n/a	theta = (mu + _acos(f)) % TWOPI
491	n/a	else:
492	n/a	theta = (mu - _acos(f)) % TWOPI
493	n/a
494	n/a	return theta
495	n/a
496	n/a	## -------------------- gamma distribution --------------------
497	n/a
498	n/a	def gammavariate(self, alpha, beta):
499	n/a	"""Gamma distribution. Not the gamma function!
500	n/a
501	n/a	Conditions on the parameters are alpha > 0 and beta > 0.
502	n/a
503	n/a	The probability distribution function is:
504	n/a
505	n/a	x ** (alpha - 1) * math.exp(-x / beta)
506	n/a	pdf(x) = --------------------------------------
507	n/a	math.gamma(alpha) * beta ** alpha
508	n/a
509	n/a	"""
510	n/a
511	n/a	# alpha > 0, beta > 0, mean is alphabeta, variance is alphabeta**2
512	n/a
513	n/a	# Warning: a few older sources define the gamma distribution in terms
514	n/a	# of alpha > -1.0
515	n/a	if alpha <= 0.0 or beta <= 0.0:
516	n/a	raise ValueError('gammavariate: alpha and beta must be > 0.0')
517	n/a
518	n/a	random = self.random
519	n/a	if alpha > 1.0:
520	n/a
521	n/a	# Uses R.C.H. Cheng, "The generation of Gamma
522	n/a	# variables with non-integral shape parameters",
523	n/a	# Applied Statistics, (1977), 26, No. 1, p71-74
524	n/a
525	n/a	ainv = _sqrt(2.0 * alpha - 1.0)
526	n/a	bbb = alpha - LOG4
527	n/a	ccc = alpha + ainv
528	n/a
529	n/a	while 1:
530	n/a	u1 = random()
531	n/a	if not 1e-7 < u1 < .9999999:
532	n/a	continue
533	n/a	u2 = 1.0 - random()
534	n/a	v = _log(u1/(1.0-u1))/ainv
535	n/a	x = alpha*_exp(v)
536	n/a	z = u1u1u2
537	n/a	r = bbb+ccc*v-x
538	n/a	if r + SG_MAGICCONST - 4.5*z >= 0.0 or r >= _log(z):
539	n/a	return x * beta
540	n/a
541	n/a	elif alpha == 1.0:
542	n/a	# expovariate(1)
543	n/a	u = random()
544	n/a	while u <= 1e-7:
545	n/a	u = random()
546	n/a	return -_log(u) * beta
547	n/a
548	n/a	else: # alpha is between 0 and 1 (exclusive)
549	n/a
550	n/a	# Uses ALGORITHM GS of Statistical Computing - Kennedy & Gentle
551	n/a
552	n/a	while 1:
553	n/a	u = random()
554	n/a	b = (_e + alpha)/_e
555	n/a	p = b*u
556	n/a	if p <= 1.0:
557	n/a	x = p ** (1.0/alpha)
558	n/a	else:
559	n/a	x = -_log((b-p)/alpha)
560	n/a	u1 = random()
561	n/a	if p > 1.0:
562	n/a	if u1 <= x ** (alpha - 1.0):
563	n/a	break
564	n/a	elif u1 <= _exp(-x):
565	n/a	break
566	n/a	return x * beta
567	n/a
568	n/a	## -------------------- Gauss (faster alternative) --------------------
569	n/a
570	n/a	def gauss(self, mu, sigma):
571	n/a	"""Gaussian distribution.
572	n/a
573	n/a	mu is the mean, and sigma is the standard deviation. This is
574	n/a	slightly faster than the normalvariate() function.
575	n/a
576	n/a	Not thread-safe without a lock around calls.
577	n/a
578	n/a	"""
579	n/a
580	n/a	# When x and y are two variables from [0, 1), uniformly
581	n/a	# distributed, then
582	n/a	#
583	n/a	# cos(2pix)sqrt(-2log(1-y))
584	n/a	# sin(2pix)sqrt(-2log(1-y))
585	n/a	#
586	n/a	# are two independent variables with normal distribution
587	n/a	# (mu = 0, sigma = 1).
588	n/a	# (Lambert Meertens)
589	n/a	# (corrected version; bug discovered by Mike Miller, fixed by LM)
590	n/a
591	n/a	# Multithreading note: When two threads call this function
592	n/a	# simultaneously, it is possible that they will receive the
593	n/a	# same return value. The window is very small though. To
594	n/a	# avoid this, you have to use a lock around all calls. (I
595	n/a	# didn't want to slow this down in the serial case by using a
596	n/a	# lock here.)
597	n/a
598	n/a	random = self.random
599	n/a	z = self.gauss_next
600	n/a	self.gauss_next = None
601	n/a	if z is None:
602	n/a	x2pi = random() * TWOPI
603	n/a	g2rad = _sqrt(-2.0 * _log(1.0 - random()))
604	n/a	z = _cos(x2pi) * g2rad
605	n/a	self.gauss_next = _sin(x2pi) * g2rad
606	n/a
607	n/a	return mu + z*sigma
608	n/a
609	n/a	## -------------------- beta --------------------
610	n/a	## See
611	n/a	## http://mail.python.org/pipermail/python-bugs-list/2001-January/003752.html
612	n/a	## for Ivan Frohne's insightful analysis of why the original implementation:
613	n/a	##
614	n/a	## def betavariate(self, alpha, beta):
615	n/a	## # Discrete Event Simulation in C, pp 87-88.
616	n/a	##
617	n/a	## y = self.expovariate(alpha)
618	n/a	## z = self.expovariate(1.0/beta)
619	n/a	## return z/(y+z)
620	n/a	##
621	n/a	## was dead wrong, and how it probably got that way.
622	n/a
623	n/a	def betavariate(self, alpha, beta):
624	n/a	"""Beta distribution.
625	n/a
626	n/a	Conditions on the parameters are alpha > 0 and beta > 0.
627	n/a	Returned values range between 0 and 1.
628	n/a
629	n/a	"""
630	n/a
631	n/a	# This version due to Janne Sinkkonen, and matches all the std
632	n/a	# texts (e.g., Knuth Vol 2 Ed 3 pg 134 "the beta distribution").
633	n/a	y = self.gammavariate(alpha, 1.0)
634	n/a	if y == 0:
635	n/a	return 0.0
636	n/a	else:
637	n/a	return y / (y + self.gammavariate(beta, 1.0))
638	n/a
639	n/a	## -------------------- Pareto --------------------
640	n/a
641	n/a	def paretovariate(self, alpha):
642	n/a	"""Pareto distribution. alpha is the shape parameter."""
643	n/a	# Jain, pg. 495
644	n/a
645	n/a	u = 1.0 - self.random()
646	n/a	return 1.0 / u ** (1.0/alpha)
647	n/a
648	n/a	## -------------------- Weibull --------------------
649	n/a
650	n/a	def weibullvariate(self, alpha, beta):
651	n/a	"""Weibull distribution.
652	n/a
653	n/a	alpha is the scale parameter and beta is the shape parameter.
654	n/a
655	n/a	"""
656	n/a	# Jain, pg. 499; bug fix courtesy Bill Arms
657	n/a
658	n/a	u = 1.0 - self.random()
659	n/a	return alpha * (-_log(u)) ** (1.0/beta)
660	n/a
661	n/a	## --------------- Operating System Random Source ------------------
662	n/a
663	n/a	class SystemRandom(Random):
664	n/a	"""Alternate random number generator using sources provided
665	n/a	by the operating system (such as /dev/urandom on Unix or
666	n/a	CryptGenRandom on Windows).
667	n/a
668	n/a	Not available on all systems (see os.urandom() for details).
669	n/a	"""
670	n/a
671	n/a	def random(self):
672	n/a	"""Get the next random number in the range [0.0, 1.0)."""
673	n/a	return (int.from_bytes(_urandom(7), 'big') >> 3) * RECIP_BPF
674	n/a
675	n/a	def getrandbits(self, k):
676	n/a	"""getrandbits(k) -> x. Generates an int with k random bits."""
677	n/a	if k <= 0:
678	n/a	raise ValueError('number of bits must be greater than zero')
679	n/a	if k != int(k):
680	n/a	raise TypeError('number of bits should be an integer')
681	n/a	numbytes = (k + 7) // 8 # bits / 8 and rounded up
682	n/a	x = int.from_bytes(_urandom(numbytes), 'big')
683	n/a	return x >> (numbytes * 8 - k) # trim excess bits
684	n/a
685	n/a	def seed(self, args, *kwds):
686	n/a	"Stub method. Not used for a system random number generator."
687	n/a	return None
688	n/a
689	n/a	def _notimplemented(self, args, *kwds):
690	n/a	"Method should not be called for a system random number generator."
691	n/a	raise NotImplementedError('System entropy source does not have state.')
692	n/a	getstate = setstate = _notimplemented
693	n/a
694	n/a	## -------------------- test program --------------------
695	n/a
696	n/a	def _test_generator(n, func, args):
697	n/a	import time
698	n/a	print(n, 'times', func.__name__)
699	n/a	total = 0.0
700	n/a	sqsum = 0.0
701	n/a	smallest = 1e10
702	n/a	largest = -1e10
703	n/a	t0 = time.time()
704	n/a	for i in range(n):
705	n/a	x = func(*args)
706	n/a	total += x
707	n/a	sqsum = sqsum + x*x
708	n/a	smallest = min(x, smallest)
709	n/a	largest = max(x, largest)
710	n/a	t1 = time.time()
711	n/a	print(round(t1-t0, 3), 'sec,', end=' ')
712	n/a	avg = total/n
713	n/a	stddev = _sqrt(sqsum/n - avg*avg)
714	n/a	print('avg %g, stddev %g, min %g, max %g\n' % \
715	n/a	(avg, stddev, smallest, largest))
716	n/a
717	n/a
718	n/a	def _test(N=2000):
719	n/a	_test_generator(N, random, ())
720	n/a	_test_generator(N, normalvariate, (0.0, 1.0))
721	n/a	_test_generator(N, lognormvariate, (0.0, 1.0))
722	n/a	_test_generator(N, vonmisesvariate, (0.0, 1.0))
723	n/a	_test_generator(N, gammavariate, (0.01, 1.0))
724	n/a	_test_generator(N, gammavariate, (0.1, 1.0))
725	n/a	_test_generator(N, gammavariate, (0.1, 2.0))
726	n/a	_test_generator(N, gammavariate, (0.5, 1.0))
727	n/a	_test_generator(N, gammavariate, (0.9, 1.0))
728	n/a	_test_generator(N, gammavariate, (1.0, 1.0))
729	n/a	_test_generator(N, gammavariate, (2.0, 1.0))
730	n/a	_test_generator(N, gammavariate, (20.0, 1.0))
731	n/a	_test_generator(N, gammavariate, (200.0, 1.0))
732	n/a	_test_generator(N, gauss, (0.0, 1.0))
733	n/a	_test_generator(N, betavariate, (3.0, 3.0))
734	n/a	_test_generator(N, triangular, (0.0, 1.0, 1.0/3.0))
735	n/a
736	n/a	# Create one instance, seeded from current time, and export its methods
737	n/a	# as module-level functions. The functions share state across all uses
738	n/a	#(both in the user's code and in the Python libraries), but that's fine
739	n/a	# for most programs and is easier for the casual user than making them
740	n/a	# instantiate their own Random() instance.
741	n/a
742	n/a	_inst = Random()
743	n/a	seed = _inst.seed
744	n/a	random = _inst.random
745	n/a	uniform = _inst.uniform
746	n/a	triangular = _inst.triangular
747	n/a	randint = _inst.randint
748	n/a	choice = _inst.choice
749	n/a	randrange = _inst.randrange
750	n/a	sample = _inst.sample
751	n/a	shuffle = _inst.shuffle
752	n/a	choices = _inst.choices
753	n/a	normalvariate = _inst.normalvariate
754	n/a	lognormvariate = _inst.lognormvariate
755	n/a	expovariate = _inst.expovariate
756	n/a	vonmisesvariate = _inst.vonmisesvariate
757	n/a	gammavariate = _inst.gammavariate
758	n/a	gauss = _inst.gauss
759	n/a	betavariate = _inst.betavariate
760	n/a	paretovariate = _inst.paretovariate
761	n/a	weibullvariate = _inst.weibullvariate
762	n/a	getstate = _inst.getstate
763	n/a	setstate = _inst.setstate
764	n/a	getrandbits = _inst.getrandbits
765	n/a
766	n/a	if __name__ == '__main__':
767	n/a	_test()