I am confused about why Program 1 produces random output but Program 2 does not.
Program 1
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
// ...
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
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.
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...