SFMT

SFMT random number generator, whose parameters are set compile time.

Constructors

this
this(uint seed)
this
this(uint[] seed)

Members

Aliases

mexp
alias mexp = mersenneExponent
Undocumented in source.

Manifest constants

id
enum id;
m
enum m;
masks
enum masks;
mersenneExponent
enum mersenneExponent;
n
enum n;
parity
enum parity;
shifts
enum shifts;
size
enum size;

Mixins

__anonymous
mixin SFMTMixin
Undocumented in source.

Mixed In Members

From mixin SFMTMixin

isUniformRandom
enum isUniformRandom;
min
enum min;
max
enum max;
fillState
void fillState(ubyte b)
Undocumented in source. Be warned that the author may not have intended to support it.
seed
void seed(uint seed)
seed
void seed(uint[] seed)
empty
enum empty;
front
ulong front()
popFront
void popFront()

input range interface.

frontPop
T frontPop()
Undocumented in source. Be warned that the author may not have intended to support it.
frontPop
T frontPop()
Undocumented in source. Be warned that the author may not have intended to support it.
next
T next(size_t size)
idx
int idx;
Undocumented in source.
assureLongPeriod
bool assureLongPeriod()

returns true if modification is done

Examples

/// SFMT19937 is an alias of SFMT!(...).
import std.random;
static assert (isUniformRNG!SFMT19937);
assert (SFMT19937(4321u).front == 16924766246869039260UL);
import std.algorithm : equal;
import std.range : take;
assert (SFMT19937(4321u).next!(ulong[])(1000).equal(
        SFMT19937(4321u).take(1000)));
stderr.writeln("checked next!ulong[] and range functionality");
import std.random;
auto sfmt = SFMT19937(4321u);
foreach (i; 0..1000)
{
    assert (0 <= sfmt.uniform01!real);
    assert (0 <= sfmt.uniform01!double);
    assert (0 <= sfmt.uniform01!float);
    assert (sfmt.uniform01!real < 1);
    assert (sfmt.uniform01!double < 1);
    assert (sfmt.uniform01!float < 1);
}
stderr.writeln("checked uniform01");

auto sixThousandth = sfmt.front;
sfmt = SFMT19937(4321u);
foreach (i; 0..6000)
    sfmt.popFront;
assert (sfmt.front == sixThousandth);
stderr.writeln("checked call-only-popFront case");
void testNext(U, ISFMT)(ISFMT sfmt)
{
    auto copy = sfmt;
    auto firstBlock = sfmt.next!(U[])(10000);
    auto secondBlock = sfmt.next!(U[])(10000);
    U s;
    foreach (i, b; firstBlock)
        assert (b == (s = copy.frontPop!U), "mismatch: first[%d] = %0*,8x != %0*,8x".format(i, U.sizeof>>1, b, U.sizeof>>1, s));
    foreach (i, b; secondBlock)
        assert (b == (s = copy.frontPop!U), "mismatch: second[%d;%d] = %0*,8x != %0*,8x".format(i, i+firstBlock.length, U.sizeof>>1, b, U.sizeof>>1, s));
}
testNext!ulong(SFMT19937(4321u));
testNext!ulong(SFMT19937([uint(5), 4, 3, 2, 1]));
testNext!uint(SFMT19937(1234u));
testNext!uint(SFMT19937([uint(0x1234), 0x5678, 0x9abc, 0xdef0]));
stderr.writeln("checked frontPop!U and next!U[] (U = ulong, uint)");
void testPopFrontThenBlock(size_t firstSize, size_t secondSize)
{
    import std.range : drop, take;
    import std.algorithm : equal;
    auto sfmt = SFMT19937(4321u);
    foreach (i; 0..firstSize*2)
        sfmt.popFront;
    auto a = sfmt.next!(ulong[])(secondSize*2);
    auto b = SFMT19937(4321u).drop(firstSize*2).take(secondSize*2);
    assert (a.equal(b));
}
foreach (i; 0..SFMT19937.n)
    foreach (j; SFMT19937.n..SFMT19937.n*2)
    {
        testPopFrontThenBlock(i, j);
    }
stderr.writeln("checked next!U[]");

Meta