Generate Random numbers uniformly over entire range

Question

I need to generate random numbers with in specified interval [max,min]

Also the random numbers should be uniformly distributed over interval, not located to particular point

Currenly I am generating as:

for(int i=0;i<6;i++)
{
DWORD random= rand()%(max-min+1) + min;
}

From my tests random numbers are generated around one point only

Example
min= 3604607;
max= 7654607;

Random numbers generated:

3631594
3609293
3630000
3628441
3636376
3621404

Edit (added from answers below): Ok RAND_MAX is 32767. I am on C++ windows platform.. Is there any other method to generate random numbers with uniform distribution?

Answer 1

If you want numbers to be uniformly distributed over the range, you should break your range up into a number of equal sections that represent the number of points you need. Then get a random number with a min/max for each section.

As another note, you should probably not use rand() as it's not very good at actually generating random numbers. I don't know what platform you're running on, but there is probably a better function you can call like random().

Answer 2

Check what RAND_MAX is on your system -- I'm guessing it is only 16 bits, and your range is too big for it.

Beyond that see this discussion on: Generating Random Integers within a Desired Range and the notes on using (or not) the C rand() function.

Answer 3

If you are concerned about randomness and not about speed, you should use a secure random number generation method. There are several ways to do this... the easiest one being to use OpenSSL's Random Number Generator.

You can also write your own using an encryption algorithm (like AES). By picking a seed and an IV and then continuously re-encrypting the output of the encryption function. Using openssl is easier, but less manly.

Answer 4

You should look at RAND_MAX for your particular compiler/environment. I think you would see these results if rand() is producing a random 16-bit number. (you seem to be assuming it will be a 32-bit number).

I can't promise this is the answer, but please post your value of RAND_MAX, and a little more detail on your environment.

Answer 5

Ok RAND_MAX is 32767. I am on C++ windows platform.. Is there any other method to generate random numbers with uniform distribution?

Answer 6

By their nature, a small sample of random numbers doesn't have to be uniformly distributed. They're random, after all. I agree that if a random number generator is generating numbers that consistently appear to be grouped, then there is probably something wrong with it.

But keep in mind that randomness isn't necessarily uniform.

Edit: I added "small sample" to clarify.

Answer 7

If RAND_MAX is 32767, you can double the number of bits easily.

int BigRand()
{
    assert(INT_MAX/(RAND_MAX+1) > RAND_MAX);
    return rand() * (RAND_MAX+1) + rand();
}

Answer 8

I just found on net

This should work

DWORD random = ((min) + rand()/(RAND_MAX + 1.0) * ((max) - (min) + 1));

Answer 9

Solution given by man 3 rand for a number between 1 and 10 inclusive:

j = 1 + (int) (10.0 * (rand() / (RAND_MAX + 1.0)));

In your case, it would be:

j = min + (int) ((max-min+1) * (rand() / (RAND_MAX + 1.0)));

Of course this is not perfect randomness or uniformity as some other messages are pointing out, but this is enough for most cases.

Answer 10

Generally, the high bits show a better distribution than the low bits, so the recommended way to generate random numbers of a range for simple purposes is:

((double) rand() / (RAND_MAX+1)) * (max-min+1) + min

Note: make sure RAND_MAX+1 does not overflow! (Thanks Demi)

the division generates a random number from the interval [0, 1), "stretch" this to the required range. Only when max-min+1 gets close to RAND_MAX you need a "BigRand()" function like posted by Mark Ransom.

This also avoids some slicing problems due to the modulo, which can worsen your numbers even more.

---

The built-in random number generator isn't guaranteed to have a the quality required for statistical simulations. It is ok for numbers to "look random" to a human, but for a serious application, you should take something better - or at least check its properties (uniform distribution is usually good, but values tend to correlate, and the sequence is deterministic.) Knuth has an excellent (if hard to read) treatise on random number generators, and I recently found LFSR to be excellent and darn simple to implement, given its properties are ok for you.

If you want more information, please describe your application, and I/we can dig up some more concrete implementations.

Answer 11

If you are able to use boost, I have had good luck with their random library.

uniform_int should do what you want.