Different results for uniform random number generation between D and Boost

[Joseph Rushton Wakeling]

Hello all,

A little curiosity I noticed when comparing fine-detailed results from 
simulations where I had code in both C++ and D.

Here's a little program that prints out the first 10 results of the Mersenne 
Twister RNG, and then uses the same sequence to generate 10 
uniformly-distributed numbers in [0, 1).

////////////////////////////////////////////////////////////////////////////
import std.random, std.range, std.stdio;

void main()
{
	auto rng = Random(12345);

	foreach(x; takeExactly(rng, 10))
		writeln(x);

	writeln();
	writeln("Min: ", rng.min);
	writeln("Max: ", rng.max);
	writeln();
	
	rng.seed(12345);

	foreach(i; 0..1000)
		writefln("%.64f", uniform!("[)", double, double)(0.0, 1.0, rng));
}
////////////////////////////////////////////////////////////////////////////

And now here's something similar written in C++ and using the Boost RNGs:

////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <iomanip>
#include <boost/random.hpp>

int main(void)
{
	boost::mt19937 rng(12345);

	for(int i=0;i<10;++i)
		std::cout << rng() << std::endl;
	
	std::cout << std::endl;
	std::cout << "Min: " << rng.min() << std::endl;
	std::cout << "Max: " << rng.max() << std::endl;
	std::cout << std::endl;

	rng.seed(12345);

	for(int i=0;i<10;++i)
		std::cout << std::setprecision(64) << boost::uniform_real<double>(0.0, 
1.0)(rng) << std::endl;
}
////////////////////////////////////////////////////////////////////////////

When I run these on my 64-bit machine I get different results for the uniform 
doubles, which show up round about the 15th or 16th decimal place.

If I replace double with float, I get a similar result, but now with the 
difference starting at about the 7th or 8th decimal place.

I've tried tweaking the internals of std.random's uniform() just to confirm it's 
not a rounding error down to subtly different arithmetical order; D's results 
remain unchanged.  So I'm curious why I see these differences -- OK, floating 
point is a minefield, but I thought these were hardware-implemented variables 
and operations which I'd expect to match between C++ and D.

OK, it's not the end of the world and these numbers are identical to a high 
degree of accuracy -- but I'm just curious as to why the difference.  It's also 
slightly frustrating to not have precise agreement between the output of 2 
libraries that are so obviously designed to produce an identical API and feature 
set.

Best wishes,

     -- Joe