Init random numbers with time?

[Markus Dehmann]

According to several C++ tutorials, calling srand like this to
initialize the random number generator seems to be standard:

srand((unsigned )time(0));

But it leads to the same random number sequence on every program call
if the program is called several times in a second! Isn't there a
better method to seed the random numbers? Probably based on
milliseconds instead of seconds? And integrating the process ID or
current amount of free memory or whatever? Is there a C++ library that
does it right?

Here is the program that outputs 3 different random numbers on a
../a.out call, but two identical sequences if called in a row like:
../a.out; ./a.out

#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;

int main(){
srand((unsigned )time(0));
for(unsigned i=0; i<3; ++i){
cout << rand() << endl;
}
cout << endl;
return EXIT_SUCCESS;
}

Thanks!
Markus

[Jeff Dege]

On Mon, 04 Dec 2006 21:43:37 -0800, Markus Dehmann wrote:

According to several C++ tutorials, calling srand like this to
initialize the random number generator seems to be standard:

srand((unsigned )time(0));

But it leads to the same random number sequence on every program call
if the program is called several times in a second! Isn't there a
better method to seed the random numbers?

Yes, if you want different behavior on every run. Though you may prefer
identical behavior on every run for certain phases of testing.

Probably based on
milliseconds instead of seconds?

There isn't a standard function that's guaranteed to return milliseconds.
There's nothing in the standard that time_t can't be in milliseconds, or
that it must be. You're dealing with inherently OS-specific functionality.

And integrating the process ID or
current amount of free memory or whatever?

Is your idea that by adding PID you would get distinct sequences when the
program is run more than once in the same second? That'd probably work,
except that getting the PID is also a non-portable construct. You might
as well just used the fine-grained OS-specific time function. I know of
at least one OS in which the time function is guaranteed to return unique
values on every call. And there are OSes that don't have PIDs. So your
proposal would be unnecessary on some, and impossible on others.

Is there a C++ library that
does it right?

"Right" is a matter of opinion. IMO, a pseudo-random generator that can't
be configured to produce repeatable sequences when desired is broken. In
other words, if you want to initialize the seed from the system clock, do
so.

Here is the program that outputs 3 different random numbers on a
./a.out call, but two identical sequences if called in a row like:
./a.out; ./a.out

[...]

--
"The national budget must be balanced. The public debt must be
reduced; the arrogance of the authorities must be moderated and
controlled. Payments to foreign governments must be reduced,
if the nation doesn't want to go bankrupt. People must again
learn to work, instead of living on public assistance."
- Marcus Tullius Cicero

[Steve Pope]

Markus Dehmann <ma************ @gmail.comwrote :

>According to several C++ tutorials, calling srand like this to
initialize the random number generator seems to be standard:

srand((unsigned )time(0));

But it leads to the same random number sequence on every program call
if the program is called several times in a second! Isn't there a
better method to seed the random numbers? Probably based on
milliseconds instead of seconds?

One approach is to use the process id as part of the seed. One
standard/portable way to do this is to use an integer hash function
of the string returned by tmpnam().

Steve

[David Harmon]

On 4 Dec 2006 21:43:37 -0800 in comp.lang.c++, "Markus Dehmann"
<ma************ @gmail.comwrote ,

>According to several C++ tutorials, calling srand like this to
initialize the random number generator seems to be standard:

srand((unsigned )time(0));

But it leads to the same random number sequence on every program call
if the program is called several times in a second!

Indeed, that method is unsuitable for a program that's going to be
called several times in a second. It may also be unsuitable for a
program that's going to be launched by "chron" or the windows task
scheduler etc. at repeated predictable times. The whole rand()
scheme is suitable for only casual undemanding applications.

For a somewhat better grade of random numbers I think I'd start by
adapting the random number generator class from Stroustrup ch. 22.
For your concern, I'd make it a class that loaded the seed from a file
in the constructor and saved it back to disk in the destructor.

