C++ Program To Implement Park Miller Random Number Generation Algorithm

Various software programs, such as computer models, gaming applications, cryptographic systems, statistical analysis tools, and others, rely on the capability to produce random numbers. Genuine random numbers are beyond the reach of computers, which resort to mathematical algorithms to generate pseudo-random numbers instead.

The Park-Miller algorithm, introduced in 1988 by Stephen Park and Keith Miller, remains a popular technique for generating pseudo-random numbers within computer software. Despite being more than three decades old, this method is still straightforward to implement and reliably efficient.

Initially, we choose a random value known as the 'seed' value. This seed value can be any number selected without a specific pattern and is crucial for kickstarting the random number generation process. The Park-Miller algorithm then computes the subsequent random number based on this initial seed and iteratively utilizes each generated number as a new seed for the next calculation.

Here is the formula:

next_random_number = (16807 * current_seed) % 2^31 - 1

In the equation, 16807 and 2^31 - 1 (equivalent to 2147483647) represent fixed prime figures. To illustrate, let's consider a scenario:

Seed = 5

Next random number = (16807 * 5) % 2147483647

= 1043618065

Now, using 1043618065 as the initial seed, we can generate the subsequent number in the sequence. By iterating this process, we observe a visually appealing random pattern, despite the numbers being considered pseudo-random in nature.

By implementing this straightforward algorithm, we can generate a series of aesthetically pseudo-random numbers within our C++ software. The unpredictability of the sequence enhances through the alteration of seed values, enabling versatile utilization in various scenarios such as simulations, gaming, quality assurance, sampling, and more. Despite its sophistication, the implementation retains its simplicity, effectiveness, and compatibility across different operating systems. Consequently, the Park-Miller algorithm stands out as a favored option among contemporary C++ programmers.

Algorithm with proper steps:

Select a Starting Number:

First and foremost, an integer needs to be chosen as the seed value. This seed can be any number selected at random. A popular option is to simply begin with seed = 1.

1. Set Up Variables:

Create a variable named 'seed' and assign it the seed value selected in step 1. Additionally, establish a variable 'next_random' to hold the upcoming randomly generated number.

1. Outline the Generator Function:

Afterward, we require a function that computes and provides the subsequent random number upon each invocation. This function will be named getnextrandom_number.

1. Implement the Formula:

Utilize the Park-Miller formula within the function.

next_random = (16807 * seed) % 2147483647

It produces a random whole number ranging from 0 to 2147483647 based on the seed provided earlier.

1. Refresh the Seed:

Now, substitute the previous seed with the subsequent random number that was computed earlier.

Set the variable "seed" to the value generated by the function "next_random".

1. Provide the output:

Finally, retrieve the next random value from the function to incorporate it into our program.

Invoke the Function:

Invoke the getnextrandom_number function within a loop or as needed to continuously retrieve additional random numbers.

So, in 7 simple steps, we can produce a well-ordered series of random numbers utilizing this dependable and proven algorithm.

Example:

Let's consider a C++ code example that demonstrates the implementation of the Park-Miller Random Number Generation Algorithm.

#include <iostream>

class ParkMiller {
private:
    long seed;

public:
    ParkMiller(long seed) : seed(seed) {}

    // Generate a pseudo-random number using the Park-Miller algorithm
    long generateRandomNumber() {
        const long a = 16807;   // Multiplier
        const long m = 2147483647;  // Modulus
        const long q = m / a;
        const long r = m % a;

        long temp = a * (seed % q) - r * (seed / q);

        if (temp > 0) {
            seed = temp;
        } else {
            seed = temp + m;
        }

        return seed;
    }
};

int main() {
    long seed = 1234;  // You can use any seed value

    ParkMiller rng(seed);

    // Generate and print 10 random numbers
    std::cout << "Park-Miller Random Numbers:" << std::endl;
    for (int i = 0; i < 10; ++i) {
        std::cout << rng.generateRandomNumber() << std::endl;
    }

    return 0;
}

Output:

Park-Miller Random Numbers:
165394961
1229862357
2064994670
622466744
51635271
1328980414
1729261113
2098655378
1808216131
404005600