blob: 1f5be45a4b6d16d02dc458da7f1b99ffb42fba67 [file] [log] [blame]
Guido van Rossume7b146f2000-02-04 15:28:42 +00001"""Random variable generators.
Guido van Rossumff03b1a1994-03-09 12:55:02 +00002
Tim Petersd7b5e882001-01-25 03:36:26 +00003 integers
4 --------
5 uniform within range
6
7 sequences
8 ---------
9 pick random element
Raymond Hettingerf24eb352002-11-12 17:41:57 +000010 pick random sample
Tim Petersd7b5e882001-01-25 03:36:26 +000011 generate random permutation
12
Guido van Rossume7b146f2000-02-04 15:28:42 +000013 distributions on the real line:
14 ------------------------------
Tim Petersd7b5e882001-01-25 03:36:26 +000015 uniform
Christian Heimesfe337bf2008-03-23 21:54:12 +000016 triangular
Guido van Rossume7b146f2000-02-04 15:28:42 +000017 normal (Gaussian)
18 lognormal
19 negative exponential
20 gamma
21 beta
Raymond Hettinger40f62172002-12-29 23:03:38 +000022 pareto
23 Weibull
Guido van Rossumff03b1a1994-03-09 12:55:02 +000024
Guido van Rossume7b146f2000-02-04 15:28:42 +000025 distributions on the circle (angles 0 to 2pi)
26 ---------------------------------------------
27 circular uniform
28 von Mises
29
Raymond Hettinger40f62172002-12-29 23:03:38 +000030General notes on the underlying Mersenne Twister core generator:
Guido van Rossume7b146f2000-02-04 15:28:42 +000031
Raymond Hettinger40f62172002-12-29 23:03:38 +000032* The period is 2**19937-1.
Thomas Wouters0e3f5912006-08-11 14:57:12 +000033* It is one of the most extensively tested generators in existence.
Thomas Wouters0e3f5912006-08-11 14:57:12 +000034* The random() method is implemented in C, executes in a single Python step,
35 and is, therefore, threadsafe.
Tim Peterse360d952001-01-26 10:00:39 +000036
Guido van Rossume7b146f2000-02-04 15:28:42 +000037"""
Guido van Rossumd03e1191998-05-29 17:51:31 +000038
Raymond Hettinger2f726e92003-10-05 09:09:15 +000039from warnings import warn as _warn
40from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
Raymond Hettinger91e27c22005-08-19 01:36:35 +000041from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
Tim Petersd7b5e882001-01-25 03:36:26 +000042from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
Raymond Hettingerc1c43ca2004-09-05 00:00:42 +000043from os import urandom as _urandom
Christian Heimesf1dc3ee2013-10-13 02:04:20 +020044from _collections_abc import Set as _Set, Sequence as _Sequence
Raymond Hettinger3fcf0022010-12-08 01:13:53 +000045from hashlib import sha512 as _sha512
Guido van Rossumff03b1a1994-03-09 12:55:02 +000046
Raymond Hettingerf24eb352002-11-12 17:41:57 +000047__all__ = ["Random","seed","random","uniform","randint","choice","sample",
Skip Montanaro0de65802001-02-15 22:15:14 +000048 "randrange","shuffle","normalvariate","lognormvariate",
Christian Heimesfe337bf2008-03-23 21:54:12 +000049 "expovariate","vonmisesvariate","gammavariate","triangular",
Raymond Hettingerf8a52d32003-08-05 12:23:19 +000050 "gauss","betavariate","paretovariate","weibullvariate",
Raymond Hettinger28de64f2008-01-13 23:40:30 +000051 "getstate","setstate", "getrandbits",
Raymond Hettinger23f12412004-09-13 22:23:21 +000052 "SystemRandom"]
Tim Petersd7b5e882001-01-25 03:36:26 +000053
54NV_MAGICCONST = 4 * _exp(-0.5)/_sqrt(2.0)
Tim Petersd7b5e882001-01-25 03:36:26 +000055TWOPI = 2.0*_pi
Tim Petersd7b5e882001-01-25 03:36:26 +000056LOG4 = _log(4.0)
Tim Petersd7b5e882001-01-25 03:36:26 +000057SG_MAGICCONST = 1.0 + _log(4.5)
Raymond Hettinger2f726e92003-10-05 09:09:15 +000058BPF = 53 # Number of bits in a float
Tim Peters7c2a85b2004-08-31 02:19:55 +000059RECIP_BPF = 2**-BPF
Tim Petersd7b5e882001-01-25 03:36:26 +000060
Raymond Hettinger356a4592004-08-30 06:14:31 +000061
Tim Petersd7b5e882001-01-25 03:36:26 +000062# Translated by Guido van Rossum from C source provided by
Raymond Hettinger40f62172002-12-29 23:03:38 +000063# Adrian Baddeley. Adapted by Raymond Hettinger for use with
Raymond Hettinger3fa19d72004-08-31 01:05:15 +000064# the Mersenne Twister and os.urandom() core generators.
Tim Petersd7b5e882001-01-25 03:36:26 +000065
Raymond Hettinger145a4a02003-01-07 10:25:55 +000066import _random
Raymond Hettinger40f62172002-12-29 23:03:38 +000067
Raymond Hettinger145a4a02003-01-07 10:25:55 +000068class Random(_random.Random):
Raymond Hettingerc32f0332002-05-23 19:44:49 +000069 """Random number generator base class used by bound module functions.
70
71 Used to instantiate instances of Random to get generators that don't
Raymond Hettinger28de64f2008-01-13 23:40:30 +000072 share state.
Raymond Hettingerc32f0332002-05-23 19:44:49 +000073
74 Class Random can also be subclassed if you want to use a different basic
75 generator of your own devising: in that case, override the following
Raymond Hettinger28de64f2008-01-13 23:40:30 +000076 methods: random(), seed(), getstate(), and setstate().
Benjamin Petersond18de0e2008-07-31 20:21:46 +000077 Optionally, implement a getrandbits() method so that randrange()
Raymond Hettinger2f726e92003-10-05 09:09:15 +000078 can cover arbitrarily large ranges.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +000079
Raymond Hettingerc32f0332002-05-23 19:44:49 +000080 """
Tim Petersd7b5e882001-01-25 03:36:26 +000081
Christian Heimescbf3b5c2007-12-03 21:02:03 +000082 VERSION = 3 # used by getstate/setstate
Tim Petersd7b5e882001-01-25 03:36:26 +000083
84 def __init__(self, x=None):
85 """Initialize an instance.
86
87 Optional argument x controls seeding, as for Random.seed().
88 """
89
90 self.seed(x)
Raymond Hettinger40f62172002-12-29 23:03:38 +000091 self.gauss_next = None
Tim Petersd7b5e882001-01-25 03:36:26 +000092
Raymond Hettingerf763a722010-09-07 00:38:15 +000093 def seed(self, a=None, version=2):
Tim Peters0de88fc2001-02-01 04:59:18 +000094 """Initialize internal state from hashable object.
Tim Petersd7b5e882001-01-25 03:36:26 +000095
Raymond Hettinger23f12412004-09-13 22:23:21 +000096 None or no argument seeds from current time or from an operating
97 system specific randomness source if available.
Tim Peters0de88fc2001-02-01 04:59:18 +000098
Sandro Tosi29d09aa2012-06-02 19:40:02 +020099 For version 2 (the default), all of the bits are used if *a* is a str,
Raymond Hettinger183cd1f2010-09-08 18:48:21 +0000100 bytes, or bytearray. For version 1, the hash() of *a* is used instead.
Raymond Hettingerf763a722010-09-07 00:38:15 +0000101
Raymond Hettinger183cd1f2010-09-08 18:48:21 +0000102 If *a* is an int, all bits are used.
Raymond Hettingerf763a722010-09-07 00:38:15 +0000103
Tim Petersd7b5e882001-01-25 03:36:26 +0000104 """
105
Raymond Hettinger3081d592003-08-09 18:30:57 +0000106 if a is None:
Raymond Hettingerc1c43ca2004-09-05 00:00:42 +0000107 try:
Raymond Hettinger23042cd2014-05-13 22:13:40 -0700108 # Seed with enough bytes to span the 19937 bit
109 # state space for the Mersenne Twister
110 a = int.from_bytes(_urandom(2500), 'big')
Raymond Hettingerc1c43ca2004-09-05 00:00:42 +0000111 except NotImplementedError:
Raymond Hettinger356a4592004-08-30 06:14:31 +0000112 import time
Guido van Rossume2a383d2007-01-15 16:59:06 +0000113 a = int(time.time() * 256) # use fractional seconds
Raymond Hettinger356a4592004-08-30 06:14:31 +0000114
Raymond Hettinger3fcf0022010-12-08 01:13:53 +0000115 if version == 2:
116 if isinstance(a, (str, bytes, bytearray)):
117 if isinstance(a, str):
Raymond Hettingerf90ba8a2011-05-05 11:35:50 -0700118 a = a.encode()
Raymond Hettinger3fcf0022010-12-08 01:13:53 +0000119 a += _sha512(a).digest()
120 a = int.from_bytes(a, 'big')
Raymond Hettingerf763a722010-09-07 00:38:15 +0000121
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000122 super().seed(a)
Tim Peters46c04e12002-05-05 20:40:00 +0000123 self.gauss_next = None
124
Tim Peterscd804102001-01-25 20:25:57 +0000125 def getstate(self):
126 """Return internal state; can be passed to setstate() later."""
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000127 return self.VERSION, super().getstate(), self.gauss_next
Tim Peterscd804102001-01-25 20:25:57 +0000128
129 def setstate(self, state):
130 """Restore internal state from object returned by getstate()."""
131 version = state[0]
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000132 if version == 3:
Raymond Hettinger40f62172002-12-29 23:03:38 +0000133 version, internalstate, self.gauss_next = state
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000134 super().setstate(internalstate)
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000135 elif version == 2:
136 version, internalstate, self.gauss_next = state
137 # In version 2, the state was saved as signed ints, which causes
138 # inconsistencies between 32/64-bit systems. The state is
139 # really unsigned 32-bit ints, so we convert negative ints from
140 # version 2 to positive longs for version 3.
141 try:
Raymond Hettingerc585eec2010-09-07 15:00:15 +0000142 internalstate = tuple(x % (2**32) for x in internalstate)
Christian Heimescbf3b5c2007-12-03 21:02:03 +0000143 except ValueError as e:
144 raise TypeError from e
Raymond Hettinger183cd1f2010-09-08 18:48:21 +0000145 super().setstate(internalstate)
Tim Peterscd804102001-01-25 20:25:57 +0000146 else:
147 raise ValueError("state with version %s passed to "
148 "Random.setstate() of version %s" %
149 (version, self.VERSION))
150
Tim Peterscd804102001-01-25 20:25:57 +0000151## ---- Methods below this point do not need to be overridden when
152## ---- subclassing for the purpose of using a different core generator.
153
154## -------------------- pickle support -------------------
155
R David Murrayd9ebf4d2013-04-02 13:10:52 -0400156 # Issue 17489: Since __reduce__ was defined to fix #759889 this is no
157 # longer called; we leave it here because it has been here since random was
158 # rewritten back in 2001 and why risk breaking something.
Tim Peterscd804102001-01-25 20:25:57 +0000159 def __getstate__(self): # for pickle
160 return self.getstate()
161
162 def __setstate__(self, state): # for pickle
163 self.setstate(state)
164
Raymond Hettinger5f078ff2003-06-24 20:29:04 +0000165 def __reduce__(self):
166 return self.__class__, (), self.getstate()
167
Tim Peterscd804102001-01-25 20:25:57 +0000168## -------------------- integer methods -------------------
169
Raymond Hettinger8fe47c32013-10-05 21:48:21 -0700170 def randrange(self, start, stop=None, step=1, _int=int):
Tim Petersd7b5e882001-01-25 03:36:26 +0000171 """Choose a random item from range(start, stop[, step]).
172
173 This fixes the problem with randint() which includes the
174 endpoint; in Python this is usually not what you want.
Raymond Hettinger3051cc32010-09-07 00:48:40 +0000175
Tim Petersd7b5e882001-01-25 03:36:26 +0000176 """
177
178 # This code is a bit messy to make it fast for the
Tim Peters9146f272002-08-16 03:41:39 +0000179 # common case while still doing adequate error checking.
Raymond Hettinger8fe47c32013-10-05 21:48:21 -0700180 istart = _int(start)
Tim Petersd7b5e882001-01-25 03:36:26 +0000181 if istart != start:
Collin Winterce36ad82007-08-30 01:19:48 +0000182 raise ValueError("non-integer arg 1 for randrange()")
Raymond Hettinger3051cc32010-09-07 00:48:40 +0000183 if stop is None:
Tim Petersd7b5e882001-01-25 03:36:26 +0000184 if istart > 0:
Raymond Hettinger05156612010-09-07 04:44:52 +0000185 return self._randbelow(istart)
Collin Winterce36ad82007-08-30 01:19:48 +0000186 raise ValueError("empty range for randrange()")
Tim Peters9146f272002-08-16 03:41:39 +0000187
188 # stop argument supplied.
Raymond Hettinger8fe47c32013-10-05 21:48:21 -0700189 istop = _int(stop)
Tim Petersd7b5e882001-01-25 03:36:26 +0000190 if istop != stop:
Collin Winterce36ad82007-08-30 01:19:48 +0000191 raise ValueError("non-integer stop for randrange()")
Raymond Hettinger2f726e92003-10-05 09:09:15 +0000192 width = istop - istart
193 if step == 1 and width > 0:
Raymond Hettingerc3246972010-09-07 09:32:57 +0000194 return istart + self._randbelow(width)
Tim Petersd7b5e882001-01-25 03:36:26 +0000195 if step == 1:
Collin Winterce36ad82007-08-30 01:19:48 +0000196 raise ValueError("empty range for randrange() (%d,%d, %d)" % (istart, istop, width))
Tim Peters9146f272002-08-16 03:41:39 +0000197
198 # Non-unit step argument supplied.
Raymond Hettinger8fe47c32013-10-05 21:48:21 -0700199 istep = _int(step)
Tim Petersd7b5e882001-01-25 03:36:26 +0000200 if istep != step:
Collin Winterce36ad82007-08-30 01:19:48 +0000201 raise ValueError("non-integer step for randrange()")
Tim Petersd7b5e882001-01-25 03:36:26 +0000202 if istep > 0:
Raymond Hettingerffdb8bb2004-09-27 15:29:05 +0000203 n = (width + istep - 1) // istep
Tim Petersd7b5e882001-01-25 03:36:26 +0000204 elif istep < 0:
Raymond Hettingerffdb8bb2004-09-27 15:29:05 +0000205 n = (width + istep + 1) // istep
Tim Petersd7b5e882001-01-25 03:36:26 +0000206 else:
Collin Winterce36ad82007-08-30 01:19:48 +0000207 raise ValueError("zero step for randrange()")
Tim Petersd7b5e882001-01-25 03:36:26 +0000208
209 if n <= 0:
Collin Winterce36ad82007-08-30 01:19:48 +0000210 raise ValueError("empty range for randrange()")
Raymond Hettinger2f726e92003-10-05 09:09:15 +0000211
Raymond Hettinger05156612010-09-07 04:44:52 +0000212 return istart + istep*self._randbelow(n)
Tim Petersd7b5e882001-01-25 03:36:26 +0000213
214 def randint(self, a, b):
Tim Peterscd804102001-01-25 20:25:57 +0000215 """Return random integer in range [a, b], including both end points.
Tim Petersd7b5e882001-01-25 03:36:26 +0000216 """
217
218 return self.randrange(a, b+1)
219
Raymond Hettingere4a3e992010-09-08 00:30:28 +0000220 def _randbelow(self, n, int=int, maxsize=1<<BPF, type=type,
Raymond Hettinger05a505f2010-09-07 19:19:33 +0000221 Method=_MethodType, BuiltinMethod=_BuiltinMethodType):
Raymond Hettingere4a3e992010-09-08 00:30:28 +0000222 "Return a random int in the range [0,n). Raises ValueError if n==0."
Raymond Hettinger2f726e92003-10-05 09:09:15 +0000223
Raymond Hettingerf77cdbe2013-10-05 17:18:36 -0700224 random = self.random
Raymond Hettingerc3246972010-09-07 09:32:57 +0000225 getrandbits = self.getrandbits
226 # Only call self.getrandbits if the original random() builtin method
227 # has not been overridden or if a new getrandbits() was supplied.
Raymond Hettingerf77cdbe2013-10-05 17:18:36 -0700228 if type(random) is BuiltinMethod or type(getrandbits) is Method:
Raymond Hettingere4a3e992010-09-08 00:30:28 +0000229 k = n.bit_length() # don't use (n-1) here because n can be 1
Raymond Hettingerf015b3f2010-09-07 20:04:42 +0000230 r = getrandbits(k) # 0 <= r < 2**k
Raymond Hettingerc3246972010-09-07 09:32:57 +0000231 while r >= n:
232 r = getrandbits(k)
233 return r
Raymond Hettinger05a505f2010-09-07 19:19:33 +0000234 # There's an overriden random() method but no new getrandbits() method,
235 # so we can only use random() from here.
Raymond Hettingere4a3e992010-09-08 00:30:28 +0000236 if n >= maxsize:
Raymond Hettinger2f726e92003-10-05 09:09:15 +0000237 _warn("Underlying random() generator does not supply \n"
Raymond Hettingerf015b3f2010-09-07 20:04:42 +0000238 "enough bits to choose from a population range this large.\n"
239 "To remove the range limitation, add a getrandbits() method.")
Raymond Hettingere4a3e992010-09-08 00:30:28 +0000240 return int(random() * n)
241 rem = maxsize % n
242 limit = (maxsize - rem) / maxsize # int(limit * maxsize) % n == 0
243 r = random()
244 while r >= limit:
245 r = random()
246 return int(r*maxsize) % n
Raymond Hettinger2f726e92003-10-05 09:09:15 +0000247
Tim Peterscd804102001-01-25 20:25:57 +0000248## -------------------- sequence methods -------------------
249
Tim Petersd7b5e882001-01-25 03:36:26 +0000250 def choice(self, seq):
251 """Choose a random element from a non-empty sequence."""
Raymond Hettingerdc4872e2010-09-07 10:06:56 +0000252 try:
253 i = self._randbelow(len(seq))
254 except ValueError:
255 raise IndexError('Cannot choose from an empty sequence')
256 return seq[i]
Tim Petersd7b5e882001-01-25 03:36:26 +0000257
Raymond Hettinger8fe47c32013-10-05 21:48:21 -0700258 def shuffle(self, x, random=None):
Antoine Pitrou5e394332012-11-04 02:10:33 +0100259 """Shuffle list x in place, and return None.
Tim Petersd7b5e882001-01-25 03:36:26 +0000260
Antoine Pitrou5e394332012-11-04 02:10:33 +0100261 Optional argument random is a 0-argument function returning a
262 random float in [0.0, 1.0); if it is the default None, the
263 standard random.random will be used.
Senthil Kumaranf8ce51a2013-09-11 22:54:31 -0700264
Tim Petersd7b5e882001-01-25 03:36:26 +0000265 """
266
Raymond Hettinger8fe47c32013-10-05 21:48:21 -0700267 if random is None:
268 randbelow = self._randbelow
269 for i in reversed(range(1, len(x))):
270 # pick an element in x[:i+1] with which to exchange x[i]
271 j = randbelow(i+1)
272 x[i], x[j] = x[j], x[i]
273 else:
274 _int = int
275 for i in reversed(range(1, len(x))):
276 # pick an element in x[:i+1] with which to exchange x[i]
277 j = _int(random() * (i+1))
278 x[i], x[j] = x[j], x[i]
Tim Petersd7b5e882001-01-25 03:36:26 +0000279
Raymond Hettingerfdbe5222003-06-13 07:01:51 +0000280 def sample(self, population, k):
Raymond Hettinger1acde192008-01-14 01:00:53 +0000281 """Chooses k unique random elements from a population sequence or set.
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000282
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000283 Returns a new list containing elements from the population while
284 leaving the original population unchanged. The resulting list is
285 in selection order so that all sub-slices will also be valid random
286 samples. This allows raffle winners (the sample) to be partitioned
287 into grand prize and second place winners (the subslices).
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000288
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000289 Members of the population need not be hashable or unique. If the
290 population contains repeats, then each occurrence is a possible
291 selection in the sample.
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000292
Guido van Rossum805365e2007-05-07 22:24:25 +0000293 To choose a sample in a range of integers, use range as an argument.
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000294 This is especially fast and space efficient for sampling from a
Guido van Rossum805365e2007-05-07 22:24:25 +0000295 large population: sample(range(10000000), 60)
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000296 """
297
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000298 # Sampling without replacement entails tracking either potential
Raymond Hettinger91e27c22005-08-19 01:36:35 +0000299 # selections (the pool) in a list or previous selections in a set.
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000300
Jeremy Hylton2b55d352004-02-23 17:27:57 +0000301 # When the number of selections is small compared to the
302 # population, then tracking selections is efficient, requiring
Raymond Hettinger91e27c22005-08-19 01:36:35 +0000303 # only a small set and an occasional reselection. For
Jeremy Hylton2b55d352004-02-23 17:27:57 +0000304 # a larger number of selections, the pool tracking method is
305 # preferred since the list takes less space than the
Raymond Hettinger91e27c22005-08-19 01:36:35 +0000306 # set and it doesn't suffer from frequent reselections.
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000307
Raymond Hettinger57d1a882011-02-23 00:46:28 +0000308 if isinstance(population, _Set):
Raymond Hettinger1acde192008-01-14 01:00:53 +0000309 population = tuple(population)
Raymond Hettinger57d1a882011-02-23 00:46:28 +0000310 if not isinstance(population, _Sequence):
311 raise TypeError("Population must be a sequence or set. For dicts, use list(d).")
Raymond Hettinger05a505f2010-09-07 19:19:33 +0000312 randbelow = self._randbelow
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000313 n = len(population)
314 if not 0 <= k <= n:
Raymond Hettinger1acde192008-01-14 01:00:53 +0000315 raise ValueError("Sample larger than population")
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000316 result = [None] * k
Raymond Hettinger91e27c22005-08-19 01:36:35 +0000317 setsize = 21 # size of a small set minus size of an empty list
318 if k > 5:
Tim Peters9e34c042005-08-26 15:20:46 +0000319 setsize += 4 ** _ceil(_log(k * 3, 4)) # table size for big sets
Raymond Hettinger1acde192008-01-14 01:00:53 +0000320 if n <= setsize:
321 # An n-length list is smaller than a k-length set
Raymond Hettinger311f4192002-11-18 09:01:24 +0000322 pool = list(population)
Guido van Rossum805365e2007-05-07 22:24:25 +0000323 for i in range(k): # invariant: non-selected at [0,n-i)
Raymond Hettinger05a505f2010-09-07 19:19:33 +0000324 j = randbelow(n-i)
Raymond Hettinger311f4192002-11-18 09:01:24 +0000325 result[i] = pool[j]
Raymond Hettinger8b9aa8d2003-01-04 05:20:33 +0000326 pool[j] = pool[n-i-1] # move non-selected item into vacancy
Raymond Hettingerc0b40342002-11-13 15:26:37 +0000327 else:
Raymond Hettinger1acde192008-01-14 01:00:53 +0000328 selected = set()
329 selected_add = selected.add
330 for i in range(k):
Raymond Hettinger05a505f2010-09-07 19:19:33 +0000331 j = randbelow(n)
Raymond Hettinger1acde192008-01-14 01:00:53 +0000332 while j in selected:
Raymond Hettinger05a505f2010-09-07 19:19:33 +0000333 j = randbelow(n)
Raymond Hettinger1acde192008-01-14 01:00:53 +0000334 selected_add(j)
335 result[i] = population[j]
Raymond Hettinger311f4192002-11-18 09:01:24 +0000336 return result
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000337
Tim Peterscd804102001-01-25 20:25:57 +0000338## -------------------- real-valued distributions -------------------
339
340## -------------------- uniform distribution -------------------
Tim Petersd7b5e882001-01-25 03:36:26 +0000341
342 def uniform(self, a, b):
Raymond Hettingerbe40db02009-06-11 23:12:14 +0000343 "Get a random number in the range [a, b) or [a, b] depending on rounding."
Tim Petersd7b5e882001-01-25 03:36:26 +0000344 return a + (b-a) * self.random()
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000345
Christian Heimesfe337bf2008-03-23 21:54:12 +0000346## -------------------- triangular --------------------
347
348 def triangular(self, low=0.0, high=1.0, mode=None):
349 """Triangular distribution.
350
351 Continuous distribution bounded by given lower and upper limits,
352 and having a given mode value in-between.
353
354 http://en.wikipedia.org/wiki/Triangular_distribution
355
356 """
357 u = self.random()
Raymond Hettinger978c6ab2014-05-25 17:25:27 -0700358 try:
359 c = 0.5 if mode is None else (mode - low) / (high - low)
360 except ZeroDivisionError:
361 return low
Christian Heimesfe337bf2008-03-23 21:54:12 +0000362 if u > c:
363 u = 1.0 - u
364 c = 1.0 - c
365 low, high = high, low
366 return low + (high - low) * (u * c) ** 0.5
367
Tim Peterscd804102001-01-25 20:25:57 +0000368## -------------------- normal distribution --------------------
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000369
Tim Petersd7b5e882001-01-25 03:36:26 +0000370 def normalvariate(self, mu, sigma):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000371 """Normal distribution.
372
373 mu is the mean, and sigma is the standard deviation.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000374
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000375 """
Tim Petersd7b5e882001-01-25 03:36:26 +0000376 # mu = mean, sigma = standard deviation
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000377
Tim Petersd7b5e882001-01-25 03:36:26 +0000378 # Uses Kinderman and Monahan method. Reference: Kinderman,
379 # A.J. and Monahan, J.F., "Computer generation of random
380 # variables using the ratio of uniform deviates", ACM Trans
381 # Math Software, 3, (1977), pp257-260.
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000382
Tim Petersd7b5e882001-01-25 03:36:26 +0000383 random = self.random
Raymond Hettinger42406e62005-04-30 09:02:51 +0000384 while 1:
Tim Peters0c9886d2001-01-15 01:18:21 +0000385 u1 = random()
Raymond Hettinger73ced7e2003-01-04 09:26:32 +0000386 u2 = 1.0 - random()
Tim Petersd7b5e882001-01-25 03:36:26 +0000387 z = NV_MAGICCONST*(u1-0.5)/u2
388 zz = z*z/4.0
389 if zz <= -_log(u2):
390 break
391 return mu + z*sigma
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000392
Tim Peterscd804102001-01-25 20:25:57 +0000393## -------------------- lognormal distribution --------------------
Tim Petersd7b5e882001-01-25 03:36:26 +0000394
395 def lognormvariate(self, mu, sigma):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000396 """Log normal distribution.
397
398 If you take the natural logarithm of this distribution, you'll get a
399 normal distribution with mean mu and standard deviation sigma.
400 mu can have any value, and sigma must be greater than zero.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000401
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000402 """
Tim Petersd7b5e882001-01-25 03:36:26 +0000403 return _exp(self.normalvariate(mu, sigma))
404
Tim Peterscd804102001-01-25 20:25:57 +0000405## -------------------- exponential distribution --------------------
Tim Petersd7b5e882001-01-25 03:36:26 +0000406
407 def expovariate(self, lambd):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000408 """Exponential distribution.
409
Mark Dickinson2f947362009-01-07 17:54:07 +0000410 lambd is 1.0 divided by the desired mean. It should be
411 nonzero. (The parameter would be called "lambda", but that is
412 a reserved word in Python.) Returned values range from 0 to
413 positive infinity if lambd is positive, and from negative
414 infinity to 0 if lambd is negative.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000415
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000416 """
Tim Petersd7b5e882001-01-25 03:36:26 +0000417 # lambd: rate lambd = 1/mean
418 # ('lambda' is a Python reserved word)
419
Raymond Hettinger5279fb92011-06-25 11:30:53 +0200420 # we use 1-random() instead of random() to preclude the
421 # possibility of taking the log of zero.
422 return -_log(1.0 - self.random())/lambd
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000423
Tim Peterscd804102001-01-25 20:25:57 +0000424## -------------------- von Mises distribution --------------------
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000425
Tim Petersd7b5e882001-01-25 03:36:26 +0000426 def vonmisesvariate(self, mu, kappa):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000427 """Circular data distribution.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000428
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000429 mu is the mean angle, expressed in radians between 0 and 2*pi, and
430 kappa is the concentration parameter, which must be greater than or
431 equal to zero. If kappa is equal to zero, this distribution reduces
432 to a uniform random angle over the range 0 to 2*pi.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000433
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000434 """
Tim Petersd7b5e882001-01-25 03:36:26 +0000435 # mu: mean angle (in radians between 0 and 2*pi)
436 # kappa: concentration parameter kappa (>= 0)
437 # if kappa = 0 generate uniform random angle
438
439 # Based upon an algorithm published in: Fisher, N.I.,
440 # "Statistical Analysis of Circular Data", Cambridge
441 # University Press, 1993.
442
443 # Thanks to Magnus Kessler for a correction to the
444 # implementation of step 4.
445
446 random = self.random
447 if kappa <= 1e-6:
448 return TWOPI * random()
449
Serhiy Storchaka6c22b1d2013-02-10 19:28:56 +0200450 s = 0.5 / kappa
451 r = s + _sqrt(1.0 + s * s)
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000452
Raymond Hettinger42406e62005-04-30 09:02:51 +0000453 while 1:
Tim Peters0c9886d2001-01-15 01:18:21 +0000454 u1 = random()
Tim Petersd7b5e882001-01-25 03:36:26 +0000455 z = _cos(_pi * u1)
Tim Petersd7b5e882001-01-25 03:36:26 +0000456
Serhiy Storchaka6c22b1d2013-02-10 19:28:56 +0200457 d = z / (r + z)
Tim Petersd7b5e882001-01-25 03:36:26 +0000458 u2 = random()
Serhiy Storchaka6c22b1d2013-02-10 19:28:56 +0200459 if u2 < 1.0 - d * d or u2 <= (1.0 - d) * _exp(d):
Tim Peters0c9886d2001-01-15 01:18:21 +0000460 break
Tim Petersd7b5e882001-01-25 03:36:26 +0000461
Serhiy Storchaka6c22b1d2013-02-10 19:28:56 +0200462 q = 1.0 / r
463 f = (q + z) / (1.0 + q * z)
Tim Petersd7b5e882001-01-25 03:36:26 +0000464 u3 = random()
465 if u3 > 0.5:
Mark Dickinsonbe5f9192013-02-10 14:16:10 +0000466 theta = (mu + _acos(f)) % TWOPI
Tim Petersd7b5e882001-01-25 03:36:26 +0000467 else:
Mark Dickinsonbe5f9192013-02-10 14:16:10 +0000468 theta = (mu - _acos(f)) % TWOPI
Tim Petersd7b5e882001-01-25 03:36:26 +0000469
470 return theta
471
Tim Peterscd804102001-01-25 20:25:57 +0000472## -------------------- gamma distribution --------------------
Tim Petersd7b5e882001-01-25 03:36:26 +0000473
474 def gammavariate(self, alpha, beta):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000475 """Gamma distribution. Not the gamma function!
476
477 Conditions on the parameters are alpha > 0 and beta > 0.
478
Raymond Hettingera8e4d6e2011-03-22 15:55:51 -0700479 The probability distribution function is:
480
481 x ** (alpha - 1) * math.exp(-x / beta)
482 pdf(x) = --------------------------------------
483 math.gamma(alpha) * beta ** alpha
484
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000485 """
Tim Peters8ac14952002-05-23 15:15:30 +0000486
Raymond Hettingerb760efb2002-05-14 06:40:34 +0000487 # alpha > 0, beta > 0, mean is alpha*beta, variance is alpha*beta**2
Tim Peters8ac14952002-05-23 15:15:30 +0000488
Guido van Rossum570764d2002-05-14 14:08:12 +0000489 # Warning: a few older sources define the gamma distribution in terms
490 # of alpha > -1.0
491 if alpha <= 0.0 or beta <= 0.0:
Collin Winterce36ad82007-08-30 01:19:48 +0000492 raise ValueError('gammavariate: alpha and beta must be > 0.0')
Tim Peters8ac14952002-05-23 15:15:30 +0000493
Tim Petersd7b5e882001-01-25 03:36:26 +0000494 random = self.random
Tim Petersd7b5e882001-01-25 03:36:26 +0000495 if alpha > 1.0:
496
497 # Uses R.C.H. Cheng, "The generation of Gamma
498 # variables with non-integral shape parameters",
499 # Applied Statistics, (1977), 26, No. 1, p71-74
500
Raymond Hettingerca6cdc22002-05-13 23:40:14 +0000501 ainv = _sqrt(2.0 * alpha - 1.0)
502 bbb = alpha - LOG4
503 ccc = alpha + ainv
Tim Peters8ac14952002-05-23 15:15:30 +0000504
Raymond Hettinger42406e62005-04-30 09:02:51 +0000505 while 1:
Tim Petersd7b5e882001-01-25 03:36:26 +0000506 u1 = random()
Raymond Hettinger73ced7e2003-01-04 09:26:32 +0000507 if not 1e-7 < u1 < .9999999:
508 continue
509 u2 = 1.0 - random()
Tim Petersd7b5e882001-01-25 03:36:26 +0000510 v = _log(u1/(1.0-u1))/ainv
511 x = alpha*_exp(v)
512 z = u1*u1*u2
513 r = bbb+ccc*v-x
514 if r + SG_MAGICCONST - 4.5*z >= 0.0 or r >= _log(z):
Raymond Hettingerb760efb2002-05-14 06:40:34 +0000515 return x * beta
Tim Petersd7b5e882001-01-25 03:36:26 +0000516
517 elif alpha == 1.0:
518 # expovariate(1)
519 u = random()
520 while u <= 1e-7:
521 u = random()
Raymond Hettingerb760efb2002-05-14 06:40:34 +0000522 return -_log(u) * beta
Tim Petersd7b5e882001-01-25 03:36:26 +0000523
524 else: # alpha is between 0 and 1 (exclusive)
525
526 # Uses ALGORITHM GS of Statistical Computing - Kennedy & Gentle
527
Raymond Hettinger42406e62005-04-30 09:02:51 +0000528 while 1:
Tim Petersd7b5e882001-01-25 03:36:26 +0000529 u = random()
530 b = (_e + alpha)/_e
531 p = b*u
532 if p <= 1.0:
Raymond Hettinger42406e62005-04-30 09:02:51 +0000533 x = p ** (1.0/alpha)
Tim Petersd7b5e882001-01-25 03:36:26 +0000534 else:
Tim Petersd7b5e882001-01-25 03:36:26 +0000535 x = -_log((b-p)/alpha)
536 u1 = random()
Raymond Hettinger42406e62005-04-30 09:02:51 +0000537 if p > 1.0:
538 if u1 <= x ** (alpha - 1.0):
539 break
540 elif u1 <= _exp(-x):
Tim Petersd7b5e882001-01-25 03:36:26 +0000541 break
Raymond Hettingerb760efb2002-05-14 06:40:34 +0000542 return x * beta
543
Tim Peterscd804102001-01-25 20:25:57 +0000544## -------------------- Gauss (faster alternative) --------------------
Guido van Rossum95bfcda1994-03-09 14:21:05 +0000545
Tim Petersd7b5e882001-01-25 03:36:26 +0000546 def gauss(self, mu, sigma):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000547 """Gaussian distribution.
548
549 mu is the mean, and sigma is the standard deviation. This is
550 slightly faster than the normalvariate() function.
551
552 Not thread-safe without a lock around calls.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000553
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000554 """
Guido van Rossumcc32ac91994-03-15 16:10:24 +0000555
Tim Petersd7b5e882001-01-25 03:36:26 +0000556 # When x and y are two variables from [0, 1), uniformly
557 # distributed, then
558 #
559 # cos(2*pi*x)*sqrt(-2*log(1-y))
560 # sin(2*pi*x)*sqrt(-2*log(1-y))
561 #
562 # are two *independent* variables with normal distribution
563 # (mu = 0, sigma = 1).
564 # (Lambert Meertens)
565 # (corrected version; bug discovered by Mike Miller, fixed by LM)
Guido van Rossumcc32ac91994-03-15 16:10:24 +0000566
Tim Petersd7b5e882001-01-25 03:36:26 +0000567 # Multithreading note: When two threads call this function
568 # simultaneously, it is possible that they will receive the
569 # same return value. The window is very small though. To
570 # avoid this, you have to use a lock around all calls. (I
571 # didn't want to slow this down in the serial case by using a
572 # lock here.)
Guido van Rossumd03e1191998-05-29 17:51:31 +0000573
Tim Petersd7b5e882001-01-25 03:36:26 +0000574 random = self.random
575 z = self.gauss_next
576 self.gauss_next = None
577 if z is None:
578 x2pi = random() * TWOPI
579 g2rad = _sqrt(-2.0 * _log(1.0 - random()))
580 z = _cos(x2pi) * g2rad
581 self.gauss_next = _sin(x2pi) * g2rad
Guido van Rossumcc32ac91994-03-15 16:10:24 +0000582
Tim Petersd7b5e882001-01-25 03:36:26 +0000583 return mu + z*sigma
Guido van Rossum95bfcda1994-03-09 14:21:05 +0000584
Tim Peterscd804102001-01-25 20:25:57 +0000585## -------------------- beta --------------------
Tim Peters85e2e472001-01-26 06:49:56 +0000586## See
Ezio Melotti20f53f12011-04-15 08:25:16 +0300587## http://mail.python.org/pipermail/python-bugs-list/2001-January/003752.html
Tim Peters85e2e472001-01-26 06:49:56 +0000588## for Ivan Frohne's insightful analysis of why the original implementation:
589##
590## def betavariate(self, alpha, beta):
591## # Discrete Event Simulation in C, pp 87-88.
592##
593## y = self.expovariate(alpha)
594## z = self.expovariate(1.0/beta)
595## return z/(y+z)
596##
597## was dead wrong, and how it probably got that way.
Guido van Rossum95bfcda1994-03-09 14:21:05 +0000598
Tim Petersd7b5e882001-01-25 03:36:26 +0000599 def betavariate(self, alpha, beta):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000600 """Beta distribution.
601
Thomas Woutersb2137042007-02-01 18:02:27 +0000602 Conditions on the parameters are alpha > 0 and beta > 0.
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000603 Returned values range between 0 and 1.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000604
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000605 """
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000606
Tim Peters85e2e472001-01-26 06:49:56 +0000607 # This version due to Janne Sinkkonen, and matches all the std
608 # texts (e.g., Knuth Vol 2 Ed 3 pg 134 "the beta distribution").
609 y = self.gammavariate(alpha, 1.)
610 if y == 0:
611 return 0.0
612 else:
613 return y / (y + self.gammavariate(beta, 1.))
Guido van Rossum95bfcda1994-03-09 14:21:05 +0000614
Tim Peterscd804102001-01-25 20:25:57 +0000615## -------------------- Pareto --------------------
Guido van Rossumcf4559a1997-12-02 02:47:39 +0000616
Tim Petersd7b5e882001-01-25 03:36:26 +0000617 def paretovariate(self, alpha):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000618 """Pareto distribution. alpha is the shape parameter."""
Tim Petersd7b5e882001-01-25 03:36:26 +0000619 # Jain, pg. 495
Guido van Rossumcf4559a1997-12-02 02:47:39 +0000620
Raymond Hettinger73ced7e2003-01-04 09:26:32 +0000621 u = 1.0 - self.random()
Raymond Hettinger8ff10992010-09-08 18:58:33 +0000622 return 1.0 / u ** (1.0/alpha)
Guido van Rossumcf4559a1997-12-02 02:47:39 +0000623
Tim Peterscd804102001-01-25 20:25:57 +0000624## -------------------- Weibull --------------------
Guido van Rossumcf4559a1997-12-02 02:47:39 +0000625
Tim Petersd7b5e882001-01-25 03:36:26 +0000626 def weibullvariate(self, alpha, beta):
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000627 """Weibull distribution.
628
629 alpha is the scale parameter and beta is the shape parameter.
Raymond Hettingeref4d4bd2002-05-23 23:58:17 +0000630
Raymond Hettingerc32f0332002-05-23 19:44:49 +0000631 """
Tim Petersd7b5e882001-01-25 03:36:26 +0000632 # Jain, pg. 499; bug fix courtesy Bill Arms
Guido van Rossumcf4559a1997-12-02 02:47:39 +0000633
Raymond Hettinger73ced7e2003-01-04 09:26:32 +0000634 u = 1.0 - self.random()
Raymond Hettinger183cd1f2010-09-08 18:48:21 +0000635 return alpha * (-_log(u)) ** (1.0/beta)
Guido van Rossum6c395ba1999-08-18 13:53:28 +0000636
Raymond Hettinger23f12412004-09-13 22:23:21 +0000637## --------------- Operating System Random Source ------------------
Raymond Hettinger356a4592004-08-30 06:14:31 +0000638
Raymond Hettinger23f12412004-09-13 22:23:21 +0000639class SystemRandom(Random):
640 """Alternate random number generator using sources provided
641 by the operating system (such as /dev/urandom on Unix or
642 CryptGenRandom on Windows).
Raymond Hettinger356a4592004-08-30 06:14:31 +0000643
644 Not available on all systems (see os.urandom() for details).
645 """
646
647 def random(self):
648 """Get the next random number in the range [0.0, 1.0)."""
Raymond Hettinger183cd1f2010-09-08 18:48:21 +0000649 return (int.from_bytes(_urandom(7), 'big') >> 3) * RECIP_BPF
Raymond Hettinger356a4592004-08-30 06:14:31 +0000650
651 def getrandbits(self, k):
Serhiy Storchaka95949422013-08-27 19:40:23 +0300652 """getrandbits(k) -> x. Generates an int with k random bits."""
Raymond Hettinger356a4592004-08-30 06:14:31 +0000653 if k <= 0:
654 raise ValueError('number of bits must be greater than zero')
655 if k != int(k):
656 raise TypeError('number of bits should be an integer')
Raymond Hettinger63b17672010-09-08 19:27:59 +0000657 numbytes = (k + 7) // 8 # bits / 8 and rounded up
658 x = int.from_bytes(_urandom(numbytes), 'big')
659 return x >> (numbytes * 8 - k) # trim excess bits
Raymond Hettinger356a4592004-08-30 06:14:31 +0000660
Raymond Hettinger28de64f2008-01-13 23:40:30 +0000661 def seed(self, *args, **kwds):
Raymond Hettinger23f12412004-09-13 22:23:21 +0000662 "Stub method. Not used for a system random number generator."
Raymond Hettinger356a4592004-08-30 06:14:31 +0000663 return None
Raymond Hettinger356a4592004-08-30 06:14:31 +0000664
665 def _notimplemented(self, *args, **kwds):
Raymond Hettinger23f12412004-09-13 22:23:21 +0000666 "Method should not be called for a system random number generator."
667 raise NotImplementedError('System entropy source does not have state.')
Raymond Hettinger356a4592004-08-30 06:14:31 +0000668 getstate = setstate = _notimplemented
669
Tim Peterscd804102001-01-25 20:25:57 +0000670## -------------------- test program --------------------
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000671
Raymond Hettinger62297132003-08-30 01:24:19 +0000672def _test_generator(n, func, args):
Tim Peters0c9886d2001-01-15 01:18:21 +0000673 import time
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000674 print(n, 'times', func.__name__)
Raymond Hettingerb98154e2003-05-24 17:26:02 +0000675 total = 0.0
Tim Peters0c9886d2001-01-15 01:18:21 +0000676 sqsum = 0.0
677 smallest = 1e10
678 largest = -1e10
679 t0 = time.time()
680 for i in range(n):
Raymond Hettinger62297132003-08-30 01:24:19 +0000681 x = func(*args)
Raymond Hettingerb98154e2003-05-24 17:26:02 +0000682 total += x
Tim Peters0c9886d2001-01-15 01:18:21 +0000683 sqsum = sqsum + x*x
684 smallest = min(x, smallest)
685 largest = max(x, largest)
686 t1 = time.time()
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000687 print(round(t1-t0, 3), 'sec,', end=' ')
Raymond Hettingerb98154e2003-05-24 17:26:02 +0000688 avg = total/n
Tim Petersd7b5e882001-01-25 03:36:26 +0000689 stddev = _sqrt(sqsum/n - avg*avg)
Raymond Hettinger1f548142014-05-19 20:21:43 +0100690 print('avg %g, stddev %g, min %g, max %g\n' % \
Guido van Rossumbe19ed72007-02-09 05:37:30 +0000691 (avg, stddev, smallest, largest))
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000692
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000693
694def _test(N=2000):
Raymond Hettinger62297132003-08-30 01:24:19 +0000695 _test_generator(N, random, ())
696 _test_generator(N, normalvariate, (0.0, 1.0))
697 _test_generator(N, lognormvariate, (0.0, 1.0))
698 _test_generator(N, vonmisesvariate, (0.0, 1.0))
699 _test_generator(N, gammavariate, (0.01, 1.0))
700 _test_generator(N, gammavariate, (0.1, 1.0))
701 _test_generator(N, gammavariate, (0.1, 2.0))
702 _test_generator(N, gammavariate, (0.5, 1.0))
703 _test_generator(N, gammavariate, (0.9, 1.0))
704 _test_generator(N, gammavariate, (1.0, 1.0))
705 _test_generator(N, gammavariate, (2.0, 1.0))
706 _test_generator(N, gammavariate, (20.0, 1.0))
707 _test_generator(N, gammavariate, (200.0, 1.0))
708 _test_generator(N, gauss, (0.0, 1.0))
709 _test_generator(N, betavariate, (3.0, 3.0))
Christian Heimesfe337bf2008-03-23 21:54:12 +0000710 _test_generator(N, triangular, (0.0, 1.0, 1.0/3.0))
Tim Peterscd804102001-01-25 20:25:57 +0000711
Tim Peters715c4c42001-01-26 22:56:56 +0000712# Create one instance, seeded from current time, and export its methods
Raymond Hettinger40f62172002-12-29 23:03:38 +0000713# as module-level functions. The functions share state across all uses
714#(both in the user's code and in the Python libraries), but that's fine
715# for most programs and is easier for the casual user than making them
716# instantiate their own Random() instance.
717
Tim Petersd7b5e882001-01-25 03:36:26 +0000718_inst = Random()
719seed = _inst.seed
720random = _inst.random
721uniform = _inst.uniform
Christian Heimesfe337bf2008-03-23 21:54:12 +0000722triangular = _inst.triangular
Tim Petersd7b5e882001-01-25 03:36:26 +0000723randint = _inst.randint
724choice = _inst.choice
725randrange = _inst.randrange
Raymond Hettingerf24eb352002-11-12 17:41:57 +0000726sample = _inst.sample
Tim Petersd7b5e882001-01-25 03:36:26 +0000727shuffle = _inst.shuffle
728normalvariate = _inst.normalvariate
729lognormvariate = _inst.lognormvariate
Tim Petersd7b5e882001-01-25 03:36:26 +0000730expovariate = _inst.expovariate
731vonmisesvariate = _inst.vonmisesvariate
732gammavariate = _inst.gammavariate
Tim Petersd7b5e882001-01-25 03:36:26 +0000733gauss = _inst.gauss
734betavariate = _inst.betavariate
735paretovariate = _inst.paretovariate
736weibullvariate = _inst.weibullvariate
737getstate = _inst.getstate
738setstate = _inst.setstate
Raymond Hettinger2f726e92003-10-05 09:09:15 +0000739getrandbits = _inst.getrandbits
Tim Petersd7b5e882001-01-25 03:36:26 +0000740
Guido van Rossumff03b1a1994-03-09 12:55:02 +0000741if __name__ == '__main__':
Tim Petersd7b5e882001-01-25 03:36:26 +0000742 _test()