For the best grade of random numbers, consult a cryptologist.

In June 1998 the Arizona Lottery had to suspended its Pick 3 game when
they discovered that their random number generator selecting the winning
numbers never picked the digit 9. (RISKS Digest 19.3)

[David Harmon]

On Tue, 05 Dec 2006 06:03:37 GMT in comp.lang.c++, David Harmon
<so****@netcom. comwrote,

>In June 1998 the Arizona Lottery had to suspended its Pick 3 game when
they discovered that their random number generator selecting the winning
numbers never picked the digit 9. (RISKS Digest 19.3)

Sorry, that's RISKS Digest 19.83

[Steve Pope]

I wrote:

>One approach is to use the process id as part of the seed. One
standard/portable way to do this is to use an integer hash function
of the string returned by tmpnam().

I notice the gcc documentation for tmpnam() says: "Never use this
function. Use mkstemp(3) instead".

However, mkstemp() is not part of standard C++, whereas tmpnam()
is, so pick your poison.

Steve

[eriwik]

On Dec 5, 6:43 am, "Markus Dehmann" <markus.dehm... @gmail.comwrote :

According to several C++ tutorials, calling srand like this to
initialize the random number generator seems to be standard:

srand((unsigned )time(0));

But it leads to the same random number sequence on every program call
if the program is called several times in a second! Isn't there a
better method to seed the random numbers? Probably based on
milliseconds instead of seconds? And integrating the process ID or
current amount of free memory or whatever? Is there a C++ library that
does it right?

As many have pointed out, if you want to do this well, you'll have to
use some platform-specific code (or wait to the next version of the
standard, looks like it will have random number generators). If you are
running Linux/Unix you can read in a value to use as seed from
/dev/random (or dev/urandom or something such). This will give you
high-entropy random numbers.

--
Erik Wikström

[lwz]

You could put a random number generated by rand() into your srand
function, maybe even added to the number of processor clock ticks after
the process started (clock())... so
srand(rand()+cl ock()+time(NULL ));

er****@student. chalmers.se wrote:

On Dec 5, 6:43 am, "Markus Dehmann" <markus.dehm... @gmail.comwrote :

According to several C++ tutorials, calling srand like this to
initialize the random number generator seems to be standard:

srand((unsigned )time(0));

But it leads to the same random number sequence on every program call
if the program is called several times in a second! Isn't there a
better method to seed the random numbers? Probably based on
milliseconds instead of seconds? And integrating the process ID or
current amount of free memory or whatever? Is there a C++ library that
does it right?

As many have pointed out, if you want to do this well, you'll have to
use some platform-specific code (or wait to the next version of the
standard, looks like it will have random number generators). If you are
running Linux/Unix you can read in a value to use as seed from
/dev/random (or dev/urandom or something such). This will give you
high-entropy random numbers.

--
Erik Wikström

[Jeff Dege]

On Tue, 05 Dec 2006 02:42:11 -0800, lwz wrote:

You could put a random number generated by rand() into your srand
function, maybe even added to the number of processor clock ticks after
the process started (clock())... so
srand(rand()+cl ock()+time(NULL ));

That's not going to give you a unique seed, if you start the program
multiple times in the same second. Calling rand() without having set a
distinct seed will always return the same value. On many platforms,
calling clock() at the same point in program execution will always return
the same value.

--
Windows2000 - from the people who brought you edlin.

[Markus Moll]

Hi

Steve Pope wrote:

I wrote:

>>One approach is to use the process id as part of the seed. One
standard/portable way to do this is to use an integer hash function
of the string returned by tmpnam().

I notice the gcc documentation for tmpnam() says: "Never use this
function. Use mkstemp(3) instead".

It's completely safe if you just want to use the string for whatever
purpose. The only problem with the function is that getting the filename
from tmpnam and actually opening the file is not atomic, which leaves you
vulnerable to some attacks:
http://www.owasp.org/index.php/Insecure_Temporary_File

Markus