HE_Mesh2014  2.0.11
Public Member Functions | Private Attributes | Static Private Attributes | List of all members
wblut.math.WB_MTRandom Class Reference
+ Inheritance diagram for wblut.math.WB_MTRandom:

Public Member Functions

Object clone () throws CloneNotSupportedException
 
boolean stateEquals (final Object o)
 
void readState (final DataInputStream stream) throws IOException
 
void writeState (final DataOutputStream stream) throws IOException
 
 WB_MTRandom ()
 
 WB_MTRandom (final long seed)
 
 WB_MTRandom (final int[] array)
 
synchronized void setSeed (final long seed)
 
synchronized void setSeed (final int[] array)
 
final int nextInt ()
 
final short nextShort ()
 
final char nextChar ()
 
final boolean nextBoolean ()
 
final boolean nextBoolean (final float probability)
 
final boolean nextBoolean (final double probability)
 
final byte nextByte ()
 
final void nextBytes (final byte[] bytes)
 
final long nextLong ()
 
final long nextLong (final long n)
 
final double nextDouble ()
 
final double nextGaussian ()
 
final float nextFloat ()
 
final int nextInt (final int n)
 

Private Attributes

int mt []
 
int mti
 
int mag01 []
 
double __nextNextGaussian
 
boolean __haveNextNextGaussian
 

Static Private Attributes

static final long serialVersionUID = 3636987267914792302L
 
static final int N = 624
 
static final int M = 397
 
static final int MATRIX_A = 0x9908b0df
 
static final int UPPER_MASK = 0x80000000
 
static final int LOWER_MASK = 0x7fffffff
 
static final int TEMPERING_MASK_B = 0x9d2c5680
 
static final int TEMPERING_MASK_C = 0xefc60000
 

Detailed Description

Mersenne Twister random number generator.

