**'cern.jet.random.engine.MersenneTwister'**Java class

## Class MersenneTwister

- java.lang.Object
- cern.colt.PersistentObject
- cern.jet.random.engine.RandomEngine
- cern.jet.random.engine.MersenneTwister

- All Implemented Interfaces:
- DoubleFunction, IntFunction, Serializable, Cloneable

- Direct Known Subclasses:
- MersenneTwister64

public class MersenneTwisterextends RandomEngine

MersenneTwister (MT19937) is one of the strongest uniform pseudo-random number generators known so far; at the same time it is quick.Produces uniformly distributed`int`'s and`long`'s in the closed intervals`[Integer.MIN_VALUE,Integer.MAX_VALUE]`and`[Long.MIN_VALUE,Long.MAX_VALUE]`, respectively, as well as`float`'s and`double`'s in the open unit intervals`(0.0f,1.0f)`and`(0.0,1.0)`, respectively.The seed can be any 32-bit integer except`0`. Shawn J. Cokus commented that perhaps the seed should preferably be odd.**Quality:**MersenneTwister is designed to pass the k-distribution test. It has an astronomically large period of 2^{19937}-1 (=10^{6001}) and 623-dimensional equidistribution up to 32-bit accuracy.It passes many stringent statistical tests, including the diehard test of G. Marsaglia and the load test of P. Hellekalek and S. Wegenkittl.**Performance:**Its speed is comparable to other modern generators (in particular, as fast as`java.util.Random.nextFloat()`).2.5 million calls to`raw()`per second (Pentium Pro 200 Mhz, JDK 1.2, NT).Be aware, however, that there is a non-negligible amount of overhead required to initialize the datastructures used by a MersenneTwister. Code likedouble sum = 0.0; for (int i=0; i<100000; ++i) { RandomElement twister = new MersenneTwister(new java.util.Date()); sum += twister.raw(); }

will be wildly inefficient. Consider usingdouble sum = 0.0; RandomElement twister = new MersenneTwister(new java.util.Date()); for (int i=0; i<100000; ++i) { sum += twister.raw(); }

instead. This allows the cost of constructing the MersenneTwister objectto be borne only once, rather than once for each iteration in the loop.**Implementation:**After 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.- More info on Masumoto's homepage.
- More info on Pseudo-random number generators is on the Web.
- Yet some more info.
The correctness of this implementation has been verified against the published output sequence mt19937-2.out of the C-implementationmt19937-2.c.(Call

`test(1000)`to print the sequence).- Note that this implementation is
**not synchronized**.**Details:**MersenneTwister is designed with consideration of the flaws of various existing generators in mind.It is an improved version of TT800, a very successful generator.MersenneTwister is based on linear recurrences modulo 2.Such generators are very fast, have extremely long periods, and appear quite robust. MersenneTwister produces 32-bit numbers, and every`k`-dimensional vector of such numbers appears the same number of times as`k`successive values over theperiod length, for each`k <= 623`(except for the zero vector, which appears one time less).If one looks at only the first`n <= 16`bits of each number, then the property holds for even larger`k`, as shown in the following table (taken from the publication cited above):n123456789101112 .. 1617 .. 32k1993799686240498437383115249324921869186912481246623MersenneTwister generates random numbers in batches of 624 numbers at a time, so the caching and pipelining of modern systems is exploited.The generator is implemented to generate the output by using the fastest arithmetic operations only: 32-bit additions and bit operations (no division, no multiplication, no mod).These operations generate sequences of 32 random bits (

`int`'s).`long`'s are formed by concatenating two 32 bit`int`'s.`float`'s are formed by dividing the interval`[0.0,1.0]`into 2^{32}sub intervals, then randomly choosing one subinterval.`double`'s are formed by dividing the interval`[0.0,1.0]`into 2^{64}sub intervals, then randomly choosing one subinterval.- See Also:
`Random`

, Serialized Form

**Warning:**You cannot see the full API documentation of this class since the access to the DatMelt documentation for third-party Java classes is denied. Guests can only view jhplot Java API. To view the complete description of this class and its methods, please request the full DataMelt membership.

If you are already a full member, please login to the DataMelt member area before visiting this documentation.