public class MersenneTwister
extends java.util.Random
implements java.io.Serializable
Version 8, based on version MT199937(99/10/29) of the Mersenne Twister algorithm found at The Mersenne Twister Home Page, with the initialization improved using the new 2002/1/26 initialization algorithm By Sean Luke, April 2004.
MersenneTwister is a dropin subclass replacement for java.util.Random. It is properly synchronized and can be used in a multithreaded environment. On modern VMs such as HotSpot, it is approximately 1/3 slower than java.util.Random.
MersenneTwisterFast is not a subclass of java.util.Random. It has the same public methods as Random does, however, and it is algorithmically identical to MersenneTwister. MersenneTwisterFast has hardcode inlined all of its methods directly, and made all of them final (well, the ones of consequence anyway). Further, these methods are not synchronized, so the same MersenneTwisterFast instance cannot be shared by multiple threads. But all this helps MersenneTwisterFast achieve well over twice the speed of MersenneTwister. java.util.Random is about 1/3 slower than MersenneTwisterFast.
This is a Java version of the Cprogram for MT19937: Integer version. The MT19937 algorithm was created by Makoto Matsumoto and Takuji Nishimura, who ask: "When you use this, send an email to: matumoto@math.keio.ac.jp with an appropriate reference to your work". Indicate that this is a translation of their algorithm into Java.
Reference. Makato Matsumoto and Takuji Nishimura, "Mersenne Twister: A 623Dimensionally Equidistributed Uniform PseudoRandom Number Generator", ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 330.
Changes Since V7: A documentation error in MersenneTwisterFast (but not MersenneTwister) stated that nextDouble selects uniformly from the fullopen interval [0,1]. It does not. nextDouble's contract is identical across MersenneTwisterFast, MersenneTwister, and java.util.Random, namely, selection in the halfopen interval [0,1). That is, 1.0 should not be returned. A similar contract exists in nextFloat.
Changes Since V6: License has changed from LGPL to BSD. New timing information to compare against java.util.Random. Recent versions of HotSpot have helped Random increase in speed to the point where it is faster than MersenneTwister but slower than MersenneTwisterFast (which should be the case, as it's a less complex algorithm but is synchronized).
Changes Since V5: New empty constructor made to work the same as java.util.Random  namely, it seeds based on the current time in milliseconds.
Changes Since V4: New initialization algorithms. See (see http://www.math.keio.ac.jp/matumoto/MT2002/emt19937ar.html)
The MersenneTwister code is based on standard MT19937 C/C++ code by Takuji Nishimura, with suggestions from Topher Cooper and Marc Rieffel, July 1997. The code was originally translated into Java by Michael Lecuyer, January 1999, and the original code is Copyright (c) 1999 by Michael Lecuyer.
This implementation implements the bug fixes made in Java 1.2's version of Random, which means it can be used with earlier versions of Java. See the JDK 1.2 java.util.Random documentation for further documentation on the randomnumber generation contracts made. Additionally, there's an undocumented bug in the JDK java.util.Random.nextBytes() method, which this code fixes.
Just like java.util.Random, this generator accepts a long seed but doesn't use all of it. java.util.Random uses 48 bits. The Mersenne Twister instead uses 32 bits (int size). So it's best if your seed does not exceed the int range.
MersenneTwister can be used reliably on JDK version 1.1.5 or above. Earlier Java versions have serious bugs in java.util.Random; only MersenneTwisterFast (and not MersenneTwister nor java.util.Random) should be used with them.
Copyright (c) 2003 by Sean Luke.
Portions copyright (c) 1993 by Michael Lecuyer.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Constructor and Description 

MersenneTwister()
Constructor using the default seed.

MersenneTwister(int[] array)
Constructor using an array.

MersenneTwister(long seed)
Constructor using a given seed.

Modifier and Type  Method and Description 

protected int 
next(int bits)
Returns an integer with bits bits filled with a random number.

boolean 
nextBoolean()
This method is missing from jdk 1.0.x and below.

boolean 
nextBoolean(double probability)
This generates a coin flip with a probability probability
of returning true, else returning false.

boolean 
nextBoolean(float probability)
This generates a coin flip with a probability probability
of returning true, else returning false.

byte 
nextByte()
For completeness' sake, though it's not in java.util.Random.

void 
nextBytes(byte[] bytes)
A bug fix for all versions of the JDK.

char 
nextChar()
For completeness' sake, though it's not in java.util.Random.

double 
nextDouble()
A bug fix for versions of JDK 1.1 and below.

float 
nextFloat()
A bug fix for versions of JDK 1.1 and below.

double 
nextGaussian()
A bug fix for all JDK code including 1.2.

int 
nextInt(int n)
This method is missing from JDK 1.1 and below.

long 
nextLong(long n)
This method is for completness' sake.

short 
nextShort()
For completeness' sake, though it's not in java.util.Random.

void 
setSeed(int[] array)
An alternative, more complete, method of seeding the
pseudo random number generator.

void 
setSeed(long seed)
Initalize the pseudo random number generator.

public MersenneTwister()
public MersenneTwister(long seed)
public MersenneTwister(int[] array)
public void setSeed(long seed)
setSeed
in class java.util.Random
public void setSeed(int[] array)
protected int next(int bits)
next
in class java.util.Random
public boolean nextBoolean()
nextBoolean
in class java.util.Random
public boolean nextBoolean(float probability)
public boolean nextBoolean(double probability)
public int nextInt(int n)
nextInt
in class java.util.Random
public long nextLong(long n)
public double nextDouble()
nextDouble
in class java.util.Random
public float nextFloat()
nextFloat
in class java.util.Random
public void nextBytes(byte[] bytes)
nextBytes
in class java.util.Random
public char nextChar()
public short nextShort()
public byte nextByte()
public double nextGaussian()
nextGaussian
in class java.util.Random