-í
ç¶<c       s.  d  Z  d k l Z l Z l Z l Z	 d k l
 Z l Z l Z l Z d d d d d d d	 d
 d d d d d d d d d d d d d d d g Z d „  Z d e d ƒ e d ƒ Z e d e d ƒ d e Z e d  e d! ƒ e d" ƒ Z e d# e d$ ƒ d% e d& ƒ Z e d' e d( ƒ [ d f  d) „  ƒ  YZ d* „  Z d+ d, „ Z e ƒ  Z e i Z e i Z e i Z e i Z e i  Z  e i! Z! e i" Z" e i# Z# e i$ Z$ e i% Z% e i& Z& e i' Z' e i( Z( e i) Z) e i* Z* e i+ Z+ e i, Z, e i- Z- e i. Z. e i/ Z/ e i0 Z0 e i1 Z1 e2 d- j o e ƒ  n d. S(/   s	  Random variable generators.

    integers
    --------
           uniform within range

    sequences
    ---------
           pick random element
           generate random permutation

    distributions on the real line:
    ------------------------------
           uniform
           normal (Gaussian)
           lognormal
           negative exponential
           gamma
           beta

    distributions on the circle (angles 0 to 2pi)
    ---------------------------------------------
           circular uniform
           von Mises

Translated from anonymously contributed C/C++ source.

Multi-threading note:  the random number generator used here is not thread-
safe; it is possible that two calls return the same random value.  However,
you can instantiate a different instance of Random() in each thread to get
generators that don't share state, then use .setstate() and .jumpahead() to
move the generators to disjoint segments of the full period.  For example,

def create_generators(num, delta, firstseed=None):
    """Return list of num distinct generators.
    Each generator has its own unique segment of delta elements from
    Random.random()'s full period.
    Seed the first generator with optional arg firstseed (default is
    None, to seed from current time).
    """

    from random import Random
    g = Random(firstseed)
    result = [g]
    for i in range(num - 1):
        laststate = g.getstate()
        g = Random()
        g.setstate(laststate)
        g.jumpahead(delta)
        result.append(g)
    return result

gens = create_generators(10, 1000000)

That creates 10 distinct generators, which can be passed out to 10 distinct
threads.  The generators don't share state so can be called safely in
parallel.  So long as no thread calls its g.random() more than a million
times (the second argument to create_generators), the sequences seen by
each thread will not overlap.

The period of the underlying Wichmann-Hill generator is 6,953,607,871,644,
and that limits how far this technique can be pushed.

Just for fun, note that since we know the period, .jumpahead() can also be
used to "move backward in time":

