Mersenne Twister Algorithm vs rand(): Generating Random Numbers

Random number generation is a crucial programming aspect, having utility in various applications. In C++, we have multiple methods to generate random numbers. However, the most notable ones are the Mersenne Twister algorithm (std::mt19937) and the conventional rand() function paired with srand(). This article will explore and compare these approaches to understand their differences, strengths, and appropriate use cases.

Some useful terms:

Period

The period of a random number generator refers to the length of the sequence of unique numbers it can produce before it starts repeating itself. A longer period is desirable as it allows for a larger number of unique values to be generated before the sequence repeats. Longer periods decrease the likelihood of observing repetitions in the generated sequence, enhancing its randomness for practical purposes.

Quality

Quality in random number generators refers to the statistical properties and randomness characteristics of the generated sequence. High-quality randomness means that the generated numbers exhibit properties such as uniform distribution, independence, and lack of patterns or biases. Quality randomness ensures that the generated sequence behaves statistically like true random numbers, meeting statistical tests for randomness.

Seed

A seed is a starting point used by pseudo-random number generators (PRNGs) to produce a sequence of seemingly random numbers. When you generate random numbers using functions like rand(), the generator requires an initial value, known as the seed, to start the sequence.

Importance of Seed

The seed’s importance lies in its ability to control the sequence of pseudo-random numbers generated by PRNGs, offering reproducibility and diversity in random number sequences for various applications.

Deterministic Behavior: With the same seed, a PRNG will generate the same sequence of random numbers every time. And different seeds lead to different sequences, providing an appearance of randomness.
Pseudo-Randomness: PRNGs generate pseudo – random numbers – they are deterministic and produce a sequence that appears random but is reproducible with the same seed.

Setting the Seed

In C++, you can set the seed using srand() function:

//
//  main.cpp
//  Random Number Generator Seed
//
//  Created by Himanshu on 09/01/24.
//

#include <iostream>
using namespace std;

int main() {
    // Setting seed using current time
    srand(time(0)); // 'time(0)' provides the current time as the seed

    // Generating random numbers using 'rand()'
    int randomNum = rand();
    
    cout<<randomNum<<endl;
    return 0;
}

Using srand(time(0)) with time(0) as the seed is a common practice. It uses the current time as the seed. This ensures a different sequence every time the program runs. It’s important to set the seed only once at the beginning of the program. Setting it multiple times frequently might lead to identical sequences due to the same time value being used.

Mersenne Twister Algorithm

The Mersenne Twister algorithm is a highly regarded pseudo-random number generator (PRNG) algorithm widely used in various programming languages. It was developed by Makoto Matsumoto and Takuji Nishimura in 1997. It utilizes a complex internal state and mathematical operations to generate seemingly random numbers.
It boasts an exceptionally long period of 2¹⁹⁹³⁷−1 and high-quality randomness, meaning it can generate a sequence of nearly 10⁶⁰⁰⁰ unique numbers before repeating. This algorithm offers robust control over the random number generation process, allowing setting seeds, utilizing various distribution functions, and managing states for different sequences.

Advantages of the Mersenne Twister Algorithm

Quality

Long Period: The sequence length before repeating is huge. The Mersenne Twister has an immensely long period. It produces sequences of random numbers up to 2¹⁹⁹³⁷−1, making it highly unlikely to repeat within practical usage.
High Quality: Statistical tests fail to detect significant deviations from true randomness, making it suitable for demanding tasks.
Efficiency: Despite its complexity, the algorithm is surprisingly efficient, making it a viable choice for resource-constrained environments.

Control and Flexibility

Mersenne Twister provides more control over the generation process, as opposed to limited control with conventional rand().
It provides various distribution functions (uniform_int_distribution, normal_distribution, etc.) for generating numbers within specific distributions or ranges.

In C++, the Mersenne Twister is available through the <random> library.

Code Implementation

//
//  main.cpp
//  Mersenne Twister Algorithm
//
//  Created by Himanshu on 09/01/24.
//

#include <iostream>
#include <random>
using namespace std;

void generateNumbers(int n) {
    mt19937 gen; // Mersenne Twister PRNG
    gen.seed(42); // Seed the PRNG with a value (i.e., 42)
    
    for (int i = 0; i < n; i++) {
        cout<<gen()<<endl; // Generating random numbers
    }
    
}

void generateNumbersinRange(int low, int high, int n) {
    mt19937 gen; // Mersenne Twister PRNG
    gen.seed(42); // Seed the PRNG with a value (i.e., 42)
    
    uniform_int_distribution<int> distrib(low, high); // Define the range
    
    for (int i = 0; i < n; i++) {
        cout<<distrib(gen)<<endl; // Generating random numbers
    }
    
}


int main() {
    
    int low = 10, high = 50, n = 5;
    
    // Generating random numbers
    cout<<"Random numbers:"<<endl;
    generateNumbers(n);

    // Generating random numbers within a range
    cout<<endl<<"Random numbers within a range ("<<low<<", "<<high<<"):"<<endl;
    generateNumbersinRange(low, high, n);
    
    return 0;
}

Output

Random numbers:
1608637542
3421126067
4083286876
787846414
3143890026

Random numbers within a range (10, 50):
48
38
24
17
30

rand() and srand()

Contrarily, the rand() function combined with srand() provides a simpler but less versatile approach. Here’s how they work:

srand(): Seeds the random number generator with a starting value, influencing the sequence of generated numbers.
rand(): Returns a random integer within a specific range.

It is essential to note that this approach offers lower-quality randomness, a shorter period, and limited control over the generated sequences. While suitable for basic use cases, these limitations can be problematic for practical applications such as simulations, games, and security-sensitive tasks.