home *** CD-ROM | disk | FTP | other *** search
/ com!online 2005 April / com_0405_1.iso / opensource / BTpp-0.5.4-bin.exe / $INSTDIR / BT++.exe / random.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2003-04-19  |  15.1 KB  |  449 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.2)
  3.  
  4. from math import log as _log, exp as _exp, pi as _pi, e as _e
  5. from math import sqrt as _sqrt, acos as _acos, cos as _cos, sin as _sin
  6. from math import floor as _floor
  7. __all__ = [
  8.     'Random',
  9.     'seed',
  10.     'random',
  11.     'uniform',
  12.     'randint',
  13.     'choice',
  14.     'randrange',
  15.     'shuffle',
  16.     'normalvariate',
  17.     'lognormvariate',
  18.     'cunifvariate',
  19.     'expovariate',
  20.     'vonmisesvariate',
  21.     'gammavariate',
  22.     'stdgamma',
  23.     'gauss',
  24.     'betavariate',
  25.     'paretovariate',
  26.     'weibullvariate',
  27.     'getstate',
  28.     'setstate',
  29.     'jumpahead',
  30.     'whseed']
  31.  
  32. def _verify(name, computed, expected):
  33.     if abs(computed - expected) > 9.9999999999999995e-008:
  34.         raise ValueError('computed value for %s deviates too much (computed %g, expected %g)' % (name, computed, expected))
  35.     
  36.  
  37. NV_MAGICCONST = 4 * _exp(-0.5) / _sqrt(2.0)
  38. _verify('NV_MAGICCONST', NV_MAGICCONST, 1.71552776992141)
  39. TWOPI = 2.0 * _pi
  40. _verify('TWOPI', TWOPI, 6.2831853071800001)
  41. LOG4 = _log(4.0)
  42. _verify('LOG4', LOG4, 1.3862943611198899)
  43. SG_MAGICCONST = 1.0 + _log(4.5)
  44. _verify('SG_MAGICCONST', SG_MAGICCONST, 2.5040773967762702)
  45. del _verify
  46.  
  47. class Random:
  48.     VERSION = 1
  49.     
  50.     def __init__(self, x = None):
  51.         self.seed(x)
  52.  
  53.     
  54.     def seed(self, a = None):
  55.         if a is None:
  56.             import time
  57.             a = long(time.time() * 256)
  58.         
  59.         if type(a) not in (type(3), type(0x3L)):
  60.             a = hash(a)
  61.         
  62.         (a, x) = divmod(a, 30268)
  63.         (a, y) = divmod(a, 30306)
  64.         (a, z) = divmod(a, 30322)
  65.         self._seed = (int(x) + 1, int(y) + 1, int(z) + 1)
  66.         self.gauss_next = None
  67.  
  68.     
  69.     def random(self):
  70.         (x, y, z) = self._seed
  71.         x = 171 * x % 30269
  72.         y = 172 * y % 30307
  73.         z = 170 * z % 30323
  74.         self._seed = (x, y, z)
  75.         return (x / 30269.0 + y / 30307.0 + z / 30323.0) % 1.0
  76.  
  77.     
  78.     def getstate(self):
  79.         return (self.VERSION, self._seed, self.gauss_next)
  80.  
  81.     
  82.     def setstate(self, state):
  83.         version = state[0]
  84.         if version == 1:
  85.             (version, self._seed, self.gauss_next) = state
  86.         else:
  87.             raise ValueError('state with version %s passed to Random.setstate() of version %s' % (version, self.VERSION))
  88.  
  89.     
  90.     def jumpahead(self, n):
  91.         if not (n >= 0):
  92.             raise ValueError('n must be >= 0')
  93.         
  94.         (x, y, z) = self._seed
  95.         x = int(x * pow(171, n, 30269)) % 30269
  96.         y = int(y * pow(172, n, 30307)) % 30307
  97.         z = int(z * pow(170, n, 30323)) % 30323
  98.         self._seed = (x, y, z)
  99.  
  100.     
  101.     def __whseed(self, x = 0, y = 0, z = 0):
  102.         if not None if type(y) == type(y) and type(z) == type(z) else type(z) == type(0):
  103.             raise TypeError('seeds must be integers')
  104.         
  105.         if x <= x:
  106.             pass
  107.         elif x < 256:
  108.             if y <= y:
  109.                 pass
  110.             elif y < 256:
  111.                 pass
  112.         if not None if z <= z else z < 256:
  113.             raise ValueError('seeds must be in range(0, 256)')
  114.         
  115.         if x == x and y == y:
  116.             pass
  117.         elif y == z:
  118.             import time
  119.             t = long(time.time() * 256)
  120.             t = int(t & 16777215 ^ t >> 24)
  121.             (t, x) = divmod(t, 256)
  122.             (t, y) = divmod(t, 256)
  123.             (t, z) = divmod(t, 256)
  124.         
  125.         if not x:
  126.             pass
  127.         if not y:
  128.             pass
  129.         if not z:
  130.             pass
  131.         self._seed = (1, 1, 1)
  132.         self.gauss_next = None
  133.  
  134.     
  135.     def whseed(self, a = None):
  136.         if a is None:
  137.             self._Random__whseed()
  138.             return None
  139.         
  140.         a = hash(a)
  141.         (a, x) = divmod(a, 256)
  142.         (a, y) = divmod(a, 256)
  143.         (a, z) = divmod(a, 256)
  144.         if not (x + a) % 256:
  145.             pass
  146.         x = 1
  147.         if not (y + a) % 256:
  148.             pass
  149.         y = 1
  150.         if not (z + a) % 256:
  151.             pass
  152.         z = 1
  153.         self._Random__whseed(x, y, z)
  154.  
  155.     
  156.     def __getstate__(self):
  157.         return self.getstate()
  158.  
  159.     
  160.     def __setstate__(self, state):
  161.         self.setstate(state)
  162.  
  163.     
  164.     def randrange(self, start, stop = None, step = 1, int = int, default = None):
  165.         istart = int(start)
  166.         if istart != start:
  167.             raise ValueError, 'non-integer arg 1 for randrange()'
  168.         
  169.         if stop is default:
  170.             if istart > 0:
  171.                 return int(self.random() * istart)
  172.             
  173.             raise ValueError, 'empty range for randrange()'
  174.         
  175.         istop = int(stop)
  176.         if istop != stop:
  177.             raise ValueError, 'non-integer stop for randrange()'
  178.         
  179.         if step == 1 and istart < istop:
  180.             
  181.             try:
  182.                 return istart + int(self.random() * (istop - istart))
  183.             except OverflowError:
  184.                 return int(istart + _floor(self.random() * (istop - istart)))
  185.  
  186.         
  187.         if step == 1:
  188.             raise ValueError, 'empty range for randrange()'
  189.         
  190.         istep = int(step)
  191.         if istep != step:
  192.             raise ValueError, 'non-integer step for randrange()'
  193.         
  194.         if istep > 0:
  195.             n = ((istop - istart) + istep - 1) / istep
  196.         elif istep < 0:
  197.             n = ((istop - istart) + istep + 1) / istep
  198.         else:
  199.             raise ValueError, 'zero step for randrange()'
  200.         if n <= 0:
  201.             raise ValueError, 'empty range for randrange()'
  202.         
  203.         return istart + istep * int(self.random() * n)
  204.  
  205.     
  206.     def randint(self, a, b):
  207.         return self.randrange(a, b + 1)
  208.  
  209.     
  210.     def choice(self, seq):
  211.         return seq[int(self.random() * len(seq))]
  212.  
  213.     
  214.     def shuffle(self, x, random = None, int = int):
  215.         if random is None:
  216.             random = self.random
  217.         
  218.         for i in xrange(len(x) - 1, 0, -1):
  219.             j = int(random() * (i + 1))
  220.             (x[i], x[j]) = (x[j], x[i])
  221.         
  222.  
  223.     
  224.     def uniform(self, a, b):
  225.         return a + (b - a) * self.random()
  226.  
  227.     
  228.     def normalvariate(self, mu, sigma):
  229.         random = self.random
  230.         while 1:
  231.             u1 = random()
  232.             u2 = random()
  233.             z = NV_MAGICCONST * (u1 - 0.5) / u2
  234.             zz = z * z / 4.0
  235.             if zz <= -_log(u2):
  236.                 break
  237.             
  238.         return mu + z * sigma
  239.  
  240.     
  241.     def lognormvariate(self, mu, sigma):
  242.         return _exp(self.normalvariate(mu, sigma))
  243.  
  244.     
  245.     def cunifvariate(self, mean, arc):
  246.         return (mean + arc * (self.random() - 0.5)) % _pi
  247.  
  248.     
  249.     def expovariate(self, lambd):
  250.         random = self.random
  251.         u = random()
  252.         while u <= 9.9999999999999995e-008:
  253.             u = random()
  254.         return -_log(u) / lambd
  255.  
  256.     
  257.     def vonmisesvariate(self, mu, kappa):
  258.         random = self.random
  259.         if kappa <= 9.9999999999999995e-007:
  260.             return TWOPI * random()
  261.         
  262.         a = 1.0 + _sqrt(1.0 + 4.0 * kappa * kappa)
  263.         b = (a - _sqrt(2.0 * a)) / (2.0 * kappa)
  264.         r = (1.0 + b * b) / (2.0 * b)
  265.         while 1:
  266.             u1 = random()
  267.             z = _cos(_pi * u1)
  268.             f = (1.0 + r * z) / (r + z)
  269.             c = kappa * (r - f)
  270.             u2 = random()
  271.             if u2 >= c * (2.0 - c):
  272.                 pass
  273.             if not (u2 > c * _exp(1.0 - c)):
  274.                 break
  275.             
  276.         u3 = random()
  277.         if u3 > 0.5:
  278.             theta = mu % TWOPI + _acos(f)
  279.         else:
  280.             theta = mu % TWOPI - _acos(f)
  281.         return theta
  282.  
  283.     
  284.     def gammavariate(self, alpha, beta):
  285.         if alpha <= 0.0 or beta <= 0.0:
  286.             raise ValueError, 'gammavariate: alpha and beta must be > 0.0'
  287.         
  288.         random = self.random
  289.         if alpha > 1.0:
  290.             ainv = _sqrt(2.0 * alpha - 1.0)
  291.             bbb = alpha - LOG4
  292.             ccc = alpha + ainv
  293.             while 1:
  294.                 u1 = random()
  295.                 u2 = random()
  296.                 v = _log(u1 / (1.0 - u1)) / ainv
  297.                 x = alpha * _exp(v)
  298.                 z = u1 * u1 * u2
  299.                 r = bbb + ccc * v - x
  300.                 if r + SG_MAGICCONST - 4.5 * z >= 0.0 or r >= _log(z):
  301.                     return x * beta
  302.                 
  303.         elif alpha == 1.0:
  304.             u = random()
  305.             while u <= 9.9999999999999995e-008:
  306.                 u = random()
  307.             return -_log(u) * beta
  308.         else:
  309.             while 1:
  310.                 u = random()
  311.                 b = (_e + alpha) / _e
  312.                 p = b * u
  313.                 if p <= 1.0:
  314.                     x = pow(p, 1.0 / alpha)
  315.                 else:
  316.                     x = -_log((b - p) / alpha)
  317.                 u1 = random()
  318.                 if p <= 1.0 and u1 > _exp(-x) and p > 1:
  319.                     pass
  320.                 if not (u1 > pow(x, alpha - 1.0)):
  321.                     break
  322.                 
  323.             return x * beta
  324.  
  325.     
  326.     def stdgamma(self, alpha, ainv, bbb, ccc):
  327.         import warnings
  328.         warnings.warn('The stdgamma function is deprecated; use gammavariate() instead', DeprecationWarning)
  329.         return self.gammavariate(alpha, 1.0)
  330.  
  331.     
  332.     def gauss(self, mu, sigma):
  333.         random = self.random
  334.         z = self.gauss_next
  335.         self.gauss_next = None
  336.         if z is None:
  337.             x2pi = random() * TWOPI
  338.             g2rad = _sqrt(-2.0 * _log(1.0 - random()))
  339.             z = _cos(x2pi) * g2rad
  340.             self.gauss_next = _sin(x2pi) * g2rad
  341.         
  342.         return mu + z * sigma
  343.  
  344.     
  345.     def betavariate(self, alpha, beta):
  346.         y = self.gammavariate(alpha, 1.0)
  347.         if y == 0:
  348.             return 0.0
  349.         else:
  350.             return y / (y + self.gammavariate(beta, 1.0))
  351.  
  352.     
  353.     def paretovariate(self, alpha):
  354.         u = self.random()
  355.         return 1.0 / pow(u, 1.0 / alpha)
  356.  
  357.     
  358.     def weibullvariate(self, alpha, beta):
  359.         u = self.random()
  360.         return alpha * pow(-_log(u), 1.0 / beta)
  361.  
  362.  
  363.  
  364. def _test_generator(n, funccall):
  365.     import time
  366.     print n, 'times', funccall
  367.     code = compile(funccall, funccall, 'eval')
  368.     sum = 0.0
  369.     sqsum = 0.0
  370.     smallest = 10000000000.0
  371.     largest = -10000000000.0
  372.     t0 = time.time()
  373.     for i in range(n):
  374.         x = eval(code)
  375.         sum = sum + x
  376.         sqsum = sqsum + x * x
  377.         smallest = min(x, smallest)
  378.         largest = max(x, largest)
  379.     
  380.     t1 = time.time()
  381.     print round(t1 - t0, 3), 'sec,',
  382.     avg = sum / n
  383.     stddev = _sqrt(sqsum / n - avg * avg)
  384.     print 'avg %g, stddev %g, min %g, max %g' % (avg, stddev, smallest, largest)
  385.  
  386.  
  387. def _test(N = 20000):
  388.     print 'TWOPI         =', TWOPI
  389.     print 'LOG4          =', LOG4
  390.     print 'NV_MAGICCONST =', NV_MAGICCONST
  391.     print 'SG_MAGICCONST =', SG_MAGICCONST
  392.     _test_generator(N, 'random()')
  393.     _test_generator(N, 'normalvariate(0.0, 1.0)')
  394.     _test_generator(N, 'lognormvariate(0.0, 1.0)')
  395.     _test_generator(N, 'cunifvariate(0.0, 1.0)')
  396.     _test_generator(N, 'expovariate(1.0)')
  397.     _test_generator(N, 'vonmisesvariate(0.0, 1.0)')
  398.     _test_generator(N, 'gammavariate(0.01, 1.0)')
  399.     _test_generator(N, 'gammavariate(0.1, 1.0)')
  400.     _test_generator(N, 'gammavariate(0.1, 2.0)')
  401.     _test_generator(N, 'gammavariate(0.5, 1.0)')
  402.     _test_generator(N, 'gammavariate(0.9, 1.0)')
  403.     _test_generator(N, 'gammavariate(1.0, 1.0)')
  404.     _test_generator(N, 'gammavariate(2.0, 1.0)')
  405.     _test_generator(N, 'gammavariate(20.0, 1.0)')
  406.     _test_generator(N, 'gammavariate(200.0, 1.0)')
  407.     _test_generator(N, 'gauss(0.0, 1.0)')
  408.     _test_generator(N, 'betavariate(3.0, 3.0)')
  409.     _test_generator(N, 'paretovariate(1.0)')
  410.     _test_generator(N, 'weibullvariate(1.0, 1.0)')
  411.     s = getstate()
  412.     jumpahead(N)
  413.     r1 = random()
  414.     setstate(s)
  415.     for i in range(N):
  416.         random()
  417.     
  418.     r2 = random()
  419.     if r1 != r2:
  420.         raise ValueError('jumpahead test failed ' + `(N, r1, r2)`)
  421.     
  422.  
  423. _inst = Random()
  424. seed = _inst.seed
  425. random = _inst.random
  426. uniform = _inst.uniform
  427. randint = _inst.randint
  428. choice = _inst.choice
  429. randrange = _inst.randrange
  430. shuffle = _inst.shuffle
  431. normalvariate = _inst.normalvariate
  432. lognormvariate = _inst.lognormvariate
  433. cunifvariate = _inst.cunifvariate
  434. expovariate = _inst.expovariate
  435. vonmisesvariate = _inst.vonmisesvariate
  436. gammavariate = _inst.gammavariate
  437. stdgamma = _inst.stdgamma
  438. gauss = _inst.gauss
  439. betavariate = _inst.betavariate
  440. paretovariate = _inst.paretovariate
  441. weibullvariate = _inst.weibullvariate
  442. getstate = _inst.getstate
  443. setstate = _inst.setstate
  444. jumpahead = _inst.jumpahead
  445. whseed = _inst.whseed
  446. if __name__ == '__main__':
  447.     _test()
  448.  
  449.