Pelle Evensen wrote:



> Randy Casstevens wrote:

>> Do some random seeds give better quality results for

>> MersenneTwisterFast?  I have heard that random seeds should be odd

>> numbers, large numbers, and/or prime numbers, but does it matter for

>> MersenneTwisterFast?

>>   

> In short, for any good quality PRNG (the MersenneTwister would be one) 

> the choice of seed does not matter at all as far as "quality" goes.



Actually, many very high-grade RNGs are known to have certain 

pathological seed cases.  The crucial issue is: do we know what those 

cases are?  If so, we're fine -- just avoid those seed choices.



Mersenne Twister is no exception: and it's considered among  best of the 

best!  MT's internal state is an array of about 600 32-bit integers. 

Its seeding pathology is to fill that array initially with lots of 

zeros.  It takes Mersenne Twister a while to work its way out of that 

state, during which time it tends to produce lots of relatively poorly 

random numbers.



This turned out to be a problem for early seeding algorithms common 

among the Mersenne Twister community.  The current standard seeding 

algorithm is to take a seed and hand it off to a simple but relatively 

random RNG (in this case, a particular linear congruential generator in 

one of Knuth's books), and pump that generator 600-ish times.  Each 

output of the generator gets put into a different slot in the Mersenne 

Twister array.  That gives you a nice random collection of numbers, and 

an acceptably small number of initial zeros.



FWIW, my MersenneTwisterFast code follows the current standards.





> The only thing to possibly worry about is if you start many different 

> simulations with nearby seeds. For some generators (depending on how the 

> seed is expanded to the internal state of the generator) this will be a 

> problem and for some others, it won't be. What the state of the Mersenne 

> Twister as implemented in MASON is, I don't know.



Generally MT doesn't have this problem, partly because as an algorithm 

it's pretty robust to that issue, and partly because the Knuth seeding 

procedure described above creates very different initial internal array 

states from very similar random numbers.  Overall, most high grade RNGs 

are robust against similar seeds.





> A better (or at least safer) approach than the Mersenne Twister would be 

> to have a generator that generates distinct streams. This article 

> discusses the desirability of distinct streams; 

> http://www.iro.umontreal.ca/~lecuyer/myftp/papers/rstream.pdf



Having a generator which is forkable is a nice feature.  But I would be 

very hesitant to rely on an algorithm that doesn't have fairly provable 

features: and the paper you cited is actually a technical report for a 

code library, not an algorithmic description.  My suggestion about 

random numbers: BE VERY CAREFUL ABOUT DEVIATING FROM WELL-STUDIED 

ALGORITHMS.  I don't get a good feeling about the lack of formality in 

this paper.



Stream protocols etc. are often implementable directly on top of 

well-regarded generators.  MT would be particularly good for this given 

its famously gigantic period.  It might be worthwhile to investigate the 

current RNG literature for formal protocols.



Sean