Lib/random.py

   1 """Random variable generators.
   2
   3     integers
   4     --------
   5            uniform within range
   6
   7     sequences
   8     ---------
   9            pick random element
  10            pick random sample
  11            generate random permutation
  12
  13     distributions on the real line:
  14     ------------------------------
  15            uniform
  16            triangular
  17            normal (Gaussian)
  18            lognormal
  19            negative exponential
  20            gamma
  21            beta
  22            pareto
  23            Weibull
  24
  25     distributions on the circle (angles 0 to 2pi)
  26     ---------------------------------------------
  27            circular uniform
  28            von Mises
  29
  30 General notes on the underlying Mersenne Twister core generator:
  31
  32 * The period is 2**19937-1.
  33 * It is one of the most extensively tested generators in existence.
  34 * Without a direct way to compute N steps forward, the semantics of
  35   jumpahead(n) are weakened to simply jump to another distant state and rely
  36   on the large period to avoid overlapping sequences.
  37 * The random() method is implemented in C, executes in a single Python step,
  38   and is, therefore, threadsafe.
  39
  40 """
  41
  42 from __future__ import division
  43 from warnings import warn as _warn
  44 from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
  45 from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
  46 from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
  47 from os import urandom as _urandom
  48 from binascii import hexlify as _hexlify
  49
  50 __all__ = ["Random","seed","random","uniform","randint","choice","sample",
  51            "randrange","shuffle","normalvariate","lognormvariate",
  52            "expovariate","vonmisesvariate","gammavariate","triangular",
  53            "gauss","betavariate","paretovariate","weibullvariate",
  54            "getstate","setstate","jumpahead", "WichmannHill", "getrandbits",
  55            "SystemRandom"]
  56
  57 NV_MAGICCONST = 4 * _exp(-0.5)/_sqrt(2.0)
  58 TWOPI = 2.0*_pi
  59 LOG4 = _log(4.0)
  60 SG_MAGICCONST = 1.0 + _log(4.5)
  61 BPF = 53        # Number of bits in a float
  62 RECIP_BPF = 2**-BPF
  63
  64
  65 # Translated by Guido van Rossum from C source provided by
  66 # Adrian Baddeley.  Adapted by Raymond Hettinger for use with
  67 # the Mersenne Twister  and os.urandom() core generators.
  68
  69 import _random
  70
  71 class Random(_random.Random):
  72     """Random number generator base class used by bound module functions.
  73
  74     Used to instantiate instances of Random to get generators that don't
  75     share state.  Especially useful for multi-threaded programs, creating
  76     a different instance of Random for each thread, and using the jumpahead()
  77     method to ensure that the generated sequences seen by each thread don't
  78     overlap.
  79
  80     Class Random can also be subclassed if you want to use a different basic
  81     generator of your own devising: in that case, override the following
  82     methods: random(), seed(), getstate(), setstate() and jumpahead().
  83     Optionally, implement a getrandbits() method so that randrange() can cover
  84     arbitrarily large ranges.
  85
  86     """
  87
  88     VERSION = 3     # used by getstate/setstate
  89
  90     def __init__(self, x=None):
  91         """Initialize an instance.
  92
  93         Optional argument x controls seeding, as for Random.seed().
  94         """
  95
  96         self.seed(x)
  97         self.gauss_next = None
  98
  99     def seed(self, a=None):
 100         """Initialize internal state from hashable object.
 101
 102         None or no argument seeds from current time or from an operating
 103         system specific randomness source if available.
 104
 105         If a is not None or an int or long, hash(a) is used instead.
 106         """
 107
 108         if a is None:
 109             try:
 110                 a = long(_hexlify(_urandom(16)), 16)
 111             except NotImplementedError:
 112                 import time
 113                 a = long(time.time() * 256) # use fractional seconds
 114
 115         super(Random, self).seed(a)
 116         self.gauss_next = None
 117
 118     def getstate(self):
 119         """Return internal state; can be passed to setstate() later."""
 120         return self.VERSION, super(Random, self).getstate(), self.gauss_next
 121
 122     def setstate(self, state):
 123         """Restore internal state from object returned by getstate()."""
 124         version = state[0]
 125         if version == 3:
 126             version, internalstate, self.gauss_next = state
 127             super(Random, self).setstate(internalstate)
 128         elif version == 2:
 129             version, internalstate, self.gauss_next = state
 130             # In version 2, the state was saved as signed ints, which causes
 131             #   inconsistencies between 32/64-bit systems. The state is
 132             #   really unsigned 32-bit ints, so we convert negative ints from
 133             #   version 2 to positive longs for version 3.
 134             try:
 135                 internalstate = tuple( long(x) % (2**32) for x in internalstate )
 136             except ValueError, e:
 137                 raise TypeError, e
 138             super(Random, self).setstate(internalstate)
 139         else:
 140             raise ValueError("state with version %s passed to "
 141                              "Random.setstate() of version %s" %
 142                              (version, self.VERSION))
 143
 144 ## ---- Methods below this point do not need to be overridden when
 145 ## ---- subclassing for the purpose of using a different core generator.
 146
 147 ## -------------------- pickle support  -------------------
 148
 149     def __getstate__(self): # for pickle
 150         return self.getstate()
 151
 152     def __setstate__(self, state):  # for pickle
 153         self.setstate(state)
 154
 155     def __reduce__(self):
 156         return self.__class__, (), self.getstate()
 157
 158 ## -------------------- integer methods  -------------------
 159
 160     def randrange(self, start, stop=None, step=1, int=int, default=None,
 161                   maxwidth=1L<<BPF):
 162         """Choose a random item from range(start, stop[, step]).
 163
 164         This fixes the problem with randint() which includes the
 165         endpoint; in Python this is usually not what you want.
 166         Do not supply the 'int', 'default', and 'maxwidth' arguments.
 167         """
 168
 169         # This code is a bit messy to make it fast for the
 170         # common case while still doing adequate error checking.
 171         istart = int(start)
 172         if istart != start:
 173             raise ValueError, "non-integer arg 1 for randrange()"
 174         if stop is default:
 175             if istart > 0:
 176                 if istart >= maxwidth:
 177                     return self._randbelow(istart)
 178                 return int(self.random() * istart)
 179             raise ValueError, "empty range for randrange()"
 180
 181         # stop argument supplied.
 182         istop = int(stop)
 183         if istop != stop:
 184             raise ValueError, "non-integer stop for randrange()"
 185         width = istop - istart
 186         if step == 1 and width > 0:
 187             # Note that
 188             #     int(istart + self.random()*width)
 189             # instead would be incorrect.  For example, consider istart
 190             # = -2 and istop = 0.  Then the guts would be in
 191             # -2.0 to 0.0 exclusive on both ends (ignoring that random()
 192             # might return 0.0), and because int() truncates toward 0, the
 193             # final result would be -1 or 0 (instead of -2 or -1).
 194             #     istart + int(self.random()*width)
 195             # would also be incorrect, for a subtler reason:  the RHS
 196             # can return a long, and then randrange() would also return
 197             # a long, but we're supposed to return an int (for backward
 198             # compatibility).
 199
 200             if width >= maxwidth:
 201                 return int(istart + self._randbelow(width))
 202             return int(istart + int(self.random()*width))
 203         if step == 1:
 204             raise ValueError, "empty range for randrange() (%d,%d, %d)" % (istart, istop, width)
 205
 206         # Non-unit step argument supplied.
 207         istep = int(step)
 208         if istep != step:
 209             raise ValueError, "non-integer step for randrange()"
 210         if istep > 0:
 211             n = (width + istep - 1) // istep
 212         elif istep < 0:
 213             n = (width + istep + 1) // istep
 214         else:
 215             raise ValueError, "zero step for randrange()"
 216
 217         if n <= 0:
 218             raise ValueError, "empty range for randrange()"
 219
 220         if n >= maxwidth:
 221             return istart + istep*self._randbelow(n)
 222         return istart + istep*int(self.random() * n)
 223
 224     def randint(self, a, b):
 225         """Return random integer in range [a, b], including both end points.
 226         """
 227
 228         return self.randrange(a, b+1)
 229
 230     def _randbelow(self, n, _log=_log, int=int, _maxwidth=1L<<BPF,
 231                    _Method=_MethodType, _BuiltinMethod=_BuiltinMethodType):
 232         """Return a random int in the range [0,n)
 233
 234         Handles the case where n has more bits than returned
 235         by a single call to the underlying generator.
 236         """
 237
 238         try:
 239             getrandbits = self.getrandbits
 240         except AttributeError:
 241             pass
 242         else:
 243             # Only call self.getrandbits if the original random() builtin method
 244             # has not been overridden or if a new getrandbits() was supplied.
 245             # This assures that the two methods correspond.
 246             if type(self.random) is _BuiltinMethod or type(getrandbits) is _Method:
 247                 k = int(1.00001 + _log(n-1, 2.0))   # 2**k > n-1 > 2**(k-2)
 248                 r = getrandbits(k)
 249                 while r >= n:
 250                     r = getrandbits(k)
 251                 return r
 252         if n >= _maxwidth:
 253             _warn("Underlying random() generator does not supply \n"
 254                 "enough bits to choose from a population range this large")
 255         return int(self.random() * n)
 256
 257 ## -------------------- sequence methods  -------------------
 258
 259     def choice(self, seq):
 260         """Choose a random element from a non-empty sequence."""
 261         return seq[int(self.random() * len(seq))]  # raises IndexError if seq is empty
 262
 263     def shuffle(self, x, random=None, int=int):
 264         """x, random=random.random -> shuffle list x in place; return None.
 265
 266         Optional arg random is a 0-argument function returning a random
 267         float in [0.0, 1.0); by default, the standard random.random.
 268         """
 269
 270         if random is None:
 271             random = self.random
 272         for i in reversed(xrange(1, len(x))):
 273             # pick an element in x[:i+1] with which to exchange x[i]
 274             j = int(random() * (i+1))
 275             x[i], x[j] = x[j], x[i]
 276
 277     def sample(self, population, k):
 278         """Chooses k unique random elements from a population sequence.
 279
 280         Returns a new list containing elements from the population while
 281         leaving the original population unchanged.  The resulting list is
 282         in selection order so that all sub-slices will also be valid random
 283         samples.  This allows raffle winners (the sample) to be partitioned
 284         into grand prize and second place winners (the subslices).
 285
 286         Members of the population need not be hashable or unique.  If the
 287         population contains repeats, then each occurrence is a possible
 288         selection in the sample.
 289
 290         To choose a sample in a range of integers, use xrange as an argument.
 291         This is especially fast and space efficient for sampling from a
 292         large population:   sample(xrange(10000000), 60)
 293         """
 294
 295         # XXX Although the documentation says `population` is "a sequence",
 296         # XXX attempts are made to cater to any iterable with a __len__
 297         # XXX method.  This has had mixed success.  Examples from both
 298         # XXX sides:  sets work fine, and should become officially supported;
 299         # XXX dicts are much harder, and have failed in various subtle
 300         # XXX ways across attempts.  Support for mapping types should probably
 301         # XXX be dropped (and users should pass mapping.keys() or .values()
 302         # XXX explicitly).
 303
 304         # Sampling without replacement entails tracking either potential
 305         # selections (the pool) in a list or previous selections in a set.
 306
 307         # When the number of selections is small compared to the
 308         # population, then tracking selections is efficient, requiring
 309         # only a small set and an occasional reselection.  For
 310         # a larger number of selections, the pool tracking method is
 311         # preferred since the list takes less space than the
 312         # set and it doesn't suffer from frequent reselections.
 313
 314         n = len(population)
 315         if not 0 <= k <= n:
 316             raise ValueError, "sample larger than population"
 317         random = self.random
 318         _int = int
 319         result = [None] * k
 320         setsize = 21        # size of a small set minus size of an empty list
 321         if k > 5:
 322             setsize += 4 ** _ceil(_log(k * 3, 4)) # table size for big sets
 323         if n <= setsize or hasattr(population, "keys"):
 324             # An n-length list is smaller than a k-length set, or this is a
 325             # mapping type so the other algorithm wouldn't work.
 326             pool = list(population)
 327             for i in xrange(k):         # invariant:  non-selected at [0,n-i)
 328                 j = _int(random() * (n-i))
 329                 result[i] = pool[j]
 330                 pool[j] = pool[n-i-1]   # move non-selected item into vacancy
 331         else:
 332             try:
 333                 selected = set()
 334                 selected_add = selected.add
 335                 for i in xrange(k):
 336                     j = _int(random() * n)
 337                     while j in selected:
 338                         j = _int(random() * n)
 339                     selected_add(j)
 340                     result[i] = population[j]
 341             except (TypeError, KeyError):   # handle (at least) sets
 342                 if isinstance(population, list):
 343                     raise
 344                 return self.sample(tuple(population), k)
 345         return result
 346
 347 ## -------------------- real-valued distributions  -------------------
 348
 349 ## -------------------- uniform distribution -------------------
 350
 351     def uniform(self, a, b):
 352         """Get a random number in the range [a, b)."""
 353         return a + (b-a) * self.random()
 354
 355 ## -------------------- triangular --------------------
 356
 357     def triangular(self, low=0.0, high=1.0, mode=None):
 358         """Triangular distribution.
 359
 360         Continuous distribution bounded by given lower and upper limits,
 361         and having a given mode value in-between.
 362
 363         http://en.wikipedia.org/wiki/Triangular_distribution
 364
 365         """
 366         u = self.random()
 367         c = 0.5 if mode is None else (mode - low) / (high - low)
 368         if u > c:
 369             u = 1.0 - u
 370             c = 1.0 - c
 371             low, high = high, low
 372         return low + (high - low) * (u * c) ** 0.5
 373
 374 ## -------------------- normal distribution --------------------
 375
 376     def normalvariate(self, mu, sigma):
 377         """Normal distribution.
 378
 379         mu is the mean, and sigma is the standard deviation.
 380
 381         """
 382         # mu = mean, sigma = standard deviation
 383
 384         # Uses Kinderman and Monahan method. Reference: Kinderman,
 385         # A.J. and Monahan, J.F., "Computer generation of random
 386         # variables using the ratio of uniform deviates", ACM Trans
 387         # Math Software, 3, (1977), pp257-260.
 388
 389         random = self.random
 390         while 1:
 391             u1 = random()
 392             u2 = 1.0 - random()
 393             z = NV_MAGICCONST*(u1-0.5)/u2
 394             zz = z*z/4.0
 395             if zz <= -_log(u2):
 396                 break
 397         return mu + z*sigma
 398
 399 ## -------------------- lognormal distribution --------------------
 400
 401     def lognormvariate(self, mu, sigma):
 402         """Log normal distribution.
 403
 404         If you take the natural logarithm of this distribution, you'll get a
 405         normal distribution with mean mu and standard deviation sigma.
 406         mu can have any value, and sigma must be greater than zero.
 407
 408         """
 409         return _exp(self.normalvariate(mu, sigma))
 410
 411 ## -------------------- exponential distribution --------------------
 412
 413     def expovariate(self, lambd):
 414         """Exponential distribution.
 415
 416         lambd is 1.0 divided by the desired mean.  It should be
 417         nonzero.  (The parameter would be called "lambda", but that is
 418         a reserved word in Python.)  Returned values range from 0 to
 419         positive infinity if lambd is positive, and from negative
 420         infinity to 0 if lambd is negative.
 421
 422         """
 423         # lambd: rate lambd = 1/mean
 424         # ('lambda' is a Python reserved word)
 425
 426         random = self.random
 427         u = random()
 428         while u <= 1e-7:
 429             u = random()
 430         return -_log(u)/lambd
 431
 432 ## -------------------- von Mises distribution --------------------
 433
 434     def vonmisesvariate(self, mu, kappa):
 435         """Circular data distribution.
 436
 437         mu is the mean angle, expressed in radians between 0 and 2*pi, and
 438         kappa is the concentration parameter, which must be greater than or
 439         equal to zero.  If kappa is equal to zero, this distribution reduces
 440         to a uniform random angle over the range 0 to 2*pi.
 441
 442         """
 443         # mu:    mean angle (in radians between 0 and 2*pi)
 444         # kappa: concentration parameter kappa (>= 0)
 445         # if kappa = 0 generate uniform random angle
 446
 447         # Based upon an algorithm published in: Fisher, N.I.,
 448         # "Statistical Analysis of Circular Data", Cambridge
 449         # University Press, 1993.
 450
 451         # Thanks to Magnus Kessler for a correction to the
 452         # implementation of step 4.
 453
 454         random = self.random
 455         if kappa <= 1e-6:
 456             return TWOPI * random()
 457
 458         a = 1.0 + _sqrt(1.0 + 4.0 * kappa * kappa)
 459         b = (a - _sqrt(2.0 * a))/(2.0 * kappa)
 460         r = (1.0 + b * b)/(2.0 * b)
 461
 462         while 1:
 463             u1 = random()
 464
 465             z = _cos(_pi * u1)
 466             f = (1.0 + r * z)/(r + z)
 467             c = kappa * (r - f)
 468
 469             u2 = random()
 470
 471             if u2 < c * (2.0 - c) or u2 <= c * _exp(1.0 - c):
 472                 break
 473
 474         u3 = random()
 475         if u3 > 0.5:
 476             theta = (mu % TWOPI) + _acos(f)
 477         else:
 478             theta = (mu % TWOPI) - _acos(f)
 479
 480         return theta
 481
 482 ## -------------------- gamma distribution --------------------
 483
 484     def gammavariate(self, alpha, beta):
 485         """Gamma distribution.  Not the gamma function!
 486
 487         Conditions on the parameters are alpha > 0 and beta > 0.
 488
 489         """
 490
 491         # alpha > 0, beta > 0, mean is alpha*beta, variance is alpha*beta**2
 492
 493         # Warning: a few older sources define the gamma distribution in terms
 494         # of alpha > -1.0
 495         if alpha <= 0.0 or beta <= 0.0:
 496             raise ValueError, 'gammavariate: alpha and beta must be > 0.0'
 497
 498         random = self.random
 499         if alpha > 1.0:
 500
 501             # Uses R.C.H. Cheng, "The generation of Gamma
 502             # variables with non-integral shape parameters",
 503             # Applied Statistics, (1977), 26, No. 1, p71-74
 504
 505             ainv = _sqrt(2.0 * alpha - 1.0)
 506             bbb = alpha - LOG4
 507             ccc = alpha + ainv
 508
 509             while 1:
 510                 u1 = random()
 511                 if not 1e-7 < u1 < .9999999:
 512                     continue
 513                 u2 = 1.0 - random()
 514                 v = _log(u1/(1.0-u1))/ainv
 515                 x = alpha*_exp(v)
 516                 z = u1*u1*u2
 517                 r = bbb+ccc*v-x
 518                 if r + SG_MAGICCONST - 4.5*z >= 0.0 or r >= _log(z):
 519                     return x * beta
 520
 521         elif alpha == 1.0:
 522             # expovariate(1)
 523             u = random()
 524             while u <= 1e-7:
 525                 u = random()
 526             return -_log(u) * beta
 527
 528         else:   # alpha is between 0 and 1 (exclusive)
 529
 530             # Uses ALGORITHM GS of Statistical Computing - Kennedy & Gentle
 531
 532             while 1:
 533                 u = random()
 534                 b = (_e + alpha)/_e
 535                 p = b*u
 536                 if p <= 1.0:
 537                     x = p ** (1.0/alpha)
 538                 else:
 539                     x = -_log((b-p)/alpha)
 540                 u1 = random()
 541                 if p > 1.0:
 542                     if u1 <= x ** (alpha - 1.0):
 543                         break
 544                 elif u1 <= _exp(-x):
 545                     break
 546             return x * beta
 547
 548 ## -------------------- Gauss (faster alternative) --------------------
 549
 550     def gauss(self, mu, sigma):
 551         """Gaussian distribution.
 552
 553         mu is the mean, and sigma is the standard deviation.  This is
 554         slightly faster than the normalvariate() function.
 555
 556         Not thread-safe without a lock around calls.
 557
 558         """
 559
 560         # When x and y are two variables from [0, 1), uniformly
 561         # distributed, then
 562         #
 563         #    cos(2*pi*x)*sqrt(-2*log(1-y))
 564         #    sin(2*pi*x)*sqrt(-2*log(1-y))
 565         #
 566         # are two *independent* variables with normal distribution
 567         # (mu = 0, sigma = 1).
 568         # (Lambert Meertens)
 569         # (corrected version; bug discovered by Mike Miller, fixed by LM)
 570
 571         # Multithreading note: When two threads call this function
 572         # simultaneously, it is possible that they will receive the
 573         # same return value.  The window is very small though.  To
 574         # avoid this, you have to use a lock around all calls.  (I
 575         # didn't want to slow this down in the serial case by using a
 576         # lock here.)
 577
 578         random = self.random
 579         z = self.gauss_next
 580         self.gauss_next = None
 581         if z is None:
 582             x2pi = random() * TWOPI
 583             g2rad = _sqrt(-2.0 * _log(1.0 - random()))
 584             z = _cos(x2pi) * g2rad
 585             self.gauss_next = _sin(x2pi) * g2rad
 586
 587         return mu + z*sigma
 588
 589 ## -------------------- beta --------------------
 590 ## See
 591 ## http://sourceforge.net/bugs/?func=detailbug&bug_id=130030&group_id=5470
 592 ## for Ivan Frohne's insightful analysis of why the original implementation:
 593 ##
 594 ##    def betavariate(self, alpha, beta):
 595 ##        # Discrete Event Simulation in C, pp 87-88.
 596 ##
 597 ##        y = self.expovariate(alpha)
 598 ##        z = self.expovariate(1.0/beta)
 599 ##        return z/(y+z)
 600 ##
 601 ## was dead wrong, and how it probably got that way.
 602
 603     def betavariate(self, alpha, beta):
 604         """Beta distribution.
 605
 606         Conditions on the parameters are alpha > 0 and beta > 0.
 607         Returned values range between 0 and 1.
 608
 609         """
 610
 611         # This version due to Janne Sinkkonen, and matches all the std
 612         # texts (e.g., Knuth Vol 2 Ed 3 pg 134 "the beta distribution").
 613         y = self.gammavariate(alpha, 1.)
 614         if y == 0:
 615             return 0.0
 616         else:
 617             return y / (y + self.gammavariate(beta, 1.))
 618
 619 ## -------------------- Pareto --------------------
 620
 621     def paretovariate(self, alpha):
 622         """Pareto distribution.  alpha is the shape parameter."""
 623         # Jain, pg. 495
 624
 625         u = 1.0 - self.random()
 626         return 1.0 / pow(u, 1.0/alpha)
 627
 628 ## -------------------- Weibull --------------------
 629
 630     def weibullvariate(self, alpha, beta):
 631         """Weibull distribution.
 632
 633         alpha is the scale parameter and beta is the shape parameter.
 634
 635         """
 636         # Jain, pg. 499; bug fix courtesy Bill Arms
 637
 638         u = 1.0 - self.random()
 639         return alpha * pow(-_log(u), 1.0/beta)
 640
 641 ## -------------------- Wichmann-Hill -------------------
 642
 643 class WichmannHill(Random):
 644
 645     VERSION = 1     # used by getstate/setstate
 646
 647     def seed(self, a=None):
 648         """Initialize internal state from hashable object.
 649
 650         None or no argument seeds from current time or from an operating
 651         system specific randomness source if available.
 652
 653         If a is not None or an int or long, hash(a) is used instead.
 654
 655         If a is an int or long, a is used directly.  Distinct values between
 656         0 and 27814431486575L inclusive are guaranteed to yield distinct
 657         internal states (this guarantee is specific to the default
 658         Wichmann-Hill generator).
 659         """
 660
 661         if a is None:
 662             try:
 663                 a = long(_hexlify(_urandom(16)), 16)
 664             except NotImplementedError:
 665                 import time
 666                 a = long(time.time() * 256) # use fractional seconds
 667
 668         if not isinstance(a, (int, long)):
 669             a = hash(a)
 670
 671         a, x = divmod(a, 30268)
 672         a, y = divmod(a, 30306)
 673         a, z = divmod(a, 30322)
 674         self._seed = int(x)+1, int(y)+1, int(z)+1
 675
 676         self.gauss_next = None
 677
 678     def random(self):
 679         """Get the next random number in the range [0.0, 1.0)."""
 680
 681         # Wichman-Hill random number generator.
 682         #
 683         # Wichmann, B. A. & Hill, I. D. (1982)
 684         # Algorithm AS 183:
 685         # An efficient and portable pseudo-random number generator
 686         # Applied Statistics 31 (1982) 188-190
 687         #
 688         # see also:
 689         #        Correction to Algorithm AS 183
 690         #        Applied Statistics 33 (1984) 123
 691         #
 692         #        McLeod, A. I. (1985)
 693         #        A remark on Algorithm AS 183
 694         #        Applied Statistics 34 (1985),198-200
 695
 696         # This part is thread-unsafe:
 697         # BEGIN CRITICAL SECTION
 698         x, y, z = self._seed
 699         x = (171 * x) % 30269
 700         y = (172 * y) % 30307
 701         z = (170 * z) % 30323
 702         self._seed = x, y, z
 703         # END CRITICAL SECTION
 704
 705         # Note:  on a platform using IEEE-754 double arithmetic, this can
 706         # never return 0.0 (asserted by Tim; proof too long for a comment).
 707         return (x/30269.0 + y/30307.0 + z/30323.0) % 1.0
 708
 709     def getstate(self):
 710         """Return internal state; can be passed to setstate() later."""
 711         return self.VERSION, self._seed, self.gauss_next
 712
 713     def setstate(self, state):
 714         """Restore internal state from object returned by getstate()."""
 715         version = state[0]
 716         if version == 1:
 717             version, self._seed, self.gauss_next = state
 718         else:
 719             raise ValueError("state with version %s passed to "
 720                              "Random.setstate() of version %s" %
 721                              (version, self.VERSION))
 722
 723     def jumpahead(self, n):
 724         """Act as if n calls to random() were made, but quickly.
 725
 726         n is an int, greater than or equal to 0.
 727
 728         Example use:  If you have 2 threads and know that each will
 729         consume no more than a million random numbers, create two Random
 730         objects r1 and r2, then do
 731             r2.setstate(r1.getstate())
 732             r2.jumpahead(1000000)
 733         Then r1 and r2 will use guaranteed-disjoint segments of the full
 734         period.
 735         """
 736
 737         if not n >= 0:
 738             raise ValueError("n must be >= 0")
 739         x, y, z = self._seed
 740         x = int(x * pow(171, n, 30269)) % 30269
 741         y = int(y * pow(172, n, 30307)) % 30307
 742         z = int(z * pow(170, n, 30323)) % 30323
 743         self._seed = x, y, z
 744
 745     def __whseed(self, x=0, y=0, z=0):
 746         """Set the Wichmann-Hill seed from (x, y, z).
 747
 748         These must be integers in the range [0, 256).
 749         """
 750
 751         if not type(x) == type(y) == type(z) == int:
 752             raise TypeError('seeds must be integers')
 753         if not (0 <= x < 256 and 0 <= y < 256 and 0 <= z < 256):
 754             raise ValueError('seeds must be in range(0, 256)')
 755         if 0 == x == y == z:
 756             # Initialize from current time
 757             import time
 758             t = long(time.time() * 256)
 759             t = int((t&0xffffff) ^ (t>>24))
 760             t, x = divmod(t, 256)
 761             t, y = divmod(t, 256)
 762             t, z = divmod(t, 256)
 763         # Zero is a poor seed, so substitute 1
 764         self._seed = (x or 1, y or 1, z or 1)
 765
 766         self.gauss_next = None
 767
 768     def whseed(self, a=None):
 769         """Seed from hashable object's hash code.
 770
 771         None or no argument seeds from current time.  It is not guaranteed
 772         that objects with distinct hash codes lead to distinct internal
 773         states.
 774
 775         This is obsolete, provided for compatibility with the seed routine
 776         used prior to Python 2.1.  Use the .seed() method instead.
 777         """
 778
 779         if a is None:
 780             self.__whseed()
 781             return
 782         a = hash(a)
 783         a, x = divmod(a, 256)
 784         a, y = divmod(a, 256)
 785         a, z = divmod(a, 256)
 786         x = (x + a) % 256 or 1
 787         y = (y + a) % 256 or 1
 788         z = (z + a) % 256 or 1
 789         self.__whseed(x, y, z)
 790
 791 ## --------------- Operating System Random Source  ------------------
 792
 793 class SystemRandom(Random):
 794     """Alternate random number generator using sources provided
 795     by the operating system (such as /dev/urandom on Unix or
 796     CryptGenRandom on Windows).
 797
 798      Not available on all systems (see os.urandom() for details).
 799     """
 800
 801     def random(self):
 802         """Get the next random number in the range [0.0, 1.0)."""
 803         return (long(_hexlify(_urandom(7)), 16) >> 3) * RECIP_BPF
 804
 805     def getrandbits(self, k):
 806         """getrandbits(k) -> x.  Generates a long int with k random bits."""
 807         if k <= 0:
 808             raise ValueError('number of bits must be greater than zero')
 809         if k != int(k):
 810             raise TypeError('number of bits should be an integer')
 811         bytes = (k + 7) // 8                    # bits / 8 and rounded up
 812         x = long(_hexlify(_urandom(bytes)), 16)
 813         return x >> (bytes * 8 - k)             # trim excess bits
 814
 815     def _stub(self, *args, **kwds):
 816         "Stub method.  Not used for a system random number generator."
 817         return None
 818     seed = jumpahead = _stub
 819
 820     def _notimplemented(self, *args, **kwds):
 821         "Method should not be called for a system random number generator."
 822         raise NotImplementedError('System entropy source does not have state.')
 823     getstate = setstate = _notimplemented
 824
 825 ## -------------------- test program --------------------
 826
 827 def _test_generator(n, func, args):
 828     import time
 829     print n, 'times', func.__name__
 830     total = 0.0
 831     sqsum = 0.0
 832     smallest = 1e10
 833     largest = -1e10
 834     t0 = time.time()
 835     for i in range(n):
 836         x = func(*args)
 837         total += x
 838         sqsum = sqsum + x*x
 839         smallest = min(x, smallest)
 840         largest = max(x, largest)
 841     t1 = time.time()
 842     print round(t1-t0, 3), 'sec,',
 843     avg = total/n
 844     stddev = _sqrt(sqsum/n - avg*avg)
 845     print 'avg %g, stddev %g, min %g, max %g' % \
 846               (avg, stddev, smallest, largest)
 847
 848
 849 def _test(N=2000):
 850     _test_generator(N, random, ())
 851     _test_generator(N, normalvariate, (0.0, 1.0))
 852     _test_generator(N, lognormvariate, (0.0, 1.0))
 853     _test_generator(N, vonmisesvariate, (0.0, 1.0))
 854     _test_generator(N, gammavariate, (0.01, 1.0))
 855     _test_generator(N, gammavariate, (0.1, 1.0))
 856     _test_generator(N, gammavariate, (0.1, 2.0))
 857     _test_generator(N, gammavariate, (0.5, 1.0))
 858     _test_generator(N, gammavariate, (0.9, 1.0))
 859     _test_generator(N, gammavariate, (1.0, 1.0))
 860     _test_generator(N, gammavariate, (2.0, 1.0))
 861     _test_generator(N, gammavariate, (20.0, 1.0))
 862     _test_generator(N, gammavariate, (200.0, 1.0))
 863     _test_generator(N, gauss, (0.0, 1.0))
 864     _test_generator(N, betavariate, (3.0, 3.0))
 865     _test_generator(N, triangular, (0.0, 1.0, 1.0/3.0))
 866
 867 # Create one instance, seeded from current time, and export its methods
 868 # as module-level functions.  The functions share state across all uses
 869 #(both in the user's code and in the Python libraries), but that's fine
 870 # for most programs and is easier for the casual user than making them
 871 # instantiate their own Random() instance.
 872
 873 _inst = Random()
 874 seed = _inst.seed
 875 random = _inst.random
 876 uniform = _inst.uniform
 877 triangular = _inst.triangular
 878 randint = _inst.randint
 879 choice = _inst.choice
 880 randrange = _inst.randrange
 881 sample = _inst.sample
 882 shuffle = _inst.shuffle
 883 normalvariate = _inst.normalvariate
 884 lognormvariate = _inst.lognormvariate
 885 expovariate = _inst.expovariate
 886 vonmisesvariate = _inst.vonmisesvariate
 887 gammavariate = _inst.gammavariate
 888 gauss = _inst.gauss
 889 betavariate = _inst.betavariate
 890 paretovariate = _inst.paretovariate
 891 weibullvariate = _inst.weibullvariate
 892 getstate = _inst.getstate
 893 setstate = _inst.setstate
 894 jumpahead = _inst.jumpahead
 895 getrandbits = _inst.getrandbits
 896
 897 if __name__ == '__main__':
 898     _test()