boost::random 从不同状态的相同种子中过于频繁地生成相同的值

Question

Problem description

Sometimes I get the same random number from a uniform distribution using a Mersenne Twister engine even I properly used the engine and iterated it. I know that the number of possible states of the engine is finite and number of possible generated values is also finite, but this is not the case now.

Using boost's implementation, 1e6 number of uniformly distributed random values are generated on the range [0; 1e7). That means that there way more possible values than required number of random values. However, I get quite often the same values, sometimes more than 100 times in this range. How is it possible?

Code

A simple code is provided to reproduce the situation. On both platforms I get the same problem:

• MSVS 2019 with boost-random:x64-windows 1.71.0, and
• g++ (Ubuntu 5.4.0-6ubuntu1~16.04.12) 5.4.0 20160609 with libboost-dev 1.58.0.1ubuntu1

#include <iostream>
#include <chrono>

#include <boost/random/mersenne_twister.hpp>          // random number generator
#include <boost/random/uniform_real_distribution.hpp> // uniform distribution generator
using namespace std;

int main()
{
    size_t seed = static_cast<int> (std::chrono::system_clock::now().time_since_epoch().count());
    cout << "seed = " << seed << endl;
    
    boost::random::mt19937 engine(seed);                         // the random number generator engine
    boost::random::uniform_real_distribution<double> u(0, 1e7);  // uniformly distributed double values on the range [0; 1e7)
    cout.precision(20);
    vector<double> history;                                      // stores the generated values for comparison
    for (size_t i = 0; i < 1e6; ++i)
    {
        history.push_back(u(engine));
        for (size_t j = 0; j < i; ++j)
            if (history[i] == history[j])
                cout << "Equal values ("<< history[i] <<") at ID = " << i << " and " << j << endl;
    }
}

Question

Is there a bug in the code that produces the same values? Or is it a bug in boost?

For my task it is important to generate numbers with uniform distribution. Finding identical values is one of the easiest tests but there are many more and I am sure I don't want to do quality analysis on a well-known library like Boost. I didn't want to use the standard library, because it is not guaranteed that two different compilers will give the same sequence for the same seed values, but it was a requirement for the task. What kind of a solution can you suggest?

Note

A strange behavior can be seen if one compares the generated values with the one std::random generates . Example for values from random::boost for seed 4561565448989 is

1755586.0406719148159
3354420.976247638464   <--
3630764.0071026980877
3488445.2889673411846  <--
7920481.4555123448372
8773544.1024415194988  <--

while standard library generates

3354420.9766563926823  <--
3488445.2898126943037  <--
8773544.1042856499553  <--
...

That is, every second generated value in the boost's sequence is very close to a corresponding value in the standard library's implementation. When two values in the boost-sequence are equal, the values in the standard-library-sequence are not equal, but close to each other. The similarity holds for MSVS and g++ compilers too, which have the right to have different implementation for Mersenne Twister and distributions.

---

Update

Poor seed?

It was suggested that maybe it is the poor seed value that causes this phenomenon because with a size_t only 2^64 number of different initial states can be generated. Even worse, our life is short and the possible time values are even less. Although this is true, it doesn't explain why the same numbers are generated many times from different states. After all, the engine is initiated only once so I chose one state from a 64bit-subset, that is a subset of the all possible states.

Poor seed could be a reason if I initiated the engine multiple times and if I found identical values in the sequences of the differently (but not differently enough) initiated engines.

It is the distribution generator

If the standard MT engine is used, but boost's distribution, the problem persists. But if the engine is the one from boost and the distribution is standard, the problem disappears. The problem is, as Peter pointed out , that the uniform distribution is platform depend for which I use boost.

Some statistics

I made a little analysis on the distributions. Using the same boost::random::mt19937 engine , but either boost's or std's uniform_real_distribution<double> u(0, 1) , I generated value pairs and investigated their difference and plotted their correlation integral I ( x ), ie the probability that two values are closer than x . As U [0; 1) is a 1D domain, I ( x ) starts as a linear function for small x values (and tends to 1). The results are shown in the figure below. The figure tells that the distributions from the boost implementation not only have a bias but there are only 4 possible distance values, whereas it is known that double s are more dense, and std indeed produces a larger spectrum of the distance values.

bug or not a bug? a deleted answer

An already deleted answer suggested to improve the seed values, but so far it turned out it wasn't the source of the issue. Since then I posted this issue on boost's github too and it still not clear where the problem lies. It can be a bug in boost, but even in that case this SO source can help others to identify issues in their distribution generators.

Answer 1

This is not a bug in Boost. The problem is due to the limited resolution provided by the older, 32-bit MersenneTwister. The steps you are seeing on the cumulative distribution are equal to $1/2^{32} \\approx 10^{-10}$. I was made aware of a costly, real-world failure of a simulation which resulted from this a couple of years ago. The solution is to use an RNG which is capable of producing full-precision doubles, while passing all statistical test suites, such as MersenneTwister64 or MIXMAX.

Answer 2

There is no bug in Boost.

The random engine mt19937 (both in Boost and in the C++ standard library) has a state of 19968 bits, so that there are 2^19968 different variations on that state. Giving that engine a seed of only 32 or 64 bits (depending on the size of int ) will produce a severely limited selection of these variations.

Moreover, seeding the engine with timestamps (or with sequential numbers or linearly related numbers) is generally not appropriate for Mersenne Twister or other PRNGs, as doing so can cause correlated random number sequences (especially in view of the fact that Mersenne Twister is a linear PRNG).

See also:

• " Developing a seed_seq Alternative "

• " Simple Portable C++ Seed Entropy "

• How to succinctly, portably, and thoroughly seed the mt19937 PRNG? (more specifically, this answer ).

• " Seed Generation for Noncryptographic PRNGs ".

I didn't want to use the standard library, because it is not guaranteed that two different compilers will give the same sequence for the same seed values, but it was a requirement for the task.

In the C++ standard library, random engines (such as std::mt19937 ) are guaranteed to have the same output for the same input on all implementations of the C++ standard library. This is in contrast to random distributions (such as std::uniform_int_distribution , which use algorithms that may vary between implementations of the C++ standard library.

See also Random number generator performance varies between platforms and Random output different between implementations .