dSFMT.c File Reference

double precision SIMD-oriented Fast Mersenne Twister (dSFMT) based on IEEE 754 format. More...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "dSFMT-params.h"
#include "wrapperMPI.h"

Include dependency graph for dSFMT.c:

Go to the source code of this file.

Functions
static uint32_t	ini_func1 (uint32_t x)
static uint32_t	ini_func2 (uint32_t x)
static void	gen_rand_array_c1o2 (dsfmt_t *dsfmt, w128_t *array, int size)
static void	gen_rand_array_c0o1 (dsfmt_t *dsfmt, w128_t *array, int size)
static void	gen_rand_array_o0c1 (dsfmt_t *dsfmt, w128_t *array, int size)
static void	gen_rand_array_o0o1 (dsfmt_t *dsfmt, w128_t *array, int size)
static int	idxof (int i)
static void	initial_mask (dsfmt_t *dsfmt)
static void	period_certification (dsfmt_t *dsfmt)
static void	do_recursion (w128_t *r, w128_t *a, w128_t *b, w128_t *lung)
static void	convert_c0o1 (w128_t *w)
static void	convert_o0c1 (w128_t *w)
static void	convert_o0o1 (w128_t *w)
const char *	dsfmt_get_idstring (void)
int	dsfmt_get_min_array_size (void)
void	dsfmt_gen_rand_all (dsfmt_t *dsfmt)
void	dsfmt_fill_array_close1_open2 (dsfmt_t *dsfmt, double array[], int size)
void	dsfmt_fill_array_open_close (dsfmt_t *dsfmt, double array[], int size)
void	dsfmt_fill_array_close_open (dsfmt_t *dsfmt, double array[], int size)
void	dsfmt_fill_array_open_open (dsfmt_t *dsfmt, double array[], int size)
void	dsfmt_chk_init_gen_rand (dsfmt_t *dsfmt, uint32_t seed, int mexp)
void	dsfmt_chk_init_by_array (dsfmt_t *dsfmt, uint32_t init_key[], int key_length, int mexp)

Variables
dsfmt_t	dsfmt_global_data
static const int	dsfmt_mexp = DSFMT_MEXP

Detailed Description

double precision SIMD-oriented Fast Mersenne Twister (dSFMT) based on IEEE 754 format.

Author

Mutsuo Saito (Hiroshima University)

Makoto Matsumoto (Hiroshima University)

Copyright (C) 2007,2008 Mutsuo Saito, Makoto Matsumoto and Hiroshima University. All rights reserved.

The new BSD License is applied to this software, see LICENSE.txt

Definition in file dSFMT.c.

Function Documentation

convert_c0o1()

static void convert_c0o1 ( w128_t *  w )

inlinestatic

This function converts the double precision floating point numbers which distribute uniformly in the range [1, 2) to those which distribute uniformly in the range [0, 1).

Parameters

w	128bit stracture of double precision floating point numbers (I/O)

Definition at line 207 of file dSFMT.c.

Referenced by do_recursion(), and gen_rand_array_c0o1().

                                           {
    w->d[0] -= 1.0;
    w->d[1] -= 1.0;
}

Here is the caller graph for this function:

convert_o0c1()

static void convert_o0c1 ( w128_t *  w )

inlinestatic

This function converts the double precision floating point numbers which distribute uniformly in the range [1, 2) to those which distribute uniformly in the range (0, 1].

Parameters

w	128bit stracture of double precision floating point numbers (I/O)

Definition at line 218 of file dSFMT.c.

Referenced by do_recursion(), and gen_rand_array_o0c1().

                                           {
    w->d[0] = 2.0 - w->d[0];
    w->d[1] = 2.0 - w->d[1];
}

Here is the caller graph for this function:

convert_o0o1()

static void convert_o0o1 ( w128_t *  w )

inlinestatic

This function converts the double precision floating point numbers which distribute uniformly in the range [1, 2) to those which distribute uniformly in the range (0, 1).

Parameters

w	128bit stracture of double precision floating point numbers (I/O)

Definition at line 229 of file dSFMT.c.

Referenced by do_recursion(), and gen_rand_array_o0o1().

                                           {
    w->u[0] |= 1;
    w->u[1] |= 1;
    w->d[0] -= 1.0;
    w->d[1] -= 1.0;
}

Here is the caller graph for this function:

do_recursion()

static void do_recursion ( w128_t *  r, w128_t *  a, w128_t *  b, w128_t *  lung  )

inlinestatic

This function represents the recursion formula.

Parameters

r	output
a	a 128-bit part of the internal state array
b	a 128-bit part of the internal state array
lung	a 128-bit part of the internal state array This function represents the recursion formula.
r	output 128-bit
a	a 128-bit part of the internal state array
b	a 128-bit part of the internal state array
lung	a 128-bit part of the internal state array (I/O)

Definition at line 154 of file dSFMT.c.

References convert_c0o1(), convert_o0c1(), and convert_o0o1().

Referenced by dsfmt_gen_rand_all(), gen_rand_array_c0o1(), gen_rand_array_c1o2(), gen_rand_array_o0c1(), gen_rand_array_o0o1(), and idxof().

                                              {
    uint64_t t0, t1, L0, L1;

    t0 = a->u[0];
    t1 = a->u[1];
    L0 = lung->u[0];
    L1 = lung->u[1];
    lung->u[0] = (t0 << DSFMT_SL1) ^ (L1 >> 32) ^ (L1 << 32) ^ b->u[0];
    lung->u[1] = (t1 << DSFMT_SL1) ^ (L0 >> 32) ^ (L0 << 32) ^ b->u[1];
    r->u[0] = (lung->u[0] >> DSFMT_SR) ^ (lung->u[0] & DSFMT_MSK1) ^ t0;
    r->u[1] = (lung->u[1] >> DSFMT_SR) ^ (lung->u[1] & DSFMT_MSK2) ^ t1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

dsfmt_chk_init_by_array()

void dsfmt_chk_init_by_array	(	dsfmt_t *	dsfmt,
		uint32_t	init_key[],
		int	key_length,
		int	mexp
	)

This function initializes the internal state array, with an array of 32-bit integers used as the seeds

Parameters

dsfmt	dsfmt state vector.
init_key	the array of 32-bit integers, used as a seed.
key_length	the length of init_key.
mexp	caller's mersenne expornent

Definition at line 657 of file dSFMT.c.

References dsfmt_mexp, exitMPI(), idxof(), ini_func1(), ini_func2(), initial_mask(), and period_certification().

                                                       {
    int i, j, count;
    uint32_t r;
    uint32_t *psfmt32;
    int lag;
    int mid;
    int size = (DSFMT_N + 1) * 4;        /* pulmonary */

    /* make sure caller program is compiled with the same MEXP */
    if (mexp != dsfmt_mexp) {
        fprintf(stderr, "DSFMT_MEXP doesn't match with dSFMT.c\n");
        exitMPI(1);
    }
    if (size >= 623) {
        lag = 11;
    } else if (size >= 68) {
        lag = 7;
    } else if (size >= 39) {
        lag = 5;
    } else {
        lag = 3;
    }
    mid = (size - lag) / 2;

    psfmt32 = &dsfmt->status[0].u32[0];
    memset(dsfmt->status, 0x8b, sizeof(dsfmt->status));
    if (key_length + 1 > size) {
        count = key_length + 1;
    } else {
        count = size;
    }
    r = ini_func1(psfmt32[idxof(0)] ^ psfmt32[idxof(mid % size)] 
                  ^ psfmt32[idxof((size - 1) % size)]);
    psfmt32[idxof(mid % size)] += r;
    r += key_length;
    psfmt32[idxof((mid + lag) % size)] += r;
    psfmt32[idxof(0)] = r;
    count--;
    for (i = 1, j = 0; (j < count) && (j < key_length); j++) {
        r = ini_func1(psfmt32[idxof(i)] 
                      ^ psfmt32[idxof((i + mid) % size)] 
                      ^ psfmt32[idxof((i + size - 1) % size)]);
        psfmt32[idxof((i + mid) % size)] += r;
        r += init_key[j] + i;
        psfmt32[idxof((i + mid + lag) % size)] += r;
        psfmt32[idxof(i)] = r;
        i = (i + 1) % size;
    }
    for (; j < count; j++) {
        r = ini_func1(psfmt32[idxof(i)] 
                      ^ psfmt32[idxof((i + mid) % size)] 
                      ^ psfmt32[idxof((i + size - 1) % size)]);
        psfmt32[idxof((i + mid) % size)] += r;
        r += i;
        psfmt32[idxof((i + mid + lag) % size)] += r;
        psfmt32[idxof(i)] = r;
        i = (i + 1) % size;
    }
    for (j = 0; j < size; j++) {
        r = ini_func2(psfmt32[idxof(i)] 
                      + psfmt32[idxof((i + mid) % size)] 
                      + psfmt32[idxof((i + size - 1) % size)]);
        psfmt32[idxof((i + mid) % size)] ^= r;
        r -= i;
        psfmt32[idxof((i + mid + lag) % size)] ^= r;
        psfmt32[idxof(i)] = r;
        i = (i + 1) % size;
    }
    initial_mask(dsfmt);
    period_certification(dsfmt);
    dsfmt->idx = DSFMT_N64;
#if defined(HAVE_SSE2)
    setup_const();
#endif
}

Here is the call graph for this function:

dsfmt_chk_init_gen_rand()

void dsfmt_chk_init_gen_rand	(	dsfmt_t *	dsfmt,
		uint32_t	seed,
		int	mexp
	)

This function initializes the internal state array with a 32-bit integer seed.

Parameters

dsfmt	dsfmt state vector.
seed	a 32-bit integer used as the seed.
mexp	caller's mersenne expornent

Definition at line 626 of file dSFMT.c.

References dsfmt_mexp, exitMPI(), idxof(), initial_mask(), and period_certification().

                                                                      {
    int i;
    uint32_t *psfmt;

    /* make sure caller program is compiled with the same MEXP */
    if (mexp != dsfmt_mexp) {
        fprintf(stderr, "DSFMT_MEXP doesn't match with dSFMT.c\n");
        exitMPI(1);
    }
    psfmt = &dsfmt->status[0].u32[0];
    psfmt[idxof(0)] = seed;
    for (i = 1; i < (DSFMT_N + 1) * 4; i++) {
        psfmt[idxof(i)] = 1812433253UL 
            * (psfmt[idxof(i - 1)] ^ (psfmt[idxof(i - 1)] >> 30)) + i;
    }
    initial_mask(dsfmt);
    period_certification(dsfmt);
    dsfmt->idx = DSFMT_N64;
#if defined(HAVE_SSE2)
    setup_const();
#endif
}

Here is the call graph for this function:

dsfmt_fill_array_close1_open2()

void dsfmt_fill_array_close1_open2	(	dsfmt_t *	dsfmt,
		double	array[],
		int	size
	)

This function generates double precision floating point pseudorandom numbers which distribute in the range [1, 2) to the specified array[] by one call. The number of pseudorandom numbers is specified by the argument size, which must be at least (SFMT_MEXP / 128) * 2 and a multiple of two. The function get_min_array_size() returns this minimum size. The generation by this function is much faster than the following fill_array_xxx functions.

For initialization, init_gen_rand() or init_by_array() must be called before the first call of this function. This function can not be used after calling genrand_xxx functions, without initialization.

Parameters

dsfmt	dsfmt state vector.
array	an array where pseudorandom numbers are filled by this function. The pointer to the array must be "aligned" (namely, must be a multiple of 16) in the SIMD version, since it refers to the address of a 128-bit integer. In the standard C version, the pointer is arbitrary.
size	the number of 64-bit pseudorandom integers to be generated. size must be a multiple of 2, and greater than or equal to (SFMT_MEXP / 128) * 2.

Note

memalign or posix_memalign is available to get aligned memory. Mac OSX doesn't have these functions, but malloc of OSX returns the pointer to the aligned memory block.

Definition at line 556 of file dSFMT.c.

References gen_rand_array_c1o2().

                                                                             {
    assert(size % 2 == 0);
    assert(size >= DSFMT_N64);
    gen_rand_array_c1o2(dsfmt, (w128_t *)array, size / 2);
}

Here is the call graph for this function:

dsfmt_fill_array_close_open()

void dsfmt_fill_array_close_open	(	dsfmt_t *	dsfmt,
		double	array[],
		int	size
	)

This function generates double precision floating point pseudorandom numbers which distribute in the range [0, 1) to the specified array[] by one call. This function is the same as fill_array_close1_open2() except the distribution range.

Parameters

array	an array where pseudorandom numbers are filled by this function.
dsfmt	dsfmt state vector.
size	the number of pseudorandom numbers to be generated. see also

See also

fill_array_close1_open2()

Definition at line 592 of file dSFMT.c.

References gen_rand_array_c0o1().

                                                                           {
    assert(size % 2 == 0);
    assert(size >= DSFMT_N64);
    gen_rand_array_c0o1(dsfmt, (w128_t *)array, size / 2);
}

Here is the call graph for this function:

dsfmt_fill_array_open_close()

void dsfmt_fill_array_open_close	(	dsfmt_t *	dsfmt,
		double	array[],
		int	size
	)

This function generates double precision floating point pseudorandom numbers which distribute in the range (0, 1] to the specified array[] by one call. This function is the same as fill_array_close1_open2() except the distribution range.

Parameters

dsfmt	dsfmt state vector.
array	an array where pseudorandom numbers are filled by this function.
size	the number of pseudorandom numbers to be generated. see also

See also

fill_array_close1_open2()

Definition at line 574 of file dSFMT.c.

References gen_rand_array_o0c1().

                                                                           {
    assert(size % 2 == 0);
    assert(size >= DSFMT_N64);
    gen_rand_array_o0c1(dsfmt, (w128_t *)array, size / 2);
}

Here is the call graph for this function:

dsfmt_fill_array_open_open()

void dsfmt_fill_array_open_open	(	dsfmt_t *	dsfmt,
		double	array[],
		int	size
	)

This function generates double precision floating point pseudorandom numbers which distribute in the range (0, 1) to the specified array[] by one call. This function is the same as fill_array_close1_open2() except the distribution range.

Parameters

dsfmt	dsfmt state vector.
array	an array where pseudorandom numbers are filled by this function.
size	the number of pseudorandom numbers to be generated. see also

See also

fill_array_close1_open2()

Definition at line 610 of file dSFMT.c.

References gen_rand_array_o0o1().

                                                                          {
    assert(size % 2 == 0);
    assert(size >= DSFMT_N64);
    gen_rand_array_o0o1(dsfmt, (w128_t *)array, size / 2);
}

Here is the call graph for this function:

dsfmt_gen_rand_all()

void dsfmt_gen_rand_all

(

dsfmt_t *

dsfmt

)

This function fills the internal state array with double precision floating point pseudorandom numbers of the IEEE 754 format.

Parameters

dsfmt

dsfmt state vector.

Definition at line 510 of file dSFMT.c.

References do_recursion().

                                        {
    int i;
    w128_t lung;

    lung = dsfmt->status[DSFMT_N];
    do_recursion(&dsfmt->status[0], &dsfmt->status[0],
                 &dsfmt->status[DSFMT_POS1], &lung);
    for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
        do_recursion(&dsfmt->status[i], &dsfmt->status[i],
                     &dsfmt->status[i + DSFMT_POS1], &lung);
    }
    for (; i < DSFMT_N; i++) {
        do_recursion(&dsfmt->status[i], &dsfmt->status[i],
                     &dsfmt->status[i + DSFMT_POS1 - DSFMT_N], &lung);
    }
    dsfmt->status[DSFMT_N] = lung;
}

Here is the call graph for this function:

dsfmt_get_idstring()

const char* dsfmt_get_idstring

(

void

)

This function returns the identification string. The string shows the Mersenne exponent, and all parameters of this generator.

Returns

id string.

Definition at line 492 of file dSFMT.c.

                                     {
    return DSFMT_IDSTR;
}

dsfmt_get_min_array_size()

int dsfmt_get_min_array_size

(

void

)

This function returns the minimum size of array used for fill_array functions.

Returns

minimum size of array used for fill_array functions.

Definition at line 501 of file dSFMT.c.

                                   {
    return DSFMT_N64;
}

gen_rand_array_c0o1()

static void gen_rand_array_c0o1 ( dsfmt_t *  dsfmt, w128_t *  array, int  size  )

inlinestatic

This function fills the user-specified array with double precision floating point pseudorandom numbers of the IEEE 754 format.

Parameters

dsfmt	dsfmt state vector.
array	an 128-bit array to be filled by pseudorandom numbers.
size	number of 128-bit pseudorandom numbers to be generated.

Definition at line 282 of file dSFMT.c.

References convert_c0o1(), and do_recursion().

Referenced by dsfmt_fill_array_close_open().

                                                 {
    int i, j;
    w128_t lung;

    lung = dsfmt->status[DSFMT_N];
    do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1],
                 &lung);
    for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &dsfmt->status[i + DSFMT_POS1], &lung);
    }
    for (; i < DSFMT_N; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
    }
    for (; i < size - DSFMT_N; i++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        convert_c0o1(&array[i - DSFMT_N]);
    }
    for (j = 0; j < 2 * DSFMT_N - size; j++) {
        dsfmt->status[j] = array[j + size - DSFMT_N];
    }
    for (; i < size; i++, j++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        dsfmt->status[j] = array[i];
        convert_c0o1(&array[i - DSFMT_N]);
    }
    for (i = size - DSFMT_N; i < size; i++) {
        convert_c0o1(&array[i]);
    }
    dsfmt->status[DSFMT_N] = lung;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gen_rand_array_c1o2()

