# Mersenne Twister

The Mersenne Twister is a pseudorandom number generator (PRNG). It is by far the most widely used general-purpose PRNG.[1] Its name derives from the fact that its period length is chosen to be a Mersenne prime.

The Mersenne Twister was developed in 1997 by Makoto Matsumoto (ja) (松本 眞) and Takuji Nishimura (西村 拓士).[2] It was designed specifically to rectify most of the flaws found in older PRNGs. It was the first PRNG to provide fast generation of high-quality pseudorandom integers.

The most commonly used version of the Mersenne Twister algorithm is based on the Mersenne prime 219937−1. The standard implementation of that, MT19937, uses a 32-bit word length. There is another implementation that uses a 64-bit word length, MT19937-64; it generates a different sequence.

The Mersenne Twister is the default PRNG for the following software systems:

Microsoft Excel,[3] GAUSS,[4] GLib,[5] GNU Multiple Precision Arithmetic Library,[6] GNU Octave,[7] GNU Scientific Library,[8] gretl,[9] IDL,[10] Julia,[11] CMU Common Lisp,[12] Embeddable Common Lisp,[13] Steel Bank Common Lisp,[14] Maple,[15] MATLAB,[16] Free Pascal,[17] PHP,[18] Python,[19][20] R,[21] Ruby,[22] SageMath,[23] Scilab,[24] Stata.[25] It is also available in Apache Commons,[26] in standard C++ (since C++11),[27][28] and in Mathematica.[29] Add-on implementations are provided in many program libraries, including the Boost C++ Libraries,[30] the CUDA Library,[31] and the NAG Numerical Library.[32]

The Mersenne Twister is one of two PRNGs in SPSS: the other generator is kept only for compatibility with older programs, and the Mersenne Twister is stated to be "more reliable".[33] The Mersenne Twister is similarly one of the PRNGs in SAS: the other generators are older and deprecated.[34]

• Permissively-licensed and patent-free for all variants except CryptMT.
• Near-ubiquitous: included in many programming languages and libraries.
• Passes numerous tests for statistical randomness, including the Diehard tests and most, but not all, of the TestU01 tests.[35]
• A very long period of 219937 − 1. Note that while a long period is not a guarantee of quality in a random number generator, short periods, such as the 232 common in many older software packages, can be problematic.[36]
• k-distributed to 32-bit accuracy for every 1 ≤ k ≤ 623 (for a definition of k-distributed, see below)
• Implementations generally create random numbers faster than other methods. A study found that the Mersenne Twister creates 64-bit floating point random numbers approximately 20x faster than the hardware-implemented, processor-based RdRand instruction set.[37]

• Relatively large state buffer, of 2.5 KiB, unless the TinyMT variant (discussed below) is used.
• Mediocre throughput by modern standards,[38] unless the SFMT variant (discussed below) is used.
• Multiple instances that differ only in seed value (but not other parameters) are not generally appropriate for Monte-Carlo simulations that require independent random number generators, though there exists a method for choosing multiple sets of parameter values.[39][40]
• Can take a long time to start generating output that passes randomness tests, if the initial state is highly non-random—particularly if the initial state has many zeros. A consequence of this is that two instances of the generator, started with initial states that are almost the same, will usually output nearly the same sequence for many iterations, before eventually diverging. The 2002 update to the MT algorithm has improved initialization, so that beginning with such a state is very unlikely.[41]
• Is not cryptographically secure, unless the CryptMT variant (discussed below) is used. The reason is that observing a sufficient number of iterations (624 in the case of MT19937, since this is the size of the state vector from which future iterations are produced) allows one to predict all future iterations.

## Alternatives

An alternative generator, WELL ("Well Equidistributed Long-period Linear"), offers quicker recovery, and equal randomness, and nearly equal speed.[42] Marsaglia's xorshift generators and variants are the fastest in this class.[43]

## k-distribution

A pseudorandom sequence xi of w-bit integers of period P is said to be k-distributed to v-bit accuracy if the following holds.