Author
NOT Frederik Vanhoutte
    This code is by Sean Luke. http://www.cs.gmu.edu/~sean/research/

    Original comments:

    <h3>MersenneTwister and MersenneTwisterFast</h3>
    <p>
    <b>Version 13</b>, based on version MT199937(99/10/29) of the
    Mersenne Twister algorithm found at <a
    href="http://www.math.keio.ac.jp/matumoto/emt.html"> The Mersenne
    Twister Home Page</a>, with the initialization improved using the new
    2002/1/26 initialization algorithm By Sean Luke, October 2004.

    <p>
    <b>MersenneTwister</b> is a drop-in 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.

    <p>
    <b>MersenneTwisterFast</b> 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 <i>not</i> 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.

    <h3>About the Mersenne Twister</h3>
    <p>
    This is a Java version of the C-program 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.

    <p>
    <b>Reference. </b> Makato Matsumoto and Takuji Nishimura, "Mersenne
    Twister: A 623-Dimensionally Equidistributed Uniform Pseudo-Random
    Number Generator", <i>ACM Transactions on Modeling and. Computer
    Simulation,</i> Vol. 8, No. 1, January 1998, pp 3--30.

    <h3>About this Version</h3>

    <p>
    <b>Changes Since V12:</b> clone() method added.

    <p>
    <b>Changes Since V11:</b> stateEquals(...) method added.
    MersenneTwisterFast is equal to other MersenneTwisterFasts with
    identical state; likewise MersenneTwister is equal to other
    MersenneTwister with identical state. This isn't equals(...) because
    that requires a contract of immutability to compare by value.

    <p>
    <b>Changes Since V10:</b> A documentation error suggested that
    setSeed(int[]) required an int[] array 624 long. In fact, the array
    can be any non-zero length. The new version also checks for this
    fact.

    <p>
    <b>Changes Since V9:</b> readState(stream) and writeState(stream)
    provided.

    <p>
    <b>Changes Since V8:</b> setSeed(int) was only using the first 28
    bits of the seed; it should have been 32 bits. For small-number seeds
    the behavior is identical.

    <p>
    <b>Changes Since V7:</b> A documentation error in MersenneTwisterFast
    (but not MersenneTwister) stated that nextDouble selects uniformly
    from the full-open interval [0,1]. It does not. nextDouble's contract
    is identical across MersenneTwisterFast, MersenneTwister, and
    java.util.Random, namely, selection in the half-open interval [0,1).
    That is, 1.0 should not be returned. A similar contract exists in
    nextFloat.

    <p>
    <b>Changes Since V6:</b> 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).

    <p>
    <b>Changes Since V5:</b> New empty constructor made to work the same
    as java.util.Random -- namely, it seeds based on the current time in
    milliseconds.

    <p>
    <b>Changes Since V4:</b> New initialization algorithms. See (see <a
    href="http://www.math.keio.ac.jp/matumoto/MT2002/emt19937ar.html"</a>
    http://www.math.keio.ac.jp/matumoto/MT2002/emt19937ar.html</a>)

    <p>
    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.

    <h3>Java notes</h3>

    <p>
    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 <a href=
    "http://www.javasoft.com/products/jdk/1.2/docs/api/java/util/Random.html"
    > the JDK 1.2 java.util.Random documentation</a> 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.

    <p>
    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.

    <p>
    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.

    <h3>License</h3>

    Copyright (c) 2003 by Sean Luke. <br>
    Portions copyright (c) 1993 by Michael Lecuyer. <br>
    All rights reserved. <br>

    <p>
    Redistribution and use in source and binary forms, with or without
    modification, are permitted provided that the following conditions
    are met:
    <ul>
    <li>Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
    <li>Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
    <li>Neither the name of the copyright owners, their employers, nor
    the names of its contributors may be used to endorse or promote
    products derived from this software without specific prior written
    permission.
    </ul>
    <p>
    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.
Version
13

Constructor & Destructor Documentation

wblut.math.WB_MTRandom.WB_MTRandom ( )

Constructor using the default seed.

wblut.math.WB_MTRandom.WB_MTRandom ( final 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
seedthe seed
wblut.math.WB_MTRandom.WB_MTRandom ( final int[]  array)

Constructor using an array of integers as seed. Your array must have a non-zero length. Only the first 624 integers in the array are used; if the array is shorter than this then integers are repeatedly used in a wrap-around fashion.

Parameters
arraythe array

Member Function Documentation

Object wblut.math.WB_MTRandom.clone ( ) throws CloneNotSupportedException
final boolean wblut.math.WB_MTRandom.nextBoolean ( )

Next boolean.

Returns
next random boolean
final boolean wblut.math.WB_MTRandom.nextBoolean ( final float  probability)

This generates a coin flip with a probability probability of returning true, else returning false. probability must be between 0.0 and 1.0, inclusive. Not as precise a random real event as nextBoolean(double), but twice as fast. To explicitly use this, remember you may need to cast to float first.

Parameters
probabilitythe probability
Returns
next random coin flip
final boolean wblut.math.WB_MTRandom.nextBoolean ( final double  probability)

This generates a coin flip with a probability probability of returning true, else returning false. probability must be between 0.0 and 1.0, inclusive.

Parameters
probabilitythe probability
Returns
next random coin flip
final byte wblut.math.WB_MTRandom.nextByte ( )

Next byte.

Returns
next random byte
final void wblut.math.WB_MTRandom.nextBytes ( final byte[]  bytes)

Fill array of bytes with random values.

Parameters
bytesthe bytes
final char wblut.math.WB_MTRandom.nextChar ( )

Next char.

Returns
next random char
final double wblut.math.WB_MTRandom.nextDouble ( )

Returns a random double in the half-open range from [0.0,1.0). Thus 0.0 is a valid result but 1.0 is not.

Returns
next random double in range [0,1)
final float wblut.math.WB_MTRandom.nextFloat ( )

Returns a random float in the half-open range from [0.0f,1.0f). Thus 0.0f is a valid result but 1.0f is not.

Returns
next random float in range [0,1)
final double wblut.math.WB_MTRandom.nextGaussian ( )

Next gaussian.

Returns
the double
final int wblut.math.WB_MTRandom.nextInt ( )

Next int.

Returns
next random integer
final int wblut.math.WB_MTRandom.nextInt ( final 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.

Parameters
nthe n
Returns
next random integer in range 0 to n-1.
final long wblut.math.WB_MTRandom.nextLong ( )

Next long.

Returns
next random long
final long wblut.math.WB_MTRandom.nextLong ( final long  n)

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

Parameters
nthe n
Returns
next random long between 0 and n-1
final short wblut.math.WB_MTRandom.nextShort ( )

Next short.

Returns
next random short
void wblut.math.WB_MTRandom.readState ( final DataInputStream  stream) throws IOException

Reads the entire state of the MersenneTwister RNG from the stream.

Parameters
streamthe stream
Exceptions
IOExceptionSignals that an I/O exception has occurred.
synchronized void wblut.math.WB_MTRandom.setSeed ( final long  seed)

Initalize the pseudo random number generator. Don't pass in a long that's bigger than an int (Mersenne Twister only uses the first 32 bits for its seed).

Parameters
seedthe new seed
synchronized void wblut.math.WB_MTRandom.setSeed ( final int[]  array)

Sets the seed of the MersenneTwister using an array of integers. Your array must have a non-zero length. Only the first 624 integers in the array are used; if the array is shorter than this then integers are repeatedly used in a wrap-around fashion.

Parameters
arraythe new seed
boolean wblut.math.WB_MTRandom.stateEquals ( final Object  o)

State equals.

Parameters
othe o
Returns
true, if successful
void wblut.math.WB_MTRandom.writeState ( final DataOutputStream  stream) throws IOException

Writes the entire state of the MersenneTwister RNG to the stream.

Parameters
streamthe stream
Exceptions
IOExceptionSignals that an I/O exception has occurred.

Member Data Documentation

boolean wblut.math.WB_MTRandom.__haveNextNextGaussian
private

The __have next next gaussian.

double wblut.math.WB_MTRandom.__nextNextGaussian
private

The __next next gaussian.

final int wblut.math.WB_MTRandom.LOWER_MASK = 0x7fffffff
staticprivate

The Constant LOWER_MASK.

final int wblut.math.WB_MTRandom.M = 397
staticprivate

The Constant M.

int wblut.math.WB_MTRandom.mag01[]
private

The mag01.

final int wblut.math.WB_MTRandom.MATRIX_A = 0x9908b0df
staticprivate

The Constant MATRIX_A.

int wblut.math.WB_MTRandom.mt[]
private

The mt.

int wblut.math.WB_MTRandom.mti
private

The mti.

final int wblut.math.WB_MTRandom.N = 624
staticprivate

The Constant N.

final long wblut.math.WB_MTRandom.serialVersionUID = 3636987267914792302L
staticprivate

The Constant serialVersionUID.

final int wblut.math.WB_MTRandom.TEMPERING_MASK_B = 0x9d2c5680
staticprivate

The Constant TEMPERING_MASK_B.

final int wblut.math.WB_MTRandom.TEMPERING_MASK_C = 0xefc60000
staticprivate

The Constant TEMPERING_MASK_C.

final int wblut.math.WB_MTRandom.UPPER_MASK = 0x80000000
staticprivate

The Constant UPPER_MASK.


The documentation for this class was generated from the following file: