Xoshiro256StarStar Class Reference

Pseudo-random integer generator. This class generates 64-bit integer using Xoshiro256** algorithm. More...

#include <xoshiro_256_star_star.h>

Public Member Functions
	Xoshiro256StarStar (const int64_t seed)
	Constructor. It initializes the state variable with random integers using splitmix64 pseudo-random generator.
	~Xoshiro256StarStar ()
	Destructor.
uint64_t	next ()
	Generates the next presudo-random number.
void	jump ()
	Jump function for the generator. It is equivalent to 2^128 calls to next(); it can be used to generate 2^128 non-overlapping subsequences for parallel computations.
void	long_jump ()
	Long jump function for the generator. It is equivalent to 2^192 calls to next(). It can be used to generate 2^64 starting points from each of which jump() will generate 2^64 non-overlapping subsequences for parallel distributed computations.

Static Protected Member Functions
static uint64_t	rotation_left (const uint64_t x, int k)
	Rotates the bits of a 64 bit integer toward left.

Protected Attributes
uint64_t *	state

Detailed Description

Pseudo-random integer generator. This class generates 64-bit integer using Xoshiro256** algorithm.

The Xoshiro256** algorithm has 256-bit state space, and passes all statistical tests, including the BigCrush. The state of this class is initialized using SplitMix64 random generator.

A very similar method to Xoshiro256** is Xoshiro256++ which has the very same properties and speed as the Xoshiro256**. An alternative method is Xoshiro256+, which is 15% faster, but it suffers linear dependency of the lower 4 bits. It is usually used for generating floating numbers using the upper 53 bits and discard the lower bits.

The Xoshiro256** algorithm is develped by David Blackman and Sebastiano Vigna (2018) and the source code can be found at: https://prng.di.unimi.it/xoshiro256starstar.c

See also

SplitMix64

Definition at line 49 of file xoshiro_256_star_star.h.

Constructor & Destructor Documentation

Xoshiro256StarStar()

Xoshiro256StarStar::Xoshiro256StarStar ( const int64_t  seed )

explicit

Constructor. It initializes the state variable with random integers using splitmix64 pseudo-random generator.

Definition at line 33 of file xoshiro_256_star_star.cpp.

                                                        :
    state(NULL)
{
    // Allocate state
    this->state = new uint64_t[4];
 
    // Initializing SplitMix64 random generator
    SplitMix64 split_mix_64(seed);
 
    for (int i=0; i < 4; ++i)
    {
        this->state[i] = split_mix_64.next();
    }
}

References SplitMix64::next(), and state.

Here is the call graph for this function:

~Xoshiro256StarStar()

Xoshiro256StarStar::~Xoshiro256StarStar

(

)

Destructor.

Definition at line 56 of file xoshiro_256_star_star.cpp.

{
    if (this->state != NULL)
    {
        delete[] this->state;
        this->state = NULL;
    }
}

References state.

Member Function Documentation

jump()

void Xoshiro256StarStar::jump

(

)

Jump function for the generator. It is equivalent to 2^128 calls to next(); it can be used to generate 2^128 non-overlapping subsequences for parallel computations.

Definition at line 100 of file xoshiro_256_star_star.cpp.

{
    static const uint64_t JUMP[] = {
        0x180ec6d33cfd0aba,
        0xd5a61266f0c9392c,
        0xa9582618e03fc9aa,
        0x39abdc4529b1661c};
 
    uint64_t s0 = 0;
    uint64_t s1 = 0;
    uint64_t s2 = 0;
    uint64_t s3 = 0;
 
    for (unsigned int i = 0; i < sizeof(JUMP) / sizeof(*JUMP); ++i)
    {
        for (int b = 0; b < 64; ++b)
        {
            if (JUMP[i] & UINT64_C(1) << b)
            {
                s0 ^= this->state[0];
                s1 ^= this->state[1];
                s2 ^= this->state[2];
                s3 ^= this->state[3];
            }
 
            this->next();
        }
    }
 
    this->state[0] = s0;
    this->state[1] = s1;
    this->state[2] = s2;
    this->state[3] = s3;
}

References next(), state, and UINT64_C.

Referenced by RandomNumberGenerator::initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

long_jump()

void Xoshiro256StarStar::long_jump

(

)

Long jump function for the generator. It is equivalent to 2^192 calls to next(). It can be used to generate 2^64 starting points from each of which jump() will generate 2^64 non-overlapping subsequences for parallel distributed computations.

Definition at line 145 of file xoshiro_256_star_star.cpp.

{
    static const uint64_t LONG_JUMP[] = {
        0x76e15d3efefdcbbf,
        0xc5004e441c522fb3,
        0x77710069854ee241,
        0x39109bb02acbe635};
 
    uint64_t s0 = 0;
    uint64_t s1 = 0;
    uint64_t s2 = 0;
    uint64_t s3 = 0;
 
    for (unsigned int i = 0; i < sizeof(LONG_JUMP) / sizeof(*LONG_JUMP); ++i)
    {
        for (int b = 0; b < 64; ++b)
        {
            if (LONG_JUMP[i] & UINT64_C(1) << b)
            {
                s0 ^= this->state[0];
                s1 ^= this->state[1];
                s2 ^= this->state[2];
                s3 ^= this->state[3];
            }
 
            this->next();
        }
    }
 
    this->state[0] = s0;
    this->state[1] = s1;
    this->state[2] = s2;
    this->state[3] = s3;
}

References next(), state, and UINT64_C.

Here is the call graph for this function:

next()

uint64_t Xoshiro256StarStar::next

(

)

Generates the next presudo-random number.

Definition at line 73 of file xoshiro_256_star_star.cpp.

{
    const uint64_t result = this->rotation_left(this->state[1] * 5, 7) * 9;
 
    const uint64_t t = this->state[1] << 17;
 
    this->state[2] ^= this->state[0];
    this->state[3] ^= this->state[1];
    this->state[1] ^= this->state[2];
    this->state[0] ^= this->state[3];
 
    this->state[2] ^= t;
 
    this->state[3] = this->rotation_left(this->state[3], 45);
 
    return result;
}

References rotation_left(), and state.

Referenced by jump(), long_jump(), and RandomNumberGenerator::next().

Here is the call graph for this function:

Here is the caller graph for this function:

rotation_left()

uint64_t Xoshiro256StarStar::rotation_left ( const uint64_t  x, int  k  )

inlinestaticprotected

Rotates the bits of a 64 bit integer toward left.

Parameters

[in]	x	A 64 bit integer to rotate its bits toward left.
[in]	k	Number of bit places to rotate each bit of x

Returns

A 64 bit integer where each bit is k bit moved left

Definition at line 192 of file xoshiro_256_star_star.cpp.

{
    return (x << k) | (x >> (64 - k));
}

Referenced by next().

Here is the caller graph for this function:

Member Data Documentation

state

uint64_t* Xoshiro256StarStar::state

protected

Definition at line 64 of file xoshiro_256_star_star.h.

Referenced by jump(), long_jump(), next(), Xoshiro256StarStar(), and ~Xoshiro256StarStar().

---

The documentation for this class was generated from the following files:

• /home/runner/work/imate/imate/imate/_random_generator/xoshiro_256_star_star.h
• /home/runner/work/imate/imate/imate/_random_generator/xoshiro_256_star_star.cpp