Let truncv(x) denote the number formed by the leading v bits of x, and consider P of the k v-bit vectors
${\displaystyle ({\text{trunc}}_{v}(x_{i}),\,{\text{trunc}}_{v}(x_{i+1}),\,...,\,{\text{trunc}}_{v}(x_{i+k-1}))\quad (0\leq i.
Then each of the 2kv possible combinations of bits occurs the same number of times in a period, except for the all-zero combination that occurs once less often.

## Algorithmic detail

Visualisation of generation of pseudo-random 32-bit integers using a Mersenne Twister. The 'Extract number' section shows an example where integer 0 has already been output and the index is at integer 1. 'Generate numbers' is run when all integers have been output.

For a w-bit word length, the Mersenne Twister generates integers in the range [0, 2w−1].

The Mersenne Twister algorithm is based on a matrix linear recurrence over a finite binary field F2. The algorithm is a twisted generalised feedback shift register[44] (twisted GFSR, or TGFSR) of rational normal form (TGFSR(R)), with state bit reflection and tempering. The basic idea is to define a series ${\displaystyle x_{i}}$ through a simple recurrence relation, and then output numbers of the form ${\displaystyle x_{i}T}$, where ${\displaystyle T}$ is an invertible F2 matrix called a tempering matrix.

The general algorithm is characterized by the following quantities (some of these explanations make sense only after reading the rest of the algorithm):

• w: word size (in number of bits)
• n: degree of recurrence
• m: middle word, an offset used in the recurrence relation defining the series x, 1 ≤ m < n
• r: separation point of one word, or the number of bits of the lower bitmask, 0 ≤ rw - 1
• a: coefficients of the rational normal form twist matrix
• b, c: TGFSR(R) tempering bitmasks
• s, t: TGFSR(R) tempering bit shifts

with the restriction that 2nw − r − 1 is a Mersenne prime. This choice simplifies the primitivity test and k-distribution test that are needed in the parameter search.

The series x is defined as a series of w-bit quantities with the recurrence relation:

${\displaystyle x_{k+n}:=x_{k+m}\oplus \left(({x_{k}}^{u}\mid \mid {x_{k+1}}^{l})A\right)\qquad \qquad k=0,1,\ldots }$

where ${\displaystyle \mid \mid }$ denotes concatenation of bit vectors (with upper bits on the left), ${\displaystyle \oplus }$ the bitwise exclusive or (XOR), ${\displaystyle {x_{k}}^{u}}$ means the upper ${\displaystyle w-r}$ bits of ${\displaystyle x_{k}}$, and ${\displaystyle x_{k+1}^{l}}$ means the lower ${\displaystyle r}$ bits of ${\displaystyle x_{k+1}}$. The twist transformation A is defined in rational normal form as:

${\displaystyle A={\begin{pmatrix}0&I_{w-1}\\a_{w-1}&(a_{w-2},\ldots ,a_{0})\end{pmatrix}}}$

with In − 1 as the (n − 1) × (n − 1) identity matrix. The rational normal form has the benefit that multiplication by A can be efficiently expressed as: (remember that here matrix multiplication is being done in F2, and therefore bitwise XOR takes the place of addition)

${\displaystyle {\boldsymbol {x}}A={\begin{cases}{\boldsymbol {x}}\gg 1&x_{0}=0\\({\boldsymbol {x}}\gg 1)\oplus {\boldsymbol {a}}&x_{0}=1\end{cases}}}$

where x0 is the lowest order bit of x.

As like TGFSR(R), the Mersenne Twister is cascaded with a tempering transform to compensate for the reduced dimensionality of equidistribution (because of the choice of A being in the rational normal form). Note that this is equivalent to using the matrix A where A = T−1AT for T an invertible matrix, and therefore the analysis of characteristic polynomial mentioned below still holds.

As with A, we choose a tempering transform to be easily computable, and so do not actually construct T itself. The tempering is defined in the case of Mersenne Twister as

y := x ⊕ ((x >> u) & d)
y := y ⊕ ((y << s) & b)
y := y ⊕ ((y << t) & c)
z := y ⊕ (y >> l)

where x is the next value from the series, y a temporary intermediate value, z the value returned from the algorithm, with <<, >> as the bitwise left and right shifts, and & as the bitwise and. The first and last transforms are added in order to improve lower-bit equidistribution. From the property of TGFSR, ${\displaystyle s+t\geq \lfloor w/2\rfloor -1}$ is required to reach the upper bound of equidistribution for the upper bits.

The coefficients for MT19937 are:

• (w, n, m, r) = (32, 624, 397, 31)
• a = 9908B0DF16
• (u, d) = (11, FFFFFFFF16)
• (s, b) = (7, 9D2C568016)
• (t, c) = (15, EFC6000016)
• l = 18

Note that 32-bit implementations of the Mersenne Twister generally have d = FFFFFFFF16. As a result, the d is occasionally omitted from the algorithm description, since the bitwise and with d in that case has no effect.

The coefficients for MT19937-64 are:[45]

• (w, n, m, r) = (64, 312, 156, 31)
• a = B5026F5AA96619E916
• (u, d) = (29, 555555555555555516)
• (s, b) = (17, 71D67FFFEDA6000016)
• (t, c) = (37, FFF7EEE00000000016)
• l = 43

### Initialization

As should be apparent from the above description, the state needed for a Mersenne Twister implementation is an array of n values of w bits each. To initialize the array, a w-bit seed value is used to supply x0 through xn − 1 by setting x0 to the seed value and thereafter setting

xi = f × (xi−1 ⊕ (xi−1 >> (w−2))) + i

for i from 1 to n−1. The first value the algorithm then generates is based on xn, not on x0. The constant f forms another parameter to the generator, though not part of the algorithm proper. The value for f for MT19937 is 1812433253 and for MT19937-64 is 6364136223846793005.[45]

### Comparison with classical GFSR

In order to achieve the 2nw − r − 1 theoretical upper limit of the period in a TGFSR, φB(t) must be a primitive polynomial, φB(t) being the characteristic polynomial of

${\displaystyle B={\begin{pmatrix}0&I_{w}&\cdots &0&0\\\vdots &&&&\\I_{w}&\vdots &\ddots &\vdots &\vdots \\\vdots &&&&\\0&0&\cdots &I_{w}&0\\0&0&\cdots &0&I_{w-r}\\S&0&\cdots &0&0\end{pmatrix}}{\begin{matrix}\\\\\leftarrow m{\hbox{-th row}}\\\\\\\\\end{matrix}}}$

${\displaystyle S={\begin{pmatrix}0&I_{r}\\I_{w-r}&0\end{pmatrix}}A}$

The twist transformation improves the classical GFSR with the following key properties:

• The period reaches the theoretical upper limit 2nw − r − 1 (except if initialized with 0)
• Equidistribution in n dimensions (e.g. linear congruential generators can at best manage reasonable distribution in five dimensions)

### Pseudocode

The following pseudocode implements the general Mersenne Twister algorithm. The constants w, n, m, r, a, u, d, s, b, t, c, l, and f are as in the algorithm description above. It is assumed that int represents a type sufficient to hold values with w bits:

 // Create a length n array to store the state of the generator
int[0..n-1] MT
int index := n+1
const int lower_mask = (1 << r) - 1 // That is, the binary number of r 1's

// Initialize the generator from a seed
function seed_mt(int seed) {
index := n
MT[0] := seed
for i from 1 to (n - 1) { // loop over each element
MT[i] := lowest w bits of (f * (MT[i-1] xor (MT[i-1] >> (w-2))) + i)
}
}

// Extract a tempered value based on MT[index]
// calling twist() every n numbers
function extract_number() {
if index >= n {
if index > n {
error "Generator was never seeded"
// Alternatively, seed with constant value; 5489 is used in reference C code[46]
}
twist()
}

int y := MT[index]
y := y xor ((y >> u) and d)
y := y xor ((y << s) and b)
y := y xor ((y << t) and c)
y := y xor (y >> l)

index := index + 1
return lowest w bits of (y)
}

// Generate the next n values from the series x_i
function twist() {
for i from 0 to (n-1) {
int x := (MT[i] and upper_mask)
+ (MT[(i+1) mod n] and lower_mask)
int xA := x >> 1
if (x mod 2) != 0 { // lowest bit of x is 1
xA := xA xor a
}
MT[i] := MT[(i + m) mod n] xor xA
}
index := 0
}


## Variants

### CryptMT

CryptMT is a stream cipher and cryptographically secure pseudorandom number generator which uses Mersenne Twister internally.[47][48] It was developed by Saito and Matsumoto alongside Hagita Mariko and Matsuo Saito. It has been submitted to the eSTREAM project of the eCRYPT network.[47] Unlike Mersenne Twister or its other derivatives, CryptMT is patented.

### MTGP

MTGP is a variant of Mersenne Twister optimised for graphics processing units published by Mutsuo Saito and Makoto Matsumoto.[49] The basic linear recurrence operations are extended from MT and parameters are chosen to allow many threads to compute the recursion in parallel, while sharing their state space to reduce memory load. The paper claims improved equidistribution over MT and performance on a high specification GPU (Nvidia GTX260 with 192 cores) of 4.7 ms for 5×107 random 32-bit integers.

### SFMT

The SFMT (SIMD-oriented Fast Mersenne Twister) is a variant of Mersenne Twister, introduced in 2006,[50] designed to be fast when it runs on 128-bit SIMD.

Intel SSE2 and PowerPC AltiVec are supported by SFMT. It is also used for games with the Cell BE in the PlayStation 3.[52]

### TinyMT

TinyMT is a variant of Mersenne Twister, proposed by Saito and Matsumoto in 2011.[53] TinyMT uses just 127 bits of state space, a significant decrease compared to the original's 2.5 KiB of state. However, it has a period of 2127−1, far shorter than the original, so it is only recommended by the authors in cases where memory is at a premium.

## References

1. ^ E.g. Marsland S. (2011) Machine Learning (CRC Press), §4.1.1. Also see the section "Adoption in software systems".
2. ^ Matsumoto, M.; Nishimura, T. (1998). "Mersenne twister: a 623-dimensionally equidistributed uniform pseudo-random number generator" (PDF). ACM Transactions on Modeling and Computer Simulation. 8 (1): 3–30. doi:10.1145/272991.272995.
3. ^ Mélard, G. (2014), "On the accuracy of statistical procedures in Microsoft Excel 2010", Computational Statistics, 29 (5): 1095–1128, doi:10.1007/s00180-014-0482-5.
4. ^ GAUSS 14 Language Reference
5. ^ Random Numbers: GLib Reference Manual
6. ^ "Random Number Algorithms". GNU MP. Retrieved 2013-11-21.
7. ^ "16.3 Special Utility Matrices". GNU Octave. Built-in Function: rand
8. ^ "Random number environment variables". GNU Scientific Library. Retrieved 2013-11-24.
9. ^ "uniform". Gretl Function Reference.
10. ^ "RANDOMU (IDL Reference)". Exelis VIS Docs Center. Retrieved 2013-08-23.
11. ^ "Random Numbers". Julia Language Documentation—The Standard Library.
12. ^ "Design choices and extensions". CMUCL User's Manual. Retrieved 2014-02-03.
13. ^ "Random states". The ECL manual. Retrieved 2015-09-20.
14. ^ "Random Number Generation". SBCL User's Manual.
16. ^ "Random number generator algorithms". Documentation Center, MathWorks.
17. ^ "random". free pascal documentation. Retrieved 2013-11-28.
18. ^ "mt_rand — Generate a better random value". PHP Manual. Retrieved 2016-03-02.
19. ^ "9.6 random — Generate pseudo-random numbers". Python v2.6.8 documentation. Retrieved 2012-05-29.
20. ^ "8.6 random — Generate pseudo-random numbers". Python v3.2 documentation. Retrieved 2012-05-29.
21. ^ "Random Number Generators". CRAN Task View: Probability Distributions. Retrieved 2012-05-29.
22. ^ ""Random" class documentation". Ruby 1.9.3 documentation. Retrieved 2012-05-29.
23. ^ Probability Distributions — Sage Reference Manual v7.2: Probablity
24. ^ "grand - Random numbers". Scilab Help.
25. ^ New random-number generator—64-bit Mersenne Twister
26. ^ "Data Generation". Apache Commons Math User Guide.
27. ^ "Random Number Generation in C++11" (PDF). Standard C++ Foundation.
28. ^ "std::mersenne_twister_engine". Pseudo Random Number Generation. Retrieved 2012-09-25.
29. ^ [1] Mathematica Documentation
30. ^ "boost/random/mersenne_twister.hpp". Boost C++ Libraries. Retrieved 2012-05-29.
31. ^ "Host API Overview". CUDA Toolkit Documentation. Retrieved 2016-08-02.
32. ^ "G05 – Random Number Generators". NAG Library Chapter Introduction. Retrieved 2012-05-29.
33. ^ "Random Number Generators". IBM SPSS Statistics. Retrieved 2013-11-21.
34. ^ "Using Random-Number Functions". SAS Language Reference. Retrieved 2013-11-21.
35. ^ P. L'Ecuyer and R. Simard, "TestU01: "A C library for empirical testing of random number generators", ACM Transactions on Mathematical Software, 33, 4, Article 22 (August 2007).
36. ^ Note: 219937 is approximately 4.3 × 106001; this is many orders of magnitude larger than the estimated number of particles in the observable universe, which is 1087.
37. ^ Route, Matthew (August 10, 2017). "Radio-flaring Ultracool Dwarf Population Synthesis". The Astrophysical Journal. 845: 66. arXiv:. Bibcode:2017ApJ...845...66R. doi:10.3847/1538-4357/aa7ede.
38. ^ "SIMD-oriented Fast Mersenne Twister (SFMT): twice faster than Mersenne Twister". Japan Society for the Promotion of Science. Retrieved 27 March 2017.
39. ^ Makoto Matsumoto; Takuji Nishimura. "Dynamic Creation of Pseudorandom Number Generators" (PDF). Retrieved 19 July 2015.
40. ^ Hiroshi Haramoto; Makoto Matsumoto; Takuji Nishimura; François Panneton; Pierre L’Ecuyer. "Efficient Jump Ahead for F2-Linear Random Number Generators" (PDF). Retrieved 12 Nov 2015.
41. ^ "mt19937ar: Mersenne Twister with improved initialization". hiroshima-u.ac.jp. Retrieved 4 October 2015.
42. ^ P. L'Ecuyer, "Uniform Random Number Generators", International Encyclopedia of Statistical Science, Lovric, Miodrag (Ed.), Springer-Verlag, 2010.
43. ^
44. ^ Matsumoto, M.; Kurita, Y. (1992). "Twisted GFSR generators". ACM Transactions on Modeling and Computer Simulation. 2 (3): 179–194. doi:10.1145/146382.146383.
45. ^ a b "std::mersenne_twister_engine". Pseudo Random Number Generation. Retrieved 2015-07-20.
46. ^ Takuji Nishimura; Makoto Matsumoto. "A C-program for MT19937, with initialization improved 2002/1/26". Retrieved 20 July 2015.
47. ^ a b "CryptMt and Fubuki". eCRYPT. Retrieved 2017-11-12.
48. ^ Matsumoto, Makoto; Nishimura, Takuji; Hagita, Mariko; Saito, Mutsuo (2005). "Cryptographic Mersenne Twister and Fubuki Stream/Block Cipher" (PDF).
49. ^ Mutsuo Saito; Makoto Matsumoto (2010). "Variants of Mersenne Twister Suitable for Graphic Processors". arXiv: [cs.MS].
50. ^ "SIMD-oriented Fast Mersenne Twister (SFMT)". hiroshima-u.ac.jp. Retrieved 4 October 2015.
51. ^ "SFMT:Comparison of speed". hiroshima-u.ac.jp. Retrieved 4 October 2015.
52. ^ "PlayStation®3 License". scei.co.jp. Retrieved 4 October 2015.
53. ^ "Tiny Mersenne Twister (TinyMT)". hiroshima-u.ac.jp. Retrieved 4 October 2015.