SplitMix64

This is a fixed-increment version of Java 8's SplittableRandom generator. It is a very fast generator passing BigCrush, and can be useful if for some reason exactly 64 bits of state are needed; otherwise, it is suggested to use Xoroshiro128plus (for moderately parallel computations) or Xorshift1024star (for massively parallel computations).

The generator period is 2 ^^ 64.

struct SplitMix64 {

enum bool isUniformRandom;

enum ulong min;

enum ulong max;

typeof(this) dup();

void seed(ulong s);

}

Constructors

this this(): Undocumented in source.
this this(ulong s): Constructor (RNG instances can only be initialized with a specified seed).

Postblit

this(this) this(this): Undocumented in source.

Members

Functions

dup typeof(this) dup(): Provides a copy of this RNG instance with identical internal state.
front ulong front()
popFront void popFront(): Range primitives
seed void seed(ulong s): (Re)seeds the generator.

Variables

empty enum bool empty;: Range primitives
isUniformRandom enum bool isUniformRandom;: Marks this range as a uniform random number generator
max enum ulong max;: Largest generated value
min enum ulong min;: Smallest generated value (0)

Examples

import std.array : array;
import std.random : isUniformRNG, randomSample, uniform;
import std.range : iota, take;
import dxorshift.splitmix64;

// splitmix64 generators must be initialized
// with a specified seed
auto gen = SplitMix64(123456);

// verify it is indeed a uniform RNG as defined
// in the standard library, whether accessed
// directly or via a pointer
static assert(isUniformRNG!(typeof(gen)));
static assert(isUniformRNG!(typeof(&gen)));

// since the postblit is disabled, we must
// pass a pointer to any functionality that
// would otherwise copy the RNG by value
assert((&gen).take(2).array == [4172122716518060777uL,
                                4753009419905186825uL]);

// this means, of course, that we must guarantee
// the lifetime of the pointer is valid for the
// lifetime of any functionality that uses it
auto sample = iota(100).randomSample(10, &gen).array;

// however, we can pass the RNG as-is to any
// functionality that takes it by ref and does
// not try to copy it by value
auto val = uniform!"()"(-0.5, 0.5, gen);

// in circumstances where we really want to
// copy the RNG state, we can use `dup`
auto gen2 = gen.dup;
assert((&gen).take(3).array == (&gen2).take(3).array);