>>> g = Random(42)  # arbitrary
>>> g.random()
0.25420336316883324
>>> g.jumpahead(6953607871644L - 1) # move *back* one
>>> g.random()
0.25420336316883324
(   s   logs   exps   pis   e(   s   sqrts   acoss   coss   sins   Randoms   seeds   randoms   uniforms   randints   choices	   randranges   shuffles   normalvariates   lognormvariates   cunifvariates   expovariates   vonmisesvariates   gammavariates   stdgammas   gausss   betavariates   paretovariates   weibullvariates   getstates   setstates	   jumpaheads   whseedc    s8   t  | | ƒ d j o t d |  | | f ƒ ‚ n d  S(   Nf9.9999999999999995e-08sB   computed value for %s deviates too much (computed %g, expected %g)(   s   abss   computeds   expecteds
   ValueErrors   name(   s   names   computeds   expected(    (    s   /usr/lib/python2.2/random.pys   _verifyU s    i   f-0.5f2.0s   NV_MAGICCONSTf1.71552776992141s   TWOPIf6.2831853071800001f4.0s   LOG4f1.3862943611198899f1.0f4.5s   SG_MAGICCONSTf2.5040773967762702c      s  t  Z d Z e d „ Z e d „ Z d „  Z d „  Z d „  Z d „  Z	 d d d d	 „ Z
 e d
 „ Z d „  Z d „  Z e d e e d „ Z d „  Z d „  Z e e d „ Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z d „  Z RS(   Ni   c    s   |  i | ƒ t |  _ d S(   se   Initialize an instance.

        Optional argument x controls seeding, as for Random.seed().
        N(   s   selfs   seeds   xs   Nones
   gauss_next(   s   selfs   x(    (    s   /usr/lib/python2.2/random.pys   __init__p s     c    sØ   | t j o# d k } t | i ƒ  d ƒ } n t | ƒ t d ƒ t d ƒ f j o t | ƒ } n t | d ƒ \ } } t | d ƒ \ } } t | d ƒ \ } } t
 | ƒ d t
 | ƒ d t
 | ƒ d f |  _ d S(	   s°  Initialize internal state from hashable object.

        None or no argument seeds from current time.

        If a is not None or an int or long, hash(a) is used instead.

        If a is an int or long, a is used directly.  Distinct values between
        0 and 27814431486575L inclusive are guaranteed to yield distinct
        internal states (this guarantee is specific to the default
        Wichmann-Hill generator).
        Ni   i   l    i<v  ibv  irv  i   (   s   as   Nones   times   longs   types   hashs   divmods   xs   ys   zs   ints   selfs   _seed(   s   selfs   as   times   ys   xs   z(    (    s   /usr/lib/python2.2/random.pys   seed s     	%c    sn   |  i \ } } } d | d } d | d } d | d } | | | f |  _ | d | d | d	 d
 Sd S(   s3   Get the next random number in the range [0.0, 1.0).i«   i=v  i¬   icv  iª   isv  f30269.0f30307.0f30323.0f1.0N(   s   selfs   _seeds   xs   ys   z(   s   selfs   ys   xs   z(    (    s   /usr/lib/python2.2/random.pys   random™ s     c    s   |  i |  i |  i f Sd S(   s9   Return internal state; can be passed to setstate() later.N(   s   selfs   VERSIONs   _seeds
   gauss_next(   s   self(    (    s   /usr/lib/python2.2/random.pys   getstate¸ s     c    sM   | d } | d j o | \ } |  _ |  _ n t d | |  i f ƒ ‚ d S(   s:   Restore internal state from object returned by getstate().i    i   s?   state with version %s passed to Random.setstate() of version %sN(   s   states   versions   selfs   _seeds
   gauss_nexts
   ValueErrors   VERSION(   s   selfs   states   version(    (    s   /usr/lib/python2.2/random.pys   setstate¼ s
     
c    s¦   | d j o t d ƒ ‚ n |  i \ } } } t | t d | d ƒ ƒ d } t | t d | d ƒ ƒ d } t | t d | d ƒ ƒ d } | | | f |  _ d	 S(
   sÃ  Act as if n calls to random() were made, but quickly.

        n is an int, greater than or equal to 0.

        Example use:  If you have 2 threads and know that each will
        consume no more than a million random numbers, create two Random
        objects r1 and r2, then do
            r2.setstate(r1.getstate())
            r2.jumpahead(1000000)
        Then r1 and r2 will use guaranteed-disjoint segments of the full
        period.
        i    s   n must be >= 0i«   i=v  i¬   icv  iª   isv  N(	   s   ns
   ValueErrors   selfs   _seeds   xs   ys   zs   ints   pow(   s   selfs   ns   ys   xs   z(    (    s   /usr/lib/python2.2/random.pys	   jumpaheadÆ s        i    c    s  t  | ƒ t  | ƒ j o" t  | ƒ j o t  d ƒ j n o t d ƒ ‚ n d | j o
 d j  n o9 d | j o
 d j  n o d | j o
 d j  n o t d ƒ ‚ n d | j o | j o
 | j n oz d k } t | i ƒ  d ƒ } t	 | d @| d ?Aƒ } t
 | d ƒ \ } } t
 | d ƒ \ } } t
 | d ƒ \ } } n | p d | p d | p d f |  _ d S(	   sj   Set the Wichmann-Hill seed from (x, y, z).

        These must be integers in the range [0, 256).
        i    s   seeds must be integersi   s   seeds must be in range(0, 256)Niÿÿÿ i   i   (   s   types   xs   ys   zs	   TypeErrors
   ValueErrors   times   longs   ts   ints   divmods   selfs   _seed(   s   selfs   xs   ys   zs   ts   time(    (    s   /usr/lib/python2.2/random.pys   __whseedÜ s     C[*	c    sÀ   | t j o |  i ƒ  d Sn t | ƒ } t | d ƒ \ } } t | d ƒ \ } } t | d ƒ \ } } | | d p d } | | d p d } | | d p d } |  i | | | ƒ d S(   sb  Seed from hashable object's hash code.

        None or no argument seeds from current time.  It is not guaranteed
        that objects with distinct hash codes lead to distinct internal
        states.

        This is obsolete, provided for compatibility with the seed routine
        used prior to Python 2.1.  Use the .seed() method instead.
        Ni   i   (	   s   as   Nones   selfs   _Random__whseeds   hashs   divmods   xs   ys   z(   s   selfs   as   ys   xs   z(    (    s   /usr/lib/python2.2/random.pys   whseedñ s    	 
c    s   |  i ƒ  Sd  S(   N(   s   selfs   getstate(   s   self(    (    s   /usr/lib/python2.2/random.pys   __getstate__s    c    s   |  i | ƒ d  S(   N(   s   selfs   setstates   state(   s   selfs   state(    (    s   /usr/lib/python2.2/random.pys   __setstate__s    c 
   s‰  | | ƒ } | | j o t d ‚ n | | j o2 | d j o | |  i ƒ  | ƒ Sn t d ‚ n | | ƒ } | | j o t d ‚ n | d j o: | | j  o  | | |  i ƒ  | | ƒ Sn t d ‚ n | | ƒ }	 |	 | j o t d ‚ n |	 d j o | | |	 d |	 } n1 |	 d j  o | | |	 d |	 } n
 t d ‚ | d j o t d ‚ n | |	 | |  i ƒ  | ƒ Sd S(	   sø   Choose a random item from range(start, stop[, step]).

        This fixes the problem with randint() which includes the
        endpoint; in Python this is usually not what you want.
        Do not supply the 'int' and 'default' arguments.
        s!   non-integer arg 1 for randrange()i    s   empty range for randrange()s    non-integer stop for randrange()i   s    non-integer step for randrange()s   zero step for randrange()N(   s   ints   starts   istarts
   ValueErrors   stops   defaults   selfs   randoms   istops   steps   isteps   n(
   s   selfs   starts   stops   steps   ints   defaults   istarts   ns   istops   istep(    (    s   /usr/lib/python2.2/random.pys	   randranges4      	c    s   |  i | | d ƒ Sd S(   sx   Return random integer in range [a, b], including both end points.

        (Deprecated; use randrange(a, b+1).)
        i   N(   s   selfs	   randranges   as   b(   s   selfs   as   b(    (    s   /usr/lib/python2.2/random.pys   randint<s     c    s"   | t |  i ƒ  t | ƒ ƒ Sd S(   s2   Choose a random element from a non-empty sequence.N(   s   seqs   ints   selfs   randoms   len(   s   selfs   seq(    (    s   /usr/lib/python2.2/random.pys   choiceFs     c    s~   | t j o |  i  } n x] t t | ƒ d d d ƒ D]? } | | ƒ  | d ƒ } | | | | f \ | | <| | <q7 Wd S(   sÓ  x, random=random.random -> shuffle list x in place; return None.

        Optional arg random is a 0-argument function returning a random
        float in [0.0, 1.0); by default, the standard random.random.

        Note that for even rather small len(x), the total number of
        permutations of x is larger than the period of most random number
        generators; this implies that "most" permutations of a long
        sequence can never be generated.
        i   i    iÿÿÿÿN(	   s   randoms   Nones   selfs   xranges   lens   xs   is   ints   j(   s   selfs   xs   randoms   ints   is   j(    (    s   /usr/lib/python2.2/random.pys   shuffleJs    
  c    s   | | | |  i ƒ  Sd S(   s(   Get a random number in the range [a, b).N(   s   as   bs   selfs   random(   s   selfs   as   b(    (    s   /usr/lib/python2.2/random.pys   uniformas     c    ss   |  i } xW d oO | ƒ  } | ƒ  } t | d | } | | d } | t | ƒ j o Pn q W| | | Sd  S(   Ni   f0.5f4.0(
   s   selfs   randoms   u1s   u2s   NV_MAGICCONSTs   zs   zzs   _logs   mus   sigma(   s   selfs   mus   sigmas   zs   zzs   randoms   u1s   u2(    (    s   /usr/lib/python2.2/random.pys   normalvariategs    	 		
c    s   t  |  i | | ƒ ƒ Sd  S(   N(   s   _exps   selfs   normalvariates   mus   sigma(   s   selfs   mus   sigma(    (    s   /usr/lib/python2.2/random.pys   lognormvariate{s    c    s   | | |  i ƒ  d t Sd  S(   Nf0.5(   s   means   arcs   selfs   randoms   _pi(   s   selfs   means   arc(    (    s   /usr/lib/python2.2/random.pys   cunifvariate€s    c    sC   |  i } | ƒ  } x | d j o | ƒ  } q Wt | ƒ | Sd  S(   Nf9.9999999999999995e-08(   s   selfs   randoms   us   _logs   lambd(   s   selfs   lambds   randoms   u(    (    s   /usr/lib/python2.2/random.pys   expovariateˆs    		 c    sH  |  i } | d j o t | ƒ  Sn d t d d | | ƒ } | t d | ƒ d | } d | | d | } xˆ d o€ | ƒ  } t	 t
 | ƒ } d | | | | } | | | } | ƒ  }
 |
 | d | j o |
 | t d | ƒ j o Pn qv W| ƒ  }	 |	 d j o | t t | ƒ } n | t t | ƒ } | Sd  S(   Nf9.9999999999999995e-07f1.0f4.0f2.0i   f0.5(   s   selfs   randoms   kappas   TWOPIs   _sqrts   as   bs   rs   u1s   _coss   _pis   zs   fs   cs   u2s   _exps   u3s   mus   _acoss   theta(   s   selfs   mus   kappas   as   bs   fs   cs   randoms   u1s   u3s   u2s   rs   thetas   z(    (    s   /usr/lib/python2.2/random.pys   vonmisesvariate”s(    	 		1
	c    s:   t  d | d ƒ } | |  i | | | t | | ƒ Sd  S(   Nf2.0f1.0(   s   _sqrts   alphas   ainvs   betas   selfs   stdgammas   LOG4(   s   selfs   alphas   betas   ainv(    (    s   /usr/lib/python2.2/random.pys   gammavariate¾s    c    sÜ  |  i } | d j o t d ‚ n | d j o¡ xš d o’ | ƒ  } | ƒ  } t | d | ƒ | } | t	 | ƒ } | | | } | | | | }
 |
 t d | d j p |
 t | ƒ j o | Sn q3 Wn| d j o6 | ƒ  } x | d j o | ƒ  } qê Wt | ƒ SnÅ x½ d oµ | ƒ  } t | t } | | }	 |	 d j o t |	 d | ƒ } n t | |	 | ƒ } | ƒ  } |	 d j o | t	 | ƒ j p$ |	 d j o | t | | d ƒ j o Pn qW| Sd  S(   Nf0.0s   stdgamma: alpha must be > 0.0f1.0i   f4.5f9.9999999999999995e-08(   s   selfs   randoms   alphas
   ValueErrors   u1s   u2s   _logs   ainvs   vs   _exps   xs   zs   bbbs   cccs   rs   SG_MAGICCONSTs   us   _es   bs   ps   pow(   s   selfs   alphas   ainvs   bbbs   cccs   xs   randoms   u1s   u2s   ps   rs   us   vs   zs   b(    (    s   /usr/lib/python2.2/random.pys   stdgammaÃs@    	 		,	  	
	I
c    s‰   |  i } |  i } t |  _ | t j oQ | ƒ  t } t d t d | ƒ  ƒ ƒ } t
 | ƒ | } t | ƒ | |  _ n | | | Sd  S(   Nf-2.0f1.0(   s   selfs   randoms
   gauss_nexts   zs   Nones   TWOPIs   x2pis   _sqrts   _logs   g2rads   _coss   _sins   mus   sigma(   s   selfs   mus   sigmas   randoms   x2pis   zs   g2rad(    (    s   /usr/lib/python2.2/random.pys   gaussùs    			c    sC   |  i | d ƒ } | d j o d Sn | | |  i | d ƒ Sd  S(   Nf1.0i    f0.0(   s   selfs   gammavariates   alphas   ys   beta(   s   selfs   alphas   betas   y(    (    s   /usr/lib/python2.2/random.pys   betavariate&s    c    s%   |  i ƒ  } d t | d | ƒ Sd  S(   Nf1.0(   s   selfs   randoms   us   pows   alpha(   s   selfs   alphas   u(    (    s   /usr/lib/python2.2/random.pys   paretovariate1s    c    s,   |  i ƒ  } | t t | ƒ d | ƒ Sd  S(   Nf1.0(   s   selfs   randoms   us   alphas   pows   _logs   beta(   s   selfs   alphas   betas   u(    (    s   /usr/lib/python2.2/random.pys   weibullvariate9s    (   s   __name__s
   __module__s   VERSIONs   Nones   __init__s   seeds   randoms   getstates   setstates	   jumpaheads   _Random__whseeds   whseeds   __getstate__s   __setstate__s   ints	   randranges   randints   choices   shuffles   uniforms   normalvariates   lognormvariates   cunifvariates   expovariates   vonmisesvariates   gammavariates   stdgammas   gausss   betavariates   paretovariates   weibullvariate(    (    (    s   /usr/lib/python2.2/random.pys   Randoml s6   			
			'	
							*		6	-		c    s  d  k  }
 |  Gd G| GHt | | d ƒ } d } d }	 d } d } |
 i  ƒ  } xV t
 |  ƒ D]H } t | ƒ } | | } |	 | | }	 t | | ƒ } t | | ƒ } qY W|
 i  ƒ  } t | | d ƒ Gd G| |  } t |	 |  | | ƒ } d | | | | f GHd  S(	   Ns   timess   evalf0.0f10000000000.0f-10000000000.0i   s   sec,s!   avg %g, stddev %g, min %g, max %g(   s   times   ns   funccalls   compiles   codes   sums   sqsums   smallests   largests   t0s   ranges   is   evals   xs   mins   maxs   t1s   rounds   avgs   _sqrts   stddev(   s   ns   funccalls   codes   stddevs   is   sums   largests   t0s   smallests   sqsums   times   xs   t1s   avg(    (    s   /usr/lib/python2.2/random.pys   _test_generatorAs(    	 

iÈ   c    sp  d Gt  GHd Gt GHd Gt GHd Gt GHt |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d	 ƒ t |  d
 ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t |  d ƒ t ƒ  } t |  ƒ t	 ƒ  } t | ƒ x t |  ƒ D] } t	 ƒ  q'Wt	 ƒ  } | | j o t d |  | | f ƒ ‚ n d  S(   Ns   TWOPI         =s   LOG4          =s   NV_MAGICCONST =s   SG_MAGICCONST =s   random()s   normalvariate(0.0, 1.0)s   lognormvariate(0.0, 1.0)s   cunifvariate(0.0, 1.0)s   expovariate(1.0)s   vonmisesvariate(0.0, 1.0)s   gammavariate(0.5, 1.0)s   gammavariate(0.9, 1.0)s   gammavariate(1.0, 1.0)s   gammavariate(2.0, 1.0)s   gammavariate(20.0, 1.0)s   gammavariate(200.0, 1.0)s   gauss(0.0, 1.0)s   betavariate(3.0, 3.0)s   paretovariate(1.0)s   weibullvariate(1.0, 1.0)s   jumpahead test failed (   s   TWOPIs   LOG4s   NV_MAGICCONSTs   SG_MAGICCONSTs   _test_generators   Ns   getstates   ss	   jumpaheads   randoms   r1s   setstates   ranges   is   r2s
   ValueError(   s   Ns   r1s   is   r2s   s(    (    s   /usr/lib/python2.2/random.pys   _testWs<    					
	
 	s   __main__N(3   s   __doc__s   maths   logs   _logs   exps   _exps   pis   _pis   es   _es   sqrts   _sqrts   acoss   _acoss   coss   _coss   sins   _sins   __all__s   _verifys   NV_MAGICCONSTs   TWOPIs   LOG4s   SG_MAGICCONSTs   Randoms   _test_generators   _tests   _insts   seeds   randoms   uniforms   randints   choices	   randranges   shuffles   normalvariates   lognormvariates   cunifvariates   expovariates   vonmisesvariates   gammavariates   stdgammas   gausss   betavariates   paretovariates   weibullvariates   getstates   setstates	   jumpaheads   whseeds   __name__((   s   lognormvariates   _sins   _exps	   randranges   _acoss   betavariates   _tests   randoms   LOG4s   normalvariates   choices   _verifys   weibullvariates   gausss	   jumpaheads   _logs   shuffles   paretovariates   expovariates   _insts   gammavariates   TWOPIs   _test_generators   __all__s   SG_MAGICCONSTs   randints   whseeds   vonmisesvariates   Randoms   _pis   getstates   uniforms   _coss   stdgammas   seeds   cunifvariates   _sqrts   _es   NV_MAGICCONSTs   setstate(    (    s   /usr/lib/python2.2/random.pys   ?I sT   K	
ÿ Ö	'																							