static void gen_rand_array_c1o2 ( dsfmt_t *  dsfmt, w128_t *  array, int  size  )

inlinestatic

This function fills the user-specified array with double precision floating point pseudorandom numbers of the IEEE 754 format.

Parameters

dsfmt	dsfmt state vector.
array	an 128-bit array to be filled by pseudorandom numbers.
size	number of 128-bit pseudorandom numbers to be generated.

Definition at line 244 of file dSFMT.c.

References do_recursion().

Referenced by dsfmt_fill_array_close1_open2().

                                                 {
    int i, j;
    w128_t lung;

    lung = dsfmt->status[DSFMT_N];
    do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1],
                 &lung);
    for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &dsfmt->status[i + DSFMT_POS1], &lung);
    }
    for (; i < DSFMT_N; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
    }
    for (; i < size - DSFMT_N; i++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
    }
    for (j = 0; j < 2 * DSFMT_N - size; j++) {
        dsfmt->status[j] = array[j + size - DSFMT_N];
    }
    for (; i < size; i++, j++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        dsfmt->status[j] = array[i];
    }
    dsfmt->status[DSFMT_N] = lung;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gen_rand_array_o0c1()

static void gen_rand_array_o0c1 ( dsfmt_t *  dsfmt, w128_t *  array, int  size  )

