# Class MersenneTwisterRNG

java.lang.Object
java.util.Random
org.uncommons.maths.random.MersenneTwisterRNG

All Implemented Interfaces:
  `Serializable, RandomGenerator, RepeatableRNG`

public class MersenneTwisterRNG extends Random implements RepeatableRNG

Random number generator based on the Mersenne Twister algorithm developed by Makoto Matsumoto and Takuji Nishimura.

This is a very fast random number generator with good statistical properties (it passes the full DIEHARD suite). This is the best RNG for most experiments. If a non-linear generator is required, use the slower `AESCounterRNG` RNG.

This PRNG is deterministic, which can be advantageous for testing purposes since the output is repeatable. If multiple instances of this class are created with the same seed they will all have identical output.

This code is translated from the original C version and assumes that we will always seed from an array of bytes. I don't pretend to know the meanings of the magic numbers or how it works, it just does.

NOTE: Because instances of this class require 128-bit seeds, it is not possible to seed this RNG using the `Random.setSeed(long)` method inherited from `Random`. Calls to this method will have no effect. Instead the seed must be set by a constructor.

See Also:
  - Serialized Form

## Nested Class Summary

### Nested classes/interfaces inherited from interface RandomGenerator

`RandomGenerator.ArbitrarilyJumpableGenerator, RandomGenerator.JumpableGenerator, RandomGenerator.LeapableGenerator, RandomGenerator.SplittableGenerator, RandomGenerator.StreamableGenerator`

## Constructor Summary

Constructors
Constructor
Description
`MersenneTwisterRNG()`
Creates a new RNG and seeds it using the default seeding strategy.
`MersenneTwisterRNG(byte[] seed)`
Creates an RNG and seeds it with the specified seed data.
`MersenneTwisterRNG(SeedGenerator seedGenerator)`
Seed the RNG using the provided seed generation strategy.

## Method Summary

Modifier and Type
Method
Description
`byte[]`
`getSeed()`
`protected final int`
`next(int bits)`

### Methods inherited from class Random

`doubles, doubles, doubles, doubles, from, ints, ints, ints, ints, longs, longs, longs, longs, nextBoolean, nextBytes, nextDouble, nextFloat, nextGaussian, nextInt, nextInt, nextLong, setSeed`

### Methods inherited from class Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Methods inherited from interface RandomGenerator

`equiDoubles, isDeprecated, nextDouble, nextDouble, nextExponential, nextFloat, nextFloat, nextGaussian, nextInt, nextLong, nextLong`

## Constructor Details

### MersenneTwisterRNG

public MersenneTwisterRNG()
Creates a new RNG and seeds it using the default seeding strategy.

### MersenneTwisterRNG

public MersenneTwisterRNG(SeedGenerator seedGenerator) throws SeedException
Seed the RNG using the provided seed generation strategy.

Parameters:
  `seedGenerator` - The seed generation strategy that will provide the seed value for this RNG.
Throws:
  `SeedException` - If there is a problem generating a seed.

### MersenneTwisterRNG

public MersenneTwisterRNG(byte[] seed)
Creates an RNG and seeds it with the specified seed data.

Parameters:
  `seed` - The seed data used to initialise the RNG.

## Method Details

### getSeed

public byte[] getSeed()

Specified by:
  `getSeed` in interface `RepeatableRNG`
Returns:
  The seed data used to initialise this pseudo-random number generator.

### next

protected final int next(int bits)

Overrides:
  `next` in class `Random`