Search results
Results from the WOW.Com Content Network
All in all, C++ programmers should not use std::rand() anymore, not because its bad, but because the current standard provides better alternatives that are more straight forward and reliable. Hopefully, many of you find this helpful, especially those of you who recently web searched generating random numbers in c++!
The canonical paper on this topic would be N3551, Random Number Generation in C++11. To see why using rand() can be problematic see the rand() Considered Harmful presentation material by Stephan T. Lavavej given during the GoingNative 2013 event. The slides are in the comments but here is a direct link.
This answer does not focus on the randomness but on the arithmetic order. To get a number within a range, usually we can do it like this: // the range is between [aMin, aMax] double f = (double)rand() / RAND_MAX; double result = aMin + f * (aMax - aMin); However, there is a possibility that (aMax - aMin) overflows.
The modulus operator % n produces [0,n) - 0,..n-1. When you add a value to that result, you're adding the same value to both ends of the ranges: Now, if n is 6, as it in in your case, your output will be [0,6) Now what you want is [6,13) Subtract 6 from that: Second, there is the matter of using rand ().
int random = rand(); return random; // To get a unique sequence the random number generator should only be. // seeded once during the life of the application. // As long as you don't try and start the application mulitple times a second. // you can use time() to get a ever changing seed point that only repeats every.
A typical way to generate pseudo-random numbers in a determined range using rand is to use the modulo of the returned value by the range span and add the initial value of the range: ( value % 100 ) is in the range 0 to 99. ( value % 100 + 1 ) is in the range 1 to 100. ( value % 30 + 1985 ) is in the range 1985 to 2014.
If you use rand (), you will basically have the same result after generating your random number. So even after using srand (), it will be easy to predict the number generated if someone can guess the seed you use. This is because the function rand () uses a specific algorithm to produce such numbers.
Because of this, RAND_MAX + 1 exhibits undefined (overflow) behavior, and becomes INT_MIN. While your initial statement was dividing (random # between 0 and INT_MAX)/ (INT_MAX) and generating a value 0 <= r < 1, now it's dividing (random # between 0 and INT_MAX)/ (INT_MIN), generating a value -1 < r <= 0. In order to generate a random number 1 ...
The function rand_r () is supplied with a pointer to an unsigned int, to be used as state. This is a very small amount of state, so this function will be a weak pseudo-random generator. Try drand48_r (3) instead. The emphasized part of the above is probably the reason why all your threads get the same number.
rand and srand are usually implemented as a simple LCG, you can easily write your own (it's few lines of code) without looking for the sources of rand and srand. Notice that, if you need random numbers for "serious" purposes (e.g. cryptography), there are much better RNGs than LCG.