inlinestatic

This function fills the user-specified array with double precision floating point pseudorandom numbers of the IEEE 754 format.

Parameters

dsfmt	dsfmt state vector.
array	an 128-bit array to be filled by pseudorandom numbers.
size	number of 128-bit pseudorandom numbers to be generated.

Definition at line 368 of file dSFMT.c.

References convert_o0c1(), and do_recursion().

Referenced by dsfmt_fill_array_open_close().

                                                 {
    int i, j;
    w128_t lung;

    lung = dsfmt->status[DSFMT_N];
    do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1],
                 &lung);
    for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &dsfmt->status[i + DSFMT_POS1], &lung);
    }
    for (; i < DSFMT_N; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
    }
    for (; i < size - DSFMT_N; i++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        convert_o0c1(&array[i - DSFMT_N]);
    }
    for (j = 0; j < 2 * DSFMT_N - size; j++) {
        dsfmt->status[j] = array[j + size - DSFMT_N];
    }
    for (; i < size; i++, j++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        dsfmt->status[j] = array[i];
        convert_o0c1(&array[i - DSFMT_N]);
    }
    for (i = size - DSFMT_N; i < size; i++) {
        convert_o0c1(&array[i]);
    }
    dsfmt->status[DSFMT_N] = lung;
}

Here is the call graph for this function:

Here is the caller graph for this function:

gen_rand_array_o0o1()

static void gen_rand_array_o0o1 ( dsfmt_t *  dsfmt, w128_t *  array, int  size  )

inlinestatic

This function fills the user-specified array with double precision floating point pseudorandom numbers of the IEEE 754 format.

Parameters

dsfmt	dsfmt state vector.
array	an 128-bit array to be filled by pseudorandom numbers.
size	number of 128-bit pseudorandom numbers to be generated.

Definition at line 325 of file dSFMT.c.

References convert_o0o1(), and do_recursion().

Referenced by dsfmt_fill_array_open_open().

                                                 {
    int i, j;
    w128_t lung;

    lung = dsfmt->status[DSFMT_N];
    do_recursion(&array[0], &dsfmt->status[0], &dsfmt->status[DSFMT_POS1],
                 &lung);
    for (i = 1; i < DSFMT_N - DSFMT_POS1; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &dsfmt->status[i + DSFMT_POS1], &lung);
    }
    for (; i < DSFMT_N; i++) {
        do_recursion(&array[i], &dsfmt->status[i],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
    }
    for (; i < size - DSFMT_N; i++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        convert_o0o1(&array[i - DSFMT_N]);
    }
    for (j = 0; j < 2 * DSFMT_N - size; j++) {
        dsfmt->status[j] = array[j + size - DSFMT_N];
    }
    for (; i < size; i++, j++) {
        do_recursion(&array[i], &array[i - DSFMT_N],
                     &array[i + DSFMT_POS1 - DSFMT_N], &lung);
        dsfmt->status[j] = array[i];
        convert_o0o1(&array[i - DSFMT_N]);
    }
    for (i = size - DSFMT_N; i < size; i++) {
        convert_o0o1(&array[i]);
    }
    dsfmt->status[DSFMT_N] = lung;
}

