I need to generate random numbers within a specified interval, [max;min].

Also, the random numbers should be uniformly distributed over the interval, not located to a 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
```

From answers below: OK, RAND_MAX is 32767. I am on C++ Windows platform. Is there any other method to generate random numbers with a uniform distribution?

`rand`

is a bad ideaMost of the answers you got here make use of the `rand`

function and the modulus operator. That method may not generate numbers uniformly (it depends on the range and the value of `RAND_MAX`

), and is therefore discouraged.

With C++11 multiple other options have risen. One of which fits your requirements, for generating a random number in a range, pretty nicely: `std::uniform_int_distribution`

. Here's an example:

```
const int range_from = 0;
const int range_to = 10;
std::random_device rand_dev;
std::mt19937 generator(rand_dev());
std::uniform_int_distribution<int> distr(range_from, range_to);
std::cout << distr(generator) << '\n';
```

And here's the running example.

The `<random>`

header offers innumerable other random number generators with different kind of distributions including Bernoulli, Poisson and normal.

The standard provides `std::shuffle`

, which can be used as follows:

```
std::vector<int> vec = {4, 8, 15, 16, 23, 42};
std::random_device random_dev;
std::mt19937 generator(random_dev());
std::shuffle(vec.begin(), vec.end(), generator);
```

The algorithm will reorder the elements randomly, with a linear complexity.

Another alternative, in case you don't have access to a C++11+ compiler, is to use Boost.Random. Its interface is very similar to the C++11 one.

**[edit]** **Warning: Do not use rand() for statistics, simulation, cryptography or anything serious.**

It's good enough to make numbers *look* random for a typical human in a hurry, no more.

See @Jefffrey's reply for better options, or this answer for crypto-secure random numbers.

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 in 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.

Licensed under: CC-BY-SA with attribution

Not affiliated with: Stack Overflow