Does stdlib's rand() always give the same sequence?

I quite like being able to generate the same set of pseudo-random data repeatedly, especially with tweaking experimental code. Through开发者_如何转开发 observation I would say that rand() seems to give the same sequence of numbers each time*.

Is it guaranteed to do this for repeated executions on the same machine / for different machines / for different architectures?

*For the same seed obviously.

Yes, given the same environment for the program. From the C standard §7.20.2.2/2,

The srand function uses the argument as a seed for a new sequence of pseudo-random numbers to be returned by subsequent calls to rand. If srand is then called with the same seed value, the sequence of pseudo-random numbers shall be repeated. If rand is called before any calls to srand have been made, the same sequence shall be generated as when srand is first called with a seed value of 1.

Of course, this assumes it is using the same implementation detail (i.e. same machine, same library at the same execution period). The C standard does not mandate a standard random number generating algorithm, thus, if you run the program with a different C standard library, one may get a different random number sequence.

See the question Consistent pseudo-random numbers across platforms if you need a portable and guaranteed random number sequence with a given seed.

It is guaranteed to give the same sequence for the same seed passed to srand() - but only for the duration of a single execution of the program. In general, if an implementation has a choice in behaviour, there is no specific requirement for that choice to remain the same across subsequent executions.

It would be conforming for an implementation to pick a "master seed" at each program startup, and use that to perturb the pseudo-random number generator in a way that is different each time the program starts.

If you wish for more determinism, you should implement a PRNG with specific parameters in your program.

No.

The C standard says:

If srand is then called with the same seed value, the sequence of pseudo-random numbers shall be repeated.

But nowhere does it say what the sequence of pseudo-random numbers actually is - so it differs across implementations.

The only guarantee made is that rand() will give the same sequence of numbers for a given seed for a given implementation. There's no guarantee that the sequence will be the same across different machines or different architectures - and it almost certainly won't be.

If you need to use the exact same set of pseudo-random numbers for experimental purposes, one thing you could do is to use srand to generate a long sequence of random numbers and write them to a file/database. Then, write a portable "random number generator" function that returns values sequentially from that file. That way, you can be assured that you are using the same input data regardless of the platform, srand implementation, or seed value.

When switching to a different machine/runtime/whatever you might be out of luck. There is another possible choice the drand48 family of functions. These are normalized to use the same algorithm on all machines.

If you are in a UNIX/Linux enviroment you can see the drand48() and srand48() at your man pages if you are not you can see online manuals for the C Language. The prototypes can be found at /usr/include/stdlib.h . The first one use the Linear Congruential Method that is frequently used in Simulations.

If you provide the same seed to srand48() i.e. srand48(2) and then put the dran48() in a for loop then the sequence will be the same every time. i.e.

include stdio.h
include stdlib.h
double drand48();
int main(void){
    int i;
    double rn;
    srand48(2);
    for(i=0; i<10; i++){
        randNum = drand48();
        printf("%.6l\n", randNum);
        return 0;
}