Confusion about `Random`

[Steven Schveighoffer]

On 12/22/22 11:23 AM, jwatson-CO-edu wrote:
> I am confused about why Program 1 produces random output but Program 2 
> does not.
> 
> ---
> 
> ### Program 1
> ```d
> import std.stdio;
> import std.conv;
> import std.random;
> 
> Mt19937 rnd;
> 
> double rand01(){
>      // Uniform random sampling in [0,1)
>      return uniform( 0.0, 1.0, rnd);
> }
> 
> void main(){
>      rnd = Random( unpredictableSeed );
>      for( uint i = 0; i < 6; i++ ){
>          writeln( rand01() );
>      }
> }
> ```
> 
> Output:
> ```
> 0.35332
> 0.0687847
> 0.563096
> 0.37718
> 0.321598
> 0.530525
> ```
> 
> ---
> 
> ### Program 2
> #### sparrow_core.d
> ```d
> // ...
> 
> Mt19937 rnd; // Randomness
> 
> void init_random(){
>      // Seed the RNG with the clock
>      rnd = Random( unpredictableSeed );
> }
> 
> // ...
> 
> double rand01(){
>      // Uniform random sampling in [0,1)
>      return uniform( 0.0, 1.0, rnd);
> }
> 
> // ...
> 
> // Build a dict of primitive symbols
> primitiveSymbols["rand"] = function Atom*(){
>      // Random number on [0,1)
>      return new Atom( rand01() ); // Construct an Atom holding a random 
> value
> };
> 
> // ...
> 
> void init_SPARROW(){
>      // Populate necessary global structures
>      init_reserved(); // - Reserved symbols
>      init_env(); // ------ Global context
>      init_primitives(); // Special atoms and Primitive Functions
>      init_specials(); // - Special forms
>      init_random(); // --- RNG
> }
> ```
> 
> #### app.d
> ```d
> void main( string[] args ){
> 
>      Atom* res = null;
> 
>      if( _DEBUG_VERBOSE )  writeln( "Args are: " ~ args.to!string );
> 
>      // Populate necessary interpreter components
>      init_SPARROW();
> 
>      // ... Interpreter repeatedly invokes primitive symbol "rand"
> 
> }
> ```
> 
> Output:
> ```
> 0.961451
> 0.961451
> 0.961451
> 0.961451
> 0.961451
> 0.961451
> ```
> 
> Note: I have enclosed `uniform` so deeply because I am implementing the 
> random number feature of a [computer 
> language](https://github.com/jwatson-CO-edu/SPARROW).
> 
> ---
> 
> What is the reason for this? Has the compiler optimized away the 
> `uniform` call to a single double number?
> What is the main difference between Program 1 and Program 2? Both seem to:
> * Have a global RNG `rnd`
> * Seed RNG after `main` starts.
> * Generates a random number on [1,0) from a function.
> 
> So I would expect both programs to behave the same...
> 
> 

Without the rest of the code, and how random is called, I have a 
hunch... Are you using threads by any chance?

If, for instance, your calls to rand01 are done in a new thread, that 
new thread will have a *default* state of Mt19937.

I tried out just a non-seeded instance, and it did not produce that 
exact number, so this may not be the case.

But in case you are, you should be aware that globals get one instance 
per thread, and are default initialized.

-Steve