Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## taskspaces.rna
Class MersenneTwisterFast

    java.lang.Object
      |
      +--taskspaces.rna.MersenneTwisterFast

All Implemented Interfaces:
  java.io.Serializable

public class MersenneTwisterFast
extends java.lang.Object
implements java.io.Serializable

Mersenne Twister and MersenneTwisterFast:

MersenneTwisterFast is a drop-in 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 hard-code 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.

About the Mersenne Twister. This is a Java version of the C-program for MT19937: Integer version. next(32) generates one pseudorandom unsigned integer (32bit) which is uniformly distributed among 0 to 2^32-1 for each call. next(int bits) >>>'s by (32-bits) to get a value ranging between 0 and 2^bits-1 long inclusive; hope that's correct. setSeed(seed) set initial values to the working area of 624 words. For setSeed(seed), seed is any 32-bit integer except for 0.

Orignally Coded by Takuji Nishimura, considering the suggestions by Topher Cooper and Marc Rieffel in July-Aug. 1997. More information can be found here.

Translated to Java by Michael Lecuyer January 30, 1999 Copyright (C) 1999 Michael Lecuyer

This library 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 02111-1307 USA

Makoto Matsumoto and Takuji Nishimura, the original authors ask "When you use this, send an email to: matumoto@math.keio.ac.jp with an appropriate reference to your work" You might also point out this was a translation.

Reference. M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3--30.

About this version. This is a modification of the original code made to conform to proper java.util.Random format by Sean Luke, August 7, 1999.

Bug Fixes. 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 random-number generation contracts made. Additionally, there's an undocumented bug in the JDK java.util.Random.nextBytes() method, which this code fixes.

Important Note. 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.

See Also:
  Serialized Form

Field Summary
`private static long` | `GOOD_SEED`
`private boolean` | `haveNextNextGaussian`
`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 double` | `nextNextGaussian`
`private static int` | `TEMPERING_MASK_B`
`private static int` | `TEMPERING_MASK_C`
`private static int` | `UPPER_MASK`

Constructor Summary
`MersenneTwisterFast()` Constructor using the default seed.
`MersenneTwisterFast(long seed)` Constructor using a given seed.

Method Summary
`static void` | `main(java.lang.String[] args)` Tests the code.
`boolean` | `nextBoolean()`
`byte` | `nextByte()`
`void` | `nextBytes(byte[] bytes)`
`char` | `nextChar()`
`double` | `nextDouble()`
`float` | `nextFloat()`
`double` | `nextGaussian()`
`int` | `nextInt()`
`int` | `nextInt(int n)` Returns an integer drawn uniformly from 0 to n-1.
`long` | `nextLong()`
`short` | `nextShort()`
`void` | `setSeed(long seed)` Initalize the pseudo random number generator.

Methods inherited from class java.lang.Object
`, clone, equals, finalize, getClass, hashCode, notify, notifyAll, registerNatives, toString, wait, wait, wait`

Field Detail

### N

    private static final int N

### M

    private static final int M

### MATRIX_A

    private static final int MATRIX_A

### UPPER_MASK

    private static final int UPPER_MASK

### LOWER_MASK

    private static final int LOWER_MASK

### TEMPERING_MASK_B

    private static final int TEMPERING_MASK_B

### TEMPERING_MASK_C

    private static final int TEMPERING_MASK_C

### mt

    private int[] mt

### mti

    private int mti

### mag01

    private int[] mag01

### GOOD_SEED

    private static final long GOOD_SEED

### nextNextGaussian

    private double nextNextGaussian

### haveNextNextGaussian

    private boolean haveNextNextGaussian

Constructor Detail

### MersenneTwisterFast

    public MersenneTwisterFast()

  Constructor using the default seed.

### MersenneTwisterFast

    public MersenneTwisterFast(long seed)

  Constructor using a given seed. Though you pass this seed in as a long, it's best to make sure it's actually an integer.
  Parameters:
    `seed` - generator starting number, often the time of day.

Method Detail

### setSeed

    public final void setSeed(long seed)

  Initalize the pseudo random number generator. The Mersenne Twister only uses an integer for its seed; It's best that you don't pass in a long that's bigger than an int.
  Parameters:
    `seed` - from constructor

### nextInt

    public final int nextInt()

### nextShort

    public final short nextShort()

### nextChar

    public final char nextChar()

### nextBoolean

    public final boolean nextBoolean()

### nextByte

    public final byte nextByte()

### nextBytes

    public final void nextBytes(byte[] bytes)

### nextLong

    public final long nextLong()

### nextDouble

    public final double nextDouble()

### nextGaussian

    public final double nextGaussian()

### nextFloat

    public final float nextFloat()

### nextInt

    public int nextInt(int n)

  Returns an integer drawn uniformly from 0 to n-1. Suffice it to say, n must be > 0, or an IllegalArgumentException is raised.

### main

    public static void main(java.lang.String[] args)

  Tests the code.

Class | Use | Tree | Deprecated | Index | Help
| -bottom
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD