Hello,

I was just checking some information on the random_number and
random_seed
intrinsic subroutines and I came across this text fragment (in the
Compaq Visual
Fortran documentation):

If no argument is specified, a random number based on the date and
time is assigned to the seed.

I wondered if this is standard behaviour, so I wrote the following
program:

program rnd
integer :: seed_size
integer, allocatable, dimension(:) :: seed_data

call random_seed( size = seed_size )

allocate( seed_data(seed_size) )

call random_seed( get = seed_data )

write(*,*) 'Seed size:', seed_size
write(*,*) 'Seed data:', seed_data

On 2008-05-22, Arjen Markus wrote:

It is permitted by the standard, but not required.

[Sample program elided]

The behavior of gfortran is the result of a design decision with
reproducibility as it goal.

On 22 mei, 12:06, Thomas Koenig wrote:

On 2008-05-22, Arjen Markus wrote:

It's standard F95, so it can be used portably (although it may not
be needed with other implementations).

On 22 mei, 12:47, Thomas Koenig wrote:

I should have been clearer: I mean the seeding method as documented
is that general too or is it specific to gfortran.

If it is indeed general, that would be nice, but then I wonder
why the size of the seed differs from one compiler to the
next.

Regards,

Arjen

On Thu, 22 May 2008 04:19:49 -0700 (PDT), Arjen Markus wrote:

He said the seeding method is standard f95, so it can be used portably.

On 22 mei, 14:15, Dave Seaman wrote:

I interpreted it as meaning that the _code_ of the
example is standard Fortran 95, but if the _method_ is
standard as well, then that is very useful indeed.

(I had not seen documentation of the seeding before - I always
assumed that it was left to the implementors of the compiler,
hence the contents of the array used for seeding should be
treated as opaque.)

Regards,

Arjen

On Thu, 22 May 2008 05:23:42 -0700 (PDT), Arjen Markus wrote:

I don't know what you mean by that. The statement

CALL RANDOM_SEED(PUT = seed)

has an implementation-defined meaning. Different processors may treat
the PUT array in different ways, even if the size happens to be the same.

On 2008-05-22, Arjen Markus wrote:

It is standard-conforming (which is why seed is a dynamically
allocated array in this case), and it is very likely to
generate a good seed regardless of the implementation (unless the
PRNG of the implementation is of bad quality, which should hopefully
be rare).

In the words of the standard - "Computation of the seed from the
argument PUT is performed in a processor-dependent manner."
Different implementations are free to choose different algorithms.

Thomas Koenig wrote:

It is also an unfortunate example of a result of inadequate attention to
detail in the writing of the standard. The author of those words later
claimed that he had intended to specify whether the processor-dependent
seed was always the same for a given processor, or whether it could vary
like this. Unfortunately, he forgot to actually put this specification
in writing. By the time he explained that this was his intent, the
standard had long been published and there were established
implementations and programs using both different ways.