

PREV PACKAGE NEXT PACKAGE  FRAMES NO FRAMES 
See:
Description
Interface Summary  

NormalizedRandomGenerator  This interface represent a normalized random generator for scalars. 
RandomData  Deprecated. to be removed in 4.0. 
RandomGenerator  Interface extracted from java.util.Random . 
RandomVectorGenerator  This interface represents a random generator for whole vectors. 
Class Summary  

AbstractRandomGenerator  Abstract class implementing the RandomGenerator interface. 
AbstractWell  This abstract class implements the WELL class of pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
BitsStreamGenerator  Base class for random number generators that generates bits streams. 
CorrelatedRandomVectorGenerator  A RandomVectorGenerator that generates vectors with with
correlated components. 
EmpiricalDistribution  Represents an empirical probability distribution  a probability distribution derived from observed data without making any assumptions about the functional form of the population distribution that the data come from. 
GaussianRandomGenerator  This class is a gaussian normalized random generator for scalars. 
ISAACRandom 
ISAAC: a fast cryptographic pseudorandom number generator
ISAAC (Indirection, Shift, Accumulate, Add, and Count) generates 32bit random numbers. 
JDKRandomGenerator  Extension of java.util.Random to implement
RandomGenerator . 
MersenneTwister  This class implements a powerful pseudorandom number generator developed by Makoto Matsumoto and Takuji Nishimura during 19961997. 
RandomAdaptor  Extension of java.util.Random wrapping a
RandomGenerator . 
RandomDataGenerator  Implements the RandomData interface using a RandomGenerator
instance to generate nonsecure data and a SecureRandom
instance to provide data for the nextSecureXxx methods. 
RandomDataImpl  Deprecated. to be removed in 4.0. 
StableRandomGenerator  This class provides a stable normalized random generator. 
SynchronizedRandomGenerator  Any RandomGenerator implementation can be threadsafe if it
is used through an instance of this class. 
UncorrelatedRandomVectorGenerator  A RandomVectorGenerator that generates vectors with uncorrelated
components. 
UniformRandomGenerator  This class implements a normalized uniform random generator. 
UnitSphereRandomVectorGenerator  Generate random vectors isotropically located on the surface of a sphere. 
ValueServer  Generates values for use in simulation applications. 
Well1024a  This class implements the WELL1024a pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
Well19937a  This class implements the WELL19937a pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
Well19937c  This class implements the WELL19937c pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
Well44497a  This class implements the WELL44497a pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
Well44497b  This class implements the WELL44497b pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
Well512a  This class implements the WELL512a pseudorandom number generator from François Panneton, Pierre L'Ecuyer and Makoto Matsumoto. 
Random number and random data generators.
Commonsmath provides a few pseudo random number generators. The top level interface is RandomGenerator. It is implemented by three classes:
JDKRandomGenerator
that extends the JDK provided generatorThe JDK provided generator is a simple one that can be used only for very simple needs. The Mersenne Twister is a fast generator with very good properties well suited for MonteCarlo simulation. It is equidistributed for generating vectors up to dimension 623 and has a huge period: 2^{19937}  1 (which is a Mersenne prime). This generator is described in a paper by Makoto Matsumoto and Takuji Nishimura in 1998: Mersenne Twister: A 623Dimensionally Equidistributed Uniform PseudoRandom Number Generator, ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 330. The WELL generators are a family of generators with period ranging from 2^{512}  1 to 2^{44497}  1 (this last one is also a Mersenne prime) with even better properties than Mersenne Twister. These generators are described in a paper by François Panneton, Pierre L'Ecuyer and Makoto Matsumoto Improved LongPeriod Generators Based on Linear Recurrences Modulo 2 ACM Transactions on Mathematical Software, 32, 1 (2006). The errata for the paper are in wellrngerrata.txt.
For simple sampling, any of these generators is sufficient. For MonteCarlo simulations the JDK generator does not have any of the good mathematical properties of the other generators, so it should be avoided. The Mersenne twister and WELL generators have equidistribution properties proven according to their bits pool size which is directly linked to their period (all of them have maximal period, i.e. a generator with size n pool has a period 2^{n}1). They also have equidistribution properties for 32 bits blocks up to s/32 dimension where s is their pool size. So WELL19937c for exemple is equidistributed up to dimension 623 (19937/32). This means a MonteCarlo simulation generating a vector of n variables at each iteration has some guarantees on the properties of the vector as long as its dimension does not exceed the limit. However, since we use bits from two successive 32 bits generated integers to create one double, this limit is smaller when the variables are of type double. so for MonteCarlo simulation where less the 16 doubles are generated at each round, WELL1024 may be sufficient. If a larger number of doubles are needed a generator with a larger pool would be useful.
The WELL generators are more modern then MersenneTwister (the paper describing than has been published in 2006 instead of 1998) and fix some of its (few) drawbacks. If initialization array contains many zero bits, MersenneTwister may take a very long time (several hundreds of thousands of iterations to reach a steady state with a balanced number of zero and one in its bits pool). So the WELL generators are better to escape zeroland as explained by the WELL generators creators. The Well19937a and Well44497a generator are not maximally equidistributed (i.e. there are some dimensions or bits blocks size for which they are not equidistributed). The Well512a, Well1024a, Well19937c and Well44497b are maximally equidistributed for blocks size up to 32 bits (they should behave correctly also for double based on more than 32 bits blocks, but equidistribution is not proven at these blocks sizes).
The MersenneTwister generator uses a 624 elements integer array, so it consumes less than 2.5 kilobytes. The WELL generators use 6 integer arrays with a size equal to the pool size, so for example the WELL44497b generator uses about 33 kilobytes. This may be important if a very large number of generator instances were used at the same time.
All generators are quite fast. As an example, here are some comparisons, obtained on a 64 bits JVM on a linux computer with a 2008 processor (AMD phenom Quad 9550 at 2.2 GHz). The generation rate for MersenneTwister was about 27 millions doubles per second (remember we generate two 32 bits integers for each double). Generation rates for other PRNG, relative to MersenneTwister:
Example of performances  
Name  generation rate (relative to MersenneTwister) 
MersenneTwister  1 
JDKRandomGenerator  between 0.96 and 1.16 
Well512a  between 0.85 and 0.88 
Well1024a  between 0.63 and 0.73 
Well19937a  between 0.70 and 0.71 
Well19937c  between 0.57 and 0.71 
Well44497a  between 0.69 and 0.71 
Well44497b  between 0.65 and 0.71 
So for most simulation problems, the better generators like Well19937c
and Well44497b
are probably very good choices.
Note that none of these generators are suitable for cryptography. They are devoted to simulation, and to generate very long series with strong properties on the series as a whole (equidistribution, no correlation ...). They do not attempt to create small series but with very strong properties of unpredictability as needed in cryptography.


PREV PACKAGE NEXT PACKAGE  FRAMES NO FRAMES 