urng.h

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/rng/urng.h
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013,2014, Yan Zhou
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//============================================================================

#ifndef VSMC_RNG_URNG_H
#define VSMC_RNG_URNG_H


#include <vsmc/rng/internal/common.h>
#include <Random123/threefry.h>
#include <Random123/philox.h>

#define VSMC_DEFINE_RNG_URNG_RNG_T(RNG, N, W) \
    typedef struct {                                                         \
        RNG##N##x##W##_key_t key;                                            \
        RNG##N##x##W##_ctr_t ctr;                                            \
        RNG##N##x##W##_ctr_t rnd;                                            \
        unsigned char remain;                                                \
    } RNG##N##x##W##_rng_t;

#define VSMC_DEFINE_RNG_URNG_INIT(RNG, N, W) \
    VSMC_STATIC_INLINE void RNG##N##x##W##_init(                             \
            RNG##N##x##W##_rng_t *rng, uint##W##_t seed)                     \
    {                                                                        \
        RNG##N##x##W##_ctr_t init_ctr = {{}};                                \
        RNG##N##x##W##_ukey_t ukey = {{}};                                   \
        rng->ctr = init_ctr;                                                 \
        rng->rnd = init_ctr;                                                 \
        ukey.v[0] = seed;                                                    \
        rng->key = RNG##N##x##W##keyinit(ukey);                              \
        rng->remain = 0;                                                     \
    }

#define VSMC_DEFINE_RNG_URNG_RAND(RNG, N, W) \
    VSMC_STATIC_INLINE uint##W##_t RNG##N##x##W##_rand(                      \
            RNG##N##x##W##_rng_t *rng)                                       \
    {                                                                        \
        unsigned char remain = rng->remain;                                  \
        RNG##N##x##W##_ctr_t rnd = rng->rnd;                                 \
                                                                             \
        if (remain > 0) {                                                    \
            --remain;                                                        \
            rng->remain = remain;                                            \
            return rnd.v[remain];                                            \
        }                                                                    \
                                                                             \
        RNG##N##x##W##_ctr_t ctr = rng->ctr;                                 \
        RNG##N##x##W##_key_t key = rng->key;                                 \
                                                                             \
        remain = N - 1;                                                      \
        ctr.v[0]++;                                                          \
        rnd = RNG##N##x##W(ctr, key);                                        \
                                                                             \
        rng->remain = remain;                                                \
        rng->rnd = rnd;                                                      \
        rng->ctr = ctr;                                                      \
        rng->key = key;                                                      \
                                                                             \
        return rnd.v[remain];                                                \
    }

VSMC_DEFINE_RNG_URNG_RNG_T(threefry, 2, 32)
VSMC_DEFINE_RNG_URNG_RNG_T(threefry, 4, 32)
VSMC_DEFINE_RNG_URNG_RNG_T(threefry, 2, 64)
VSMC_DEFINE_RNG_URNG_RNG_T(threefry, 4, 64)

VSMC_DEFINE_RNG_URNG_INIT(threefry, 2, 32)
VSMC_DEFINE_RNG_URNG_INIT(threefry, 4, 32)
VSMC_DEFINE_RNG_URNG_INIT(threefry, 2, 64)
VSMC_DEFINE_RNG_URNG_INIT(threefry, 4, 64)

VSMC_DEFINE_RNG_URNG_RAND(threefry, 2, 32)
VSMC_DEFINE_RNG_URNG_RAND(threefry, 4, 32)
VSMC_DEFINE_RNG_URNG_RAND(threefry, 2, 64)
VSMC_DEFINE_RNG_URNG_RAND(threefry, 4, 64)

VSMC_DEFINE_RNG_URNG_RNG_T(philox, 2, 32)
VSMC_DEFINE_RNG_URNG_RNG_T(philox, 4, 32)
VSMC_DEFINE_RNG_URNG_RNG_T(philox, 2, 64)
VSMC_DEFINE_RNG_URNG_RNG_T(philox, 4, 64)

VSMC_DEFINE_RNG_URNG_INIT(philox, 2, 32)
VSMC_DEFINE_RNG_URNG_INIT(philox, 4, 32)
VSMC_DEFINE_RNG_URNG_INIT(philox, 2, 64)
VSMC_DEFINE_RNG_URNG_INIT(philox, 4, 64)

VSMC_DEFINE_RNG_URNG_RAND(philox, 2, 32)
VSMC_DEFINE_RNG_URNG_RAND(philox, 4, 32)
VSMC_DEFINE_RNG_URNG_RAND(philox, 2, 64)
VSMC_DEFINE_RNG_URNG_RAND(philox, 4, 64)

#if VSMC_USE_PHILOX_CBURNG
typedef philox2x32_rng_t cburng2x32_rng_t;
typedef philox4x32_rng_t cburng4x32_rng_t;
typedef philox2x64_rng_t cburng2x64_rng_t;
typedef philox4x64_rng_t cburng4x64_rng_t;
#define cburng2x32_init philox2x32_init
#define cburng4x32_init philox4x32_init
#define cburng2x64_init philox2x64_init
#define cburng4x64_init philox4x64_init
#define cburng2x32_rand philox2x32_rand
#define cburng4x32_rand philox4x32_rand
#define cburng2x64_rand philox2x64_rand
#define cburng4x64_rand philox4x64_rand
#else // VSMC_USE_PHILOX_CBURNG
typedef threefry2x32_rng_t cburng2x32_rng_t;
typedef threefry4x32_rng_t cburng4x32_rng_t;
typedef threefry2x64_rng_t cburng2x64_rng_t;
typedef threefry4x64_rng_t cburng4x64_rng_t;
#define cburng2x32_init threefry2x32_init
#define cburng4x32_init threefry4x32_init
#define cburng2x64_init threefry2x64_init
#define cburng4x64_init threefry4x64_init
#define cburng2x32_rand threefry2x32_rand
#define cburng4x32_rand threefry4x32_rand
#define cburng2x64_rand threefry2x64_rand
#define cburng4x64_rand threefry4x64_rand
#endif // VSMC_USE_PHILOX_CBURNG

#endif // VSMC_RNG_URNG_H