

PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 
java.lang.Object java.util.Random org.aitools.programd.util.MersenneTwister
public class MersenneTwister
Version 3 , based on version MT199937(99/10/29) of the Mersenne Twister algorithm found at The Mersenne Twister Home Page . By Sean Luke, June 2000.
MersenneTwister is a dropin subclass replacement for java.util.Random. It is properly synchronized and can be used in a multithreaded environment.
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 over twice the speed of MersenneTwister.
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.
This 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 is Copyright (c) 1999 by Michael Lecuyer. The included license is as follows:
The basic algorithmic work of this library (appearing in nextInt() and setSeed()) is free software; you can redistribute it and or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 021111307 USA
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. And why would you use 'em anyway? They're very slow, as you'll see. Here are some timings in milliseconds on a Sun Creator3D/Ultra 60 running SunOS 5.6.
Field Summary  

private boolean 
__haveNextNextGaussian

private double 
__nextNextGaussian

private static long 
GOOD_SEED

private static int 
LOWER_MASK

private static int 
M

private int[] 
mag01

private static int 
MATRIX_A

private int[] 
mt

private int 
mti

private static int 
N

private static int 
TEMPERING_MASK_B

private static int 
TEMPERING_MASK_C

private static int 
UPPER_MASK

Constructor Summary  

MersenneTwister()
Constructor using the default seed. 

MersenneTwister(long seed)
Constructor using a given seed. 
Method Summary  

static void 
main(java.lang.String[] args)
Tests the code. 
protected int 
next(int bits)

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. 
double 
nextGaussian()
A bug fix for all JDK code including 1.2. nextGaussian can theoretically ask for the log of 0 and divide it by 0! 
char 
nextChar()
For completeness' sake, though it's not in java.util.Random. 
short 
nextShort()
For completeness' sake, though it's not in java.util.Random. 
private void 
readObject(java.io.ObjectInputStream in)

void 
setSeed(int[] array)
An alternative, more complete, method of seeding the pseudo random number generator. array must be an array of 624 ints, and they can be any value as long as they're not *all* zero. 
void 
setSeed(long seed)
Initalize the pseudo random number generator. 
void 
setSeedOld(long seed)
Initalize the pseudo random number generator. 
private void 
writeObject(java.io.ObjectOutputStream out)

Methods inherited from class java.util.Random 

nextBoolean, nextDouble, nextFloat, nextInt, nextInt, nextLong 
Methods inherited from class java.lang.Object 

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait 
Field Detail 

private static final int N
private static final int M
private static final int MATRIX_A
private static final int UPPER_MASK
private static final int LOWER_MASK
private static final int TEMPERING_MASK_B
private static final int TEMPERING_MASK_C
private int[] mt
private int mti
private int[] mag01
private static final long GOOD_SEED
private double __nextNextGaussian
private boolean __haveNextNextGaussian
Constructor Detail 

public MersenneTwister()
public MersenneTwister(long seed)
seed
 the seed to useMethod Detail 

public void setSeedOld(long seed)
seed
 the seed to usepublic void setSeed(int[] array)
array
 an array of 624 intspublic void setSeed(long seed)
setSeed
in class java.util.Random
seed
 the seed to useprotected int next(int bits)
next
in class java.util.Random
bits
 the number of bits to use
private void writeObject(java.io.ObjectOutputStream out) throws java.io.IOException
java.io.IOException
private void readObject(java.io.ObjectInputStream in) throws java.io.IOException, java.lang.ClassNotFoundException
java.io.IOException
java.lang.ClassNotFoundException
public boolean nextBoolean(float probability)
probability
 the probability to use (between 0.0 and 1.0)
public boolean nextBoolean(double probability)
probability
 must be between 0.0 and 1.0
public void nextBytes(byte[] bytes)
nextBytes
in class java.util.Random
bytes
 the bytes for which to get the next bytes (?)public char nextChar()
public short nextShort()
public byte nextByte()
public double nextGaussian()
nextGaussian
in class java.util.Random
public static void main(java.lang.String[] args)
args
 not used


PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 