I'm not overly worried about the quality of the stock Perl rand() or about exhausting the numbers of random numbers it can produce. I don't think I would need more than 100,000 numbers.

I originally only wanted access to the seed, but not being able to do so using stock Perl has led me to deal with things I am not very familiar with like how to generate a seed, etc...

What method would you recommend me to do? I'm unclear about some of the differences.

Pseduo random number sequence generators (which is what we are really talking about) are tricky things and are subject to much tricky maths that I don't understand. However there are various quality attributes that characterise such generators and default rand generators often exhibit among the worst results for those qualities.

One simple quality is the number of bits used by the generator. Perl tends to use the rand provided by the runtime library of the C compiler used to build it. ActiveState's Perl build for example uses only 15 bits! You can find out how many bits you Perl build uses by:

use Config;

print $Config{randbits};
[download]

In fact the seeding snippet I gave earlier could be rewritten using that information as $seed = int(rand(2**$Config{randbits} - 1)); (although that may produce odd results if $Config{randbits} == $Config{longsize} * 8). Note that 2**2**$Config{randbits} is generally the maximum cycle length for rand.

Another area where rand is often poor is correlation between successive values. This may be a more important consideration where you are generating numbers for modelling or statistical applications. There is a pile of stuff on the internet about these sorts of applications and suitable generators. You could start at Pseudorandom_number_generator.

For your application I strongly recommend that you use Math::Random::MT for your actual generator. It is a robust generator that is generally quick enough and has a very long cycle period. It is also very easy to use. Just put:

use Math::Random::MT qw(srand rand);
[download]

and you are in business - the MT generator replaces Perl's built in rand seamlessly.

---

Perl reduces RSI - it saves typing

I seem to have $Config{randbits} = 48 and  $Config{longsize} = 4. But using $seed = int(rand(2**$Config{randbits} - 1)); produced very poor results. Even when the seed was different, I would get the same series random numbers using my $pick = int(rand(1e9))+1;
In any case, it's not important because I am now using Math::Random::MT, and its srand() function takes unsigned 32-bit integers. Thus I have to produce my seed between 0 and 2**32-1.
It worked quite well, but I noticed that I would get the same seed when my program was called several times in a short time frame. So I had to seed the PRNG with a fast-moving seed first before I could produce my actual random seed.
use Math::Random::MT qw(srand rand); I'm quite happy now with the result. I appreciate your advices GrandFather. The final code looks like this:


use Math::Random::MT qw(srand rand);
sub seed_prng {
  # Seed the pseudo random number generator with a random or specified
+ seed
  # Returns what seed value is used
  my ($seed) = shift;
  if (not defined $seed) {
    # Want to produce an random unsigned 32-bit integer to feed to
    # Math::Random::MT::srand(). That means, first seed srand() with a
+ temporary
    # seed that varies quickly in time so we don't get twice the same 
+seed if we
    # request several seeds in a short interval of time.
    my $tmp_seed = time ^ ($$ + ($$ << 15)); # shown in srand's doc
    srand($tmp_seed);
    my $max = int(2**32-1); # Largest unsigned 32-bit integer
    $seed = int(rand($max+1)); # An integer between 0 and $max
  }
  srand($seed);
  return $seed;
}
[download]