11
$\begingroup$

Suppose I want to run several times of the same code containing RandomReal function, but I don't initialise the random seed. What will happen?

I tried, but each time the RandomReal[] return different values, does it mean that Mathematica using some kind of default method to initialise the random number generator even without SeedRandom[]?

$\endgroup$
  • 5
    $\begingroup$ "... Mathematica (is) using (a) default method (when) initialising the random number generator?" - yes. $\endgroup$ – J. M. will be back soon Nov 18 '15 at 13:53
  • $\begingroup$ @J.M. Thanks. That's the answer I wanted. $\endgroup$ – LifeWorks Nov 18 '15 at 13:56
  • 2
    $\begingroup$ I'm sorry I can't give anything more substantial; the docs do not mention in detail how Mathematica seeds its default generator at the start of a session. Back in the day, this involved the system variable $RandomState, but this is no longer applicable to the current system (except when one invokes Method -> "Legacy"). $\endgroup$ – J. M. will be back soon Nov 18 '15 at 14:03
15
$\begingroup$

Let's think about when the answer to this question may be relevant. You know that if using the same seed on two different occasions, the RNG will generate the same sequence of numbers. So the relevant questions are:

  1. Does Mathematica use the same seed after startup every time?

    No. This is easy to test.

  2. Many programs take the seed from the system time. Also, the SeedRandom documentation says that "SeedRandom[] resets the generator, using as a seed the time of day and certain attributes of the current Wolfram System session." Is this what Mathematica does on startup?

    Yes. On OS X I ran the following in a terminal:

    math -run Print@RandomReal[] & math -run Print@RandomReal[]
    

    That is, I started two kernels at the same time and checked if they generate the same sequence of random numbers. They do.

  3. If the seed is taken from the system time, what about parallelization? What if I start up all parallel kernels at the same time? Will they all use the same seed?

    No. The Parallel Tools package takes care of this. Each kernel will use a different seed. You can easily test this using ParallelTable[RandomReal[], {$ProcessorCount}]. You'll get a list of different numbers.

  4. Okay, but what if instead of using in-Mathematica parallelization, I manually run several Mathematica processes in parallel, say on a HPC cluster?

    Modern operating systems come with a nondeterministic random number generator. This gives truly unpredictable random numbers using entropy sources such as keystrokes and network traffic, and is used for cryptographical purposes. You can take the seed from there. Here's a function I used for this in the past. It's only for Unix-like systems (OS X and Linux):

    (* Nondeterministic random numbers from the OS *)
    
    NondeterministicRandomInteger::usage = "NondeterministicRandomInteger[] returns an unpredictable random integer between 0..2^32-1.";
    
    NondeterministicRandomInteger::notsupp = "Not supported on ``";
    
    Switch[$OperatingSystem,
              "MacOSX"|"Unix",
              NondeterministicRandomInteger[] :=
                  AbortProtect@Module[{stream, res},
                    stream = OpenRead["!head -c 4 /dev/random", BinaryFormat -> True];
                    res = BinaryRead[stream, "UnsignedInteger32"];
                    Close[stream];
                    res
                  ],
              _,
              NondeterministicRandomInteger[] := (Message[NondeterministicRandomInteger::notsupp, $OperatingSystem]; $Failed)
    ]
    

    Use this only for seeding: SeedRandom@NondeterministicRandomInteger[].

    If I did this today, I would use something like boost::random_device through LibraryLink for a better cross platform solution that also works on Windows.

$\endgroup$
  • $\begingroup$ The answer as well, thx for the RNG, +1 $\endgroup$ – user9660 Nov 18 '15 at 14:51
  • $\begingroup$ Fantastic! Thanks for sharing the insights. $\endgroup$ – LifeWorks Nov 18 '15 at 18:32
2
$\begingroup$

From documentation:

You can use SeedRandom[n] to make sure you get the same sequence of pseudorandom numbers on different occasions.

Reference

SeedRandom

$\endgroup$
  • 2
    $\begingroup$ I got the question like: "what's happening with the seed when I'm not touching it". $\endgroup$ – Kuba Nov 18 '15 at 13:53
  • $\begingroup$ but it does not affect anything if i run it in parallel, i think. each processor still takes different values? $\endgroup$ – Chen Stats Yu Jun 12 '18 at 10:48

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.