Use of random in C++ - c++

Question

Are these pieces of code equivalent in terms of "randomness" ?
1)
std::vector<int> counts(20);
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 19);
for (int i = 0; i < 10000; ++i) {
++counts[dis(gen)];
}
2)
std::vector<int> counts(20);
std::random_device rd;
std::mt19937 gen(rd());
for (int i = 0; i < 10000; ++i) {
std::uniform_int_distribution<> dis(0, 19);
++counts[dis(gen)];
}
3)
std::vector<int> counts(20);
std::random_device rd;
for (int i = 0; i < 10000; ++i) {
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 19);
++counts[dis(gen)];
}
4)
std::vector<int> counts(20);
for (int i = 0; i < 10000; ++i) {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 19);
++counts[dis(gen)];
}
In the documentation of std::random_device, it is says that multiple std::random_device object may generate the same number sequence so the code 4 is bad, isn't it ?
And for the other codes ?
If I need to generate random values for multiple stuffs unrelated, must I need to create differents generators or can I keep the same ? :
1)
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> disInt(0, 10);
std::uniform_float_distribution<> disFloat(0, 1.0f);
// Use for one stuff
disInt(gen);
// Use same gen for another unrelated stuff
disFloat(gen);
2)
std::random_device rd1, rd2;
std::mt19937 gen1(rd1()), gen2(rd2());
std::uniform_int_distribution<> disInt(0, 10);
// Use for one stuff
disInt(gen1);
// Use another gen for another unrelated stuff
disFloat(gen2);

Answer 1

The point of the random generator is to hold the state of the algorithm, in order to produce repeatable pseudorandom sequences of numbers based on a specific random seed.
The point of the random device is to provide a random seed for the random generator.
If you try seeding a new generator for every random value, you are no longer exercising the randomness provided by the random generator's algorithm. Instead, you are biasing the generator to rely on the randomness of the random device itself.
For this reason, examples #3 and #4 are not advisable.
The correct way to generate a random sequence is example #1:
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dis(0, 19);
for (int i = 0; i < 10000; ++i) {
int foo = dis(gen);
}
Example #2 is also correct, but it's kinda pointless to construct the uniform_int_distribution inside the loop. Of course, with compiler optimizations, it doesn't really hurt and there may be times where it's preferable to keep the distribution near where it used, for the sake of clarity.
If I need to generate random values for multiple stuffs unrelated, must I need to create differents generators or can I keep the same ?
You are welcome to use multiple generators for unrelated random sequences if you want to -- that is actually one of their major draw-cards. You retain the randomness guarantees of the pseudorandom algorithm for a particular sequence if its generator is not used when generating other sequences (most notably when extraction of numbers from the sequences are interleaved).
This is also useful for reproducibility: For example, when you actually have a specific seed value (instead of pulling it from a random device), using that seed for one particular sequence gives repeatable results, regardless of any other sequences being used at the same time.
One other major benefit is that by using separate generators you get the same thread-safety guarantees that apply to other objects. In other words, that means if you want to generate multiple pseudorandom sequences concurrently, you can do so without locks provided each thread operates on a separate generator.

Answer 2

As you correctly mentioned, std::random_device may always returns the same sequence. This happens in particular on MinGW, where the behaviour is completely deterministic across multiple runs of any program using std::random_device.
The behaviour of std::mt19937 and std::uniform_int_distribution is deterministic given their inputs. As a result, on MinGW, the randomness of all four snippets is equally bad, each of them will always return the same sequence (albeit it will probably be a different sequence for each snippet).
If you're worried about that, use std::chrono::high_resolution_clock to initialise std::mt19937, either in lieu of, or in conjunction with std::random_device.

Answer 3

random_device usage
The first two loops are completely equivalent because the uniform_int_distribution type is stateless (as are all such distributions). The second might be slightly slower: I see one superfluous stack store with GCC or Clang at -O3.
For common random_device implementations based on something like /dev/random, the latter two loops are also equivalent: the random_device is merely a handle and accesses the same entropy pool regardless of intervening destruction and reinitialization. An implementation could, however, retain bits not needed for one seed and use them for another. This is of course harder to test, since the state is deliberately non-reproducible. (majk is correct that a deterministic implementation of random_device makes the last loop produce only a single value.)
Repeated random_device usage
The former two are generally to be preferred: generating many random numbers from a single seed is the point of a PRNG, and forsaking that is likely to quickly drain the entropy pool in common installations. Depending on the implementation, your process might block (extensively) waiting for more entropy or might fall back on an OS-supplied PRNG. In either case, you deprive other processes of true entropy.
Using the mt19937 here doesn’t add much anyway: the random_device can already be used directly with the uniform_int_distribution with the minor disadvantage of (rarely) polling the random_device multiple times to obtain a uniform distribution over 20 values (since that’s not a power of 2).
Different streams
It’s perfectly reasonable to use one generator for various distributions (interleaved or no). There are cases where you would want to use separate ones, usually with multiple threads or where you want to control seeding. As an example of the latter, you might define some sort of procedural content generation in terms of a PRNG with a particular seed. If other random numbers are (or in a future version come to be) needed during the generation, using a separate generator for them allows the content generator to function identically for any such additional random number usage.