vsrandom Namespace Reference

Data Structures
class	Random

Functions
def	seed
	--------------—— core generator -------------—— More...
def	random
def	getstate
def	setstate
def	jumpahead
def	whseed
def	__getstate__
	-— Methods below this point do not need to be overridden when -— subclassing for the purpose of using a different core generator. More...
def	__setstate__
def	randrange
	--------------—— integer methods -------------—— More...
def	randint
def	choice
	--------------—— sequence methods -------------—— More...
def	shuffle
def	uniform
	-----------——— real-valued distributions ----------——— More...
def	normalvariate
	-----------------— normal distribution -----------------— More...
def	lognormvariate
	-----------------— lognormal distribution -----------------— More...
def	cunifvariate
	-----------------— circular uniform -----------------— More...
def	expovariate
	-----------------— exponential distribution -----------------— More...
def	vonmisesvariate
	-----------------— von Mises distribution -----------------— More...
def	gammavariate
	-----------------— gamma distribution -----------------— More...
def	stdgamma
def	gauss
	-----------------— Gauss (faster alternative) -----------------— More...
def	betavariate
	-----------------— beta -----------------— See http://sourceforge.net/bugs/?func=detailbug&bug_id=130030&group_id=5470 for Ivan Frohne's insightful analysis of why the original implementation: More...
def	paretovariate
	-----------------— Pareto -----------------— More...
def	weibullvariate
	-----------------— Weibull -----------------— More...

Variables
float	_pi = 3.1415926536
float	_e = 2.7182818284590451
list	__all__
int	NV_MAGICCONST = 4
float	TWOPI = 2.0
tuple	LOG4 = _log(4.0)
float	SG_MAGICCONST = 1.0
tuple	_inst = Random()
	seed = _inst.seed
	random = _inst.random
	uniform = _inst.uniform
	randint = _inst.randint
	choice = _inst.choice
	randrange = _inst.randrange
	shuffle = _inst.shuffle
	normalvariate = _inst.normalvariate
	lognormvariate = _inst.lognormvariate
	cunifvariate = _inst.cunifvariate
	expovariate = _inst.expovariate
	vonmisesvariate = _inst.vonmisesvariate
	gammavariate = _inst.gammavariate
	stdgamma = _inst.stdgamma
	gauss = _inst.gauss
	betavariate = _inst.betavariate
	paretovariate = _inst.paretovariate
	weibullvariate = _inst.weibullvariate
	getstate = _inst.getstate
	setstate = _inst.setstate
	jumpahead = _inst.jumpahead
	whseed = _inst.whseed
	_seed
	gauss_next

Detailed Description

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

Function Documentation

def vsrandom.__getstate__

(

self)

-— Methods below this point do not need to be overridden when -— subclassing for the purpose of using a different core generator.

-----------------— pickle support ----------------—

Definition at line 270 of file vsrandom.py.

    def __getstate__(self): # for pickle
        return self.getstate()