home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / random.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  15.9 KB  |  537 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. from __future__ import division
  5. from warnings import warn as _warn
  6. from types import MethodType as _MethodType, BuiltinMethodType as _BuiltinMethodType
  7. from math import log as _log, exp as _exp, pi as _pi, e as _e, ceil as _ceil
  8. from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
  9. from os import urandom as _urandom
  10. from binascii import hexlify as _hexlify
  11. import hashlib as _hashlib
  12. __all__ = [
  13.     'Random',
  14.     'seed',
  15.     'random',
  16.     'uniform',
  17.     'randint',
  18.     'choice',
  19.     'sample',
  20.     'randrange',
  21.     'shuffle',
  22.     'normalvariate',
  23.     'lognormvariate',
  24.     'expovariate',
  25.     'vonmisesvariate',
  26.     'gammavariate',
  27.     'triangular',
  28.     'gauss',
  29.     'betavariate',
  30.     'paretovariate',
  31.     'weibullvariate',
  32.     'getstate',
  33.     'setstate',
  34.     'jumpahead',
  35.     'WichmannHill',
  36.     'getrandbits',
  37.     'SystemRandom']
  38. NV_MAGICCONST = 4 * _exp(-0.5) / _sqrt(2)
  39. TWOPI = 2 * _pi
  40. LOG4 = _log(4)
  41. SG_MAGICCONST = 1 + _log(4.5)
  42. BPF = 53
  43. RECIP_BPF = 2 ** (-BPF)
  44. import _random
  45.  
  46. class Random(_random.Random):
  47.     VERSION = 3
  48.     
  49.     def __init__(self, x = None):
  50.         self.seed(x)
  51.         self.gauss_next = None
  52.  
  53.     
  54.     def seed(self, a = None):
  55.         if a is None:
  56.             
  57.             try:
  58.                 a = long(_hexlify(_urandom(16)), 16)
  59.             except NotImplementedError:
  60.                 import time
  61.                 a = long(time.time() * 256)
  62.             
  63.  
  64.         super(Random, self).seed(a)
  65.         self.gauss_next = None
  66.  
  67.     
  68.     def getstate(self):
  69.         return (self.VERSION, super(Random, self).getstate(), self.gauss_next)
  70.  
  71.     
  72.     def setstate(self, state):
  73.         version = state[0]
  74.         if version == 3:
  75.             (version, internalstate, self.gauss_next) = state
  76.             super(Random, self).setstate(internalstate)
  77.         elif version == 2:
  78.             (version, internalstate, self.gauss_next) = state
  79.             
  80.             try:
  81.                 internalstate = tuple((lambda .0: pass)(internalstate))
  82.             except ValueError:
  83.                 e = None
  84.                 raise TypeError, e
  85.  
  86.             super(Random, self).setstate(internalstate)
  87.         else:
  88.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  89.  
  90.     
  91.     def jumpahead(self, n):
  92.         s = repr(n) + repr(self.getstate())
  93.         n = int(_hashlib.new('sha512', s).hexdigest(), 16)
  94.         super(Random, self).jumpahead(n)
  95.  
  96.     
  97.     def __getstate__(self):
  98.         return self.getstate()
  99.  
  100.     
  101.     def __setstate__(self, state):
  102.         self.setstate(state)
  103.  
  104.     
  105.     def __reduce__(self):
  106.         return (self.__class__, (), self.getstate())
  107.  
  108.     
  109.     def randrange(self, start, stop = None, step = 1, int = int, default = None, maxwidth = 0x1L << BPF):
  110.         istart = int(start)
  111.         if istart != start:
  112.             raise ValueError, 'non-integer arg 1 for randrange()'
  113.         if stop is default:
  114.             if istart > 0:
  115.                 if istart >= maxwidth:
  116.                     return self._randbelow(istart)
  117.                 return None(self.random() * istart)
  118.             raise None, 'empty range for randrange()'
  119.         istop = int(stop)
  120.         if istop != stop:
  121.             raise ValueError, 'non-integer stop for randrange()'
  122.         width = istop - istart
  123.         if step == 1 and width > 0:
  124.             if width >= maxwidth:
  125.                 return int(istart + self._randbelow(width))
  126.             return None(istart + int(self.random() * width))
  127.         if None == 1:
  128.             raise ValueError, 'empty range for randrange() (%d,%d, %d)' % (istart, istop, width)
  129.         istep = int(step)
  130.         if istep != step:
  131.             raise ValueError, 'non-integer step for randrange()'
  132.         if istep > 0:
  133.             n = (width + istep - 1) // istep
  134.         elif istep < 0:
  135.             n = (width + istep + 1) // istep
  136.         else:
  137.             raise ValueError, 'zero step for randrange()'
  138.         if None <= 0:
  139.             raise ValueError, 'empty range for randrange()'
  140.         if n >= maxwidth:
  141.             return istart + istep * self._randbelow(n)
  142.         return None + istep * int(self.random() * n)
  143.  
  144.     
  145.     def randint(self, a, b):
  146.         return self.randrange(a, b + 1)
  147.  
  148.     
  149.     def _randbelow(self, n, _log = _log, int = int, _maxwidth = 0x1L << BPF, _Method = _MethodType, _BuiltinMethod = _BuiltinMethodType):
  150.         
  151.         try:
  152.             getrandbits = self.getrandbits
  153.         except AttributeError:
  154.             pass
  155.  
  156.         if type(self.random) is _BuiltinMethod or type(getrandbits) is _Method:
  157.             k = int(1.00001 + _log(n - 1, 2))
  158.             r = getrandbits(k)
  159.             while r >= n:
  160.                 r = getrandbits(k)
  161.             return r
  162.         if None >= _maxwidth:
  163.             _warn('Underlying random() generator does not supply \nenough bits to choose from a population range this large')
  164.         return int(self.random() * n)
  165.  
  166.     
  167.     def choice(self, seq):
  168.         return seq[int(self.random() * len(seq))]
  169.  
  170.     
  171.     def shuffle(self, x, random = None, int = int):
  172.         if random is None:
  173.             random = self.random
  174.         for i in reversed(xrange(1, len(x))):
  175.             j = int(random() * (i + 1))
  176.             x[i] = x[j]
  177.             x[j] = x[i]
  178.         
  179.  
  180.     
  181.     def sample(self, population, k):
  182.         n = len(population)
  183.         if k <= k:
  184.             pass
  185.         elif not k <= n:
  186.             raise ValueError, 'sample larger than population'
  187.         random = self.random
  188.         _int = int
  189.         result = [
  190.             None] * k
  191.         setsize = 21
  192.         if k > 5:
  193.             setsize += 4 ** _ceil(_log(k * 3, 4))
  194.         return result
  195.  
  196.     
  197.     def uniform(self, a, b):
  198.         return a + (b - a) * self.random()
  199.  
  200.     
  201.     def triangular(self, low = 0, high = 1, mode = None):
  202.         u = self.random()
  203.         c = 0.5 if mode is None else (mode - low) / (high - low)
  204.         if u > c:
  205.             u = 1 - u
  206.             c = 1 - c
  207.             low = high
  208.             high = low
  209.         return low + (high - low) * (u * c) ** 0.5
  210.  
  211.     
  212.     def normalvariate(self, mu, sigma):
  213.         random = self.random
  214.         while None:
  215.             u1 = random()
  216.             u2 = 1 - random()
  217.             z = NV_MAGICCONST * (u1 - 0.5) / u2
  218.             zz = z * z / 4
  219.             if zz <= -_log(u2):
  220.                 break
  221.                 continue
  222.                 continue
  223.                 return mu + z * sigma
  224.  
  225.     
  226.     def lognormvariate(self, mu, sigma):
  227.         return _exp(self.normalvariate(mu, sigma))
  228.  
  229.     
  230.     def expovariate(self, lambd):
  231.         random = self.random
  232.         u = random()
  233.         while u <= 1e-07:
  234.             u = random()
  235.         return -_log(u) / lambd
  236.  
  237.     
  238.     def vonmisesvariate(self, mu, kappa):
  239.         random = self.random
  240.         if kappa <= 1e-06:
  241.             return TWOPI * random()
  242.         a = None + _sqrt(1 + 4 * kappa * kappa)
  243.         b = (a - _sqrt(2 * a)) / (2 * kappa)
  244.         r = (1 + b * b) / (2 * b)
  245.         while None:
  246.             u1 = random()
  247.             z = _cos(_pi * u1)
  248.             f = (1 + r * z) / (r + z)
  249.             c = kappa * (r - f)
  250.             u2 = random()
  251.             if not u2 < c * (2 - c):
  252.                 if u2 <= c * _exp(1 - c):
  253.                     break
  254.                     continue
  255.                     continue
  256.                     u3 = random()
  257.                     if u3 > 0.5:
  258.                         theta = mu % TWOPI + _acos(f)
  259.                     else:
  260.                         theta = mu % TWOPI - _acos(f)
  261.         return theta
  262.  
  263.     
  264.     def gammavariate(self, alpha, beta):
  265.         if alpha <= 0 or beta <= 0:
  266.             raise ValueError, 'gammavariate: alpha and beta must be > 0.0'
  267.         random = self.random
  268.         if alpha > 1:
  269.             ainv = _sqrt(2 * alpha - 1)
  270.             bbb = alpha - LOG4
  271.             ccc = alpha + ainv
  272.             while None:
  273.                 u1 = random()
  274.                 if u1 < u1:
  275.                     pass
  276.                 elif not u1 < 1:
  277.                     continue
  278.                 u2 = 1 - random()
  279.                 v = _log(u1 / (1 - u1)) / ainv
  280.                 x = alpha * _exp(v)
  281.                 z = u1 * u1 * u2
  282.                 r = bbb + ccc * v - x
  283.                 if not r + SG_MAGICCONST - 4.5 * z >= 0:
  284.                     if r >= _log(z):
  285.                         return x * beta
  286.                 elif alpha == 1:
  287.                     u = random()
  288.                     while u <= 1e-07:
  289.                         u = random()
  290.                     return -_log(u) * beta
  291.                 while None:
  292.                     u = random()
  293.                     b = (_e + alpha) / _e
  294.                     p = b * u
  295.                     u1 = random()
  296.                     if p > 1 or u1 <= x ** (alpha - 1):
  297.                         break
  298.                     
  299.                     if u1 <= _exp(-x):
  300.                         break
  301.                         continue
  302.                         continue
  303.                         return x * beta
  304.                     return 1e-07 if p <= 1 else u1 < 1
  305.  
  306.     
  307.     def gauss(self, mu, sigma):
  308.         random = self.random
  309.         z = self.gauss_next
  310.         self.gauss_next = None
  311.         if z is None:
  312.             x2pi = random() * TWOPI
  313.             g2rad = _sqrt(-2 * _log(1 - random()))
  314.             z = _cos(x2pi) * g2rad
  315.             self.gauss_next = _sin(x2pi) * g2rad
  316.         return mu + z * sigma
  317.  
  318.     
  319.     def betavariate(self, alpha, beta):
  320.         y = self.gammavariate(alpha, 1)
  321.         if y == 0:
  322.             return 0
  323.         return None / (y + self.gammavariate(beta, 1))
  324.  
  325.     
  326.     def paretovariate(self, alpha):
  327.         u = 1 - self.random()
  328.         return 1 / pow(u, 1 / alpha)
  329.  
  330.     
  331.     def weibullvariate(self, alpha, beta):
  332.         u = 1 - self.random()
  333.         return alpha * pow(-_log(u), 1 / beta)
  334.  
  335.  
  336.  
  337. class WichmannHill(Random):
  338.     VERSION = 1
  339.     
  340.     def seed(self, a = None):
  341.         if a is None:
  342.             
  343.             try:
  344.                 a = long(_hexlify(_urandom(16)), 16)
  345.             except NotImplementedError:
  346.                 import time
  347.                 a = long(time.time() * 256)
  348.             
  349.  
  350.         if not isinstance(a, (int, long)):
  351.             a = hash(a)
  352.         (a, x) = divmod(a, 30268)
  353.         (a, y) = divmod(a, 30306)
  354.         (a, z) = divmod(a, 30322)
  355.         self._seed = (int(x) + 1, int(y) + 1, int(z) + 1)
  356.         self.gauss_next = None
  357.  
  358.     
  359.     def random(self):
  360.         (x, y, z) = self._seed
  361.         x = 171 * x % 30269
  362.         y = 172 * y % 30307
  363.         z = 170 * z % 30323
  364.         self._seed = (x, y, z)
  365.         return (x / 30269 + y / 30307 + z / 30323) % 1
  366.  
  367.     
  368.     def getstate(self):
  369.         return (self.VERSION, self._seed, self.gauss_next)
  370.  
  371.     
  372.     def setstate(self, state):
  373.         version = state[0]
  374.         if version == 1:
  375.             (version, self._seed, self.gauss_next) = state
  376.         else:
  377.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  378.  
  379.     
  380.     def jumpahead(self, n):
  381.         if not n >= 0:
  382.             raise ValueError('n must be >= 0')
  383.         (x, y, z) = self._seed
  384.         x = int(x * pow(171, n, 30269)) % 30269
  385.         y = int(y * pow(172, n, 30307)) % 30307
  386.         z = int(z * pow(170, n, 30323)) % 30323
  387.         self._seed = (x, y, z)
  388.  
  389.     
  390.     def __whseed(self, x = 0, y = 0, z = 0):
  391.         if type(y) == type(y) and type(z) == type(z):
  392.             pass
  393.         elif not type(z) == int:
  394.             raise TypeError('seeds must be integers')
  395.         if x <= x:
  396.             pass
  397.         elif x < 256:
  398.             if y <= y:
  399.                 pass
  400.             elif y < 256:
  401.                 if z <= z:
  402.                     pass
  403.                 elif not z < 256:
  404.                     raise ValueError('seeds must be in range(0, 256)')
  405.                 if x == x and y == y:
  406.                     pass
  407.                 elif y == z:
  408.                     import time
  409.                     t = long(time.time() * 256)
  410.                     t = int(t & 16777215 ^ t >> 24)
  411.                     (t, x) = divmod(t, 256)
  412.                     (t, y) = divmod(t, 256)
  413.                     (t, z) = divmod(t, 256)
  414.                 if not x:
  415.                     pass
  416.         if not y:
  417.             pass
  418.         if not z:
  419.             pass
  420.         self._seed = (1, 1, 1)
  421.         self.gauss_next = None
  422.  
  423.     
  424.     def whseed(self, a = None):
  425.         if a is None:
  426.             self._WichmannHill__whseed()
  427.             return None
  428.         a = None(a)
  429.         (a, x) = divmod(a, 256)
  430.         (a, y) = divmod(a, 256)
  431.         (a, z) = divmod(a, 256)
  432.         if not (x + a) % 256:
  433.             pass
  434.         x = 1
  435.         if not (y + a) % 256:
  436.             pass
  437.         y = 1
  438.         if not (z + a) % 256:
  439.             pass
  440.         z = 1
  441.         self._WichmannHill__whseed(x, y, z)
  442.  
  443.  
  444.  
  445. class SystemRandom(Random):
  446.     
  447.     def random(self):
  448.         return (long(_hexlify(_urandom(7)), 16) >> 3) * RECIP_BPF
  449.  
  450.     
  451.     def getrandbits(self, k):
  452.         if k <= 0:
  453.             raise ValueError('number of bits must be greater than zero')
  454.         if k != int(k):
  455.             raise TypeError('number of bits should be an integer')
  456.         bytes = (k + 7) // 8
  457.         x = long(_hexlify(_urandom(bytes)), 16)
  458.         return x >> bytes * 8 - k
  459.  
  460.     
  461.     def _stub(self, *args, **kwds):
  462.         pass
  463.  
  464.     seed = jumpahead = _stub
  465.     
  466.     def _notimplemented(self, *args, **kwds):
  467.         raise NotImplementedError('System entropy source does not have state.')
  468.  
  469.     getstate = setstate = _notimplemented
  470.  
  471.  
  472. def _test_generator(n, func, args):
  473.     import time
  474.     print n, 'times', func.__name__
  475.     total = 0
  476.     sqsum = 0
  477.     smallest = 1e+10
  478.     largest = -1e+10
  479.     t0 = time.time()
  480.     for i in range(n):
  481.         x = func(*args)
  482.         total += x
  483.         sqsum = sqsum + x * x
  484.         smallest = min(x, smallest)
  485.         largest = max(x, largest)
  486.     
  487.     t1 = time.time()
  488.     print round(t1 - t0, 3), 'sec,',
  489.     avg = total / n
  490.     stddev = _sqrt(sqsum / n - avg * avg)
  491.     print 'avg %g, stddev %g, min %g, max %g' % (avg, stddev, smallest, largest)
  492.  
  493.  
  494. def _test(N = 2000):
  495.     _test_generator(N, random, ())
  496.     _test_generator(N, normalvariate, (0, 1))
  497.     _test_generator(N, lognormvariate, (0, 1))
  498.     _test_generator(N, vonmisesvariate, (0, 1))
  499.     _test_generator(N, gammavariate, (0.01, 1))
  500.     _test_generator(N, gammavariate, (0.1, 1))
  501.     _test_generator(N, gammavariate, (0.1, 2))
  502.     _test_generator(N, gammavariate, (0.5, 1))
  503.     _test_generator(N, gammavariate, (0.9, 1))
  504.     _test_generator(N, gammavariate, (1, 1))
  505.     _test_generator(N, gammavariate, (2, 1))
  506.     _test_generator(N, gammavariate, (20, 1))
  507.     _test_generator(N, gammavariate, (200, 1))
  508.     _test_generator(N, gauss, (0, 1))
  509.     _test_generator(N, betavariate, (3, 3))
  510.     _test_generator(N, triangular, (0, 1, 0.333333))
  511.  
  512. _inst = Random()
  513. seed = _inst.seed
  514. random = _inst.random
  515. uniform = _inst.uniform
  516. triangular = _inst.triangular
  517. randint = _inst.randint
  518. choice = _inst.choice
  519. randrange = _inst.randrange
  520. sample = _inst.sample
  521. shuffle = _inst.shuffle
  522. normalvariate = _inst.normalvariate
  523. lognormvariate = _inst.lognormvariate
  524. expovariate = _inst.expovariate
  525. vonmisesvariate = _inst.vonmisesvariate
  526. gammavariate = _inst.gammavariate
  527. gauss = _inst.gauss
  528. betavariate = _inst.betavariate
  529. paretovariate = _inst.paretovariate
  530. weibullvariate = _inst.weibullvariate
  531. getstate = _inst.getstate
  532. setstate = _inst.setstate
  533. jumpahead = _inst.jumpahead
  534. getrandbits = _inst.getrandbits
  535. if __name__ == '__main__':
  536.     _test()
  537.