Here is the call graph for this function:

Here is the caller graph for this function:

idxof()

static int idxof ( int  i )

inlinestatic

This function simulate a 32-bit array index overlapped to 64-bit array of LITTLE ENDIAN in BIG ENDIAN machine.

Definition at line 65 of file dSFMT.c.

References do_recursion().

Referenced by dsfmt_chk_init_by_array(), and dsfmt_chk_init_gen_rand().

                               {
    return i;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ini_func1()

static uint32_t ini_func1 ( uint32_t  x )

inlinestatic

This function represents a function used in the initialization by init_by_array

Parameters

x	32-bit integer

Returns

32-bit integer

Definition at line 410 of file dSFMT.c.

Referenced by dsfmt_chk_init_by_array().

                                      {
    return (x ^ (x >> 27)) * (uint32_t)1664525UL;
}

Here is the caller graph for this function:

ini_func2()

static uint32_t ini_func2 ( uint32_t  x )

inlinestatic

This function represents a function used in the initialization by init_by_array

Parameters

x	32-bit integer

Returns

32-bit integer

Definition at line 420 of file dSFMT.c.

Referenced by dsfmt_chk_init_by_array().

                                      {
    return (x ^ (x >> 27)) * (uint32_t)1566083941UL;
}

Here is the caller graph for this function:

initial_mask()

static void initial_mask ( dsfmt_t *  dsfmt )

static

This function initializes the internal state array to fit the IEEE 754 format.

Parameters

dsfmt

dsfmt state vector.

Definition at line 429 of file dSFMT.c.

Referenced by dsfmt_chk_init_by_array(), and dsfmt_chk_init_gen_rand().

                                         {
    int i;
    uint64_t *psfmt;

    psfmt = &dsfmt->status[0].u[0];
    for (i = 0; i < DSFMT_N * 2; i++) {
        psfmt[i] = (psfmt[i] & DSFMT_LOW_MASK) | DSFMT_HIGH_CONST;
    }
}

Here is the caller graph for this function:

period_certification()

static void period_certification ( dsfmt_t *  dsfmt )

static

This function certificate the period of 2^{SFMT_MEXP}-1.

Parameters

dsfmt

dsfmt state vector.

Definition at line 443 of file dSFMT.c.

Referenced by dsfmt_chk_init_by_array(), and dsfmt_chk_init_gen_rand().

                                                 {
    uint64_t pcv[2] = {DSFMT_PCV1, DSFMT_PCV2};
    uint64_t tmp[2];
    uint64_t inner;
    int i;
#if (DSFMT_PCV2 & 1) != 1
    int j;
    uint64_t work;
#endif

    tmp[0] = (dsfmt->status[DSFMT_N].u[0] ^ DSFMT_FIX1);
    tmp[1] = (dsfmt->status[DSFMT_N].u[1] ^ DSFMT_FIX2);

    inner = tmp[0] & pcv[0];
    inner ^= tmp[1] & pcv[1];
    for (i = 32; i > 0; i >>= 1) {
        inner ^= inner >> i;
    }
    inner &= 1;
    /* check OK */
    if (inner == 1) {
        return;
    }
    /* check NG, and modification */
#if (DSFMT_PCV2 & 1) == 1
    dsfmt->status[DSFMT_N].u[1] ^= 1;
#else
    for (i = 1; i >= 0; i--) {
      work = 1;
      for (j = 0; j < 64; j++) {
        if ((work & pcv[i]) != 0) {
          dsfmt->status[DSFMT_N].u[i] ^= work;
          return;
        }
        work = work << 1;
      }
    }
#endif
    return;
}

Here is the caller graph for this function:

Variable Documentation

dsfmt_global_data

dsfmt_t dsfmt_global_data

dsfmt internal state vector

Definition at line 21 of file dSFMT.c.

dsfmt_mexp

const int dsfmt_mexp = DSFMT_MEXP

static

dsfmt mexp for check

Definition at line 23 of file dSFMT.c.

Referenced by dsfmt_chk_init_by_array(), and dsfmt_chk_init_gen_rand().