Thread: Random integers (numbers) - help

You may want to use C++11's random number facilities: Pseudo-random number generation - cppreference.com
To be honest, it's a little more complicated than it needs to be, but it gets the job done.

Basically, what you do is create an engine (an engine creates random numbers), initialize it with a seed, and then create a distribution (takes numbers outputted from an engine and forces them into a statistical distribution, such as a uniform range) and then just repeatedly call the distribution to get your random numbers:

std::random_device rnd; // This is a random engine which will produce our seed.
std::default_random_engine engine(rnd()); // Create our random engine and initialize it with a unique seed.
std::uniform_int_distribution<int> dist(100000, 999999); // Create our distribution which will produce our random numbers. The parameters specify the range.
for (int i = 0; i < 5; i++)
std::cout << dist(engine); // Generate our random numbers by calling the distribution. It wants an engine from where to get its random numbers, so that's where our engine comes in.

This, as we know, introduces bias, and we also know that it can generate pretty poor results depending on the implementation of rand(). We don't even know how long before the numbers start to loop, especially when you do things like this!
When we have these C++11 facilities which guarantee specific properties, why wouldn't we use them? Plus it's less code.

I do understand some of your criticism. To me, it seems the OP was worried about the random numbers not being very random at all (very close to each other), and the numbers the OP mentioned seemed pretty typical of a poor std::rand() implementation. That's why I suggested the C++11 facilities. These guarantee much stronger randomness and even guarantee a statistical distribution, which cannot be said for std::rand, and randomless is precisely what the OP wanted. That is why I opposed your solution because it introduces bias.

But I agree that if we try to ensure that each generated number vary greatly in magnitude, then no matter what you do, you will enter selection bias as you say. But the criticism from me is that even so, we can a much better job thanks to C++11's random facilities. Even if we destroy the statistical distribution, we can still guarantee that we have quality generated random numbers and a large set of unique numbers before we loop around again. You cannot guarantee this with std::rand.

Originally Posted by whiteflags

I'm sorry I wrote code with rand().

I'll just stop doing that I guess, no matter how trivial the code is.

Dunno, it looks more trivial with the new random number facilities:

Code:

#include <random>
#include <ctime>
#include <iostream>

int main()
{
    std::mt19937 prng(static_cast<std::mt19937::result_type>(std::time(nullptr)));
    std::uniform_int_distribution<int> random(100000, 999999);
    for (int loop = 0; loop < 5; loop++) {
        std::cout << random(prng) << std::endl;
    }
}

Except that uh, it needs to be explained to the novice that the first line in main creates a pseudo-random number generator seeded based on current time, the second line creates a way to obtain the numbers within the given closed range with a uniform distribution (assuming that the PRNG has a uniform distribution), and then random(prng) connects the two to generate a pseudo-random number within the given range with a uniform distribution.

Oh, then if we change the cast to result_type to use Prelude's idea of hashing the bytes of the time_t obtained as described in using rand(), I guess it becomes a little less trivial.