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