vSMCDoc/develop/rng__define__macro_8hpp_source.html

 //============================================================================
 // vSMC/include/rng/internal/rng_define_macro.hpp
 //----------------------------------------------------------------------------
 //                         vSMC: Scalable Monte Carlo
 //----------------------------------------------------------------------------
 // Copyright (c) 2013-2016, 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_DEFINE_MACRO_NA
 #define VSMC_RNG_DEFINE_MACRO_NA(RNGType, Name, name)
 #endif

 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox2x32, Philox2x32, philox2x32)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox4x32, Philox4x32, philox4x32)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox2x64, Philox2x64, philox2x64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox4x64, Philox4x64, philox4x64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox2x32_64, Philox2x32_64, philox2x32_64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox4x32_64, Philox4x32_64, philox4x32_64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox2x64_64, Philox2x64_64, philox2x64_64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Philox4x64_64, Philox4x64_64, philox4x64_64)

 VSMC_RNG_DEFINE_MACRO(::vsmc::Threefry2x32, Threefry2x32, threefry2x32)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Threefry4x32, Threefry4x32, threefry4x32)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Threefry2x64, Threefry2x64, threefry2x64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Threefry4x64, Threefry4x64, threefry4x64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Threefry8x64, Threefry8x64, threefry8x64)
 VSMC_RNG_DEFINE_MACRO(::vsmc::Threefry16x64, Threefry16x64, threefry16x64)
 VSMC_RNG_DEFINE_MACRO(
     ::vsmc::Threefry2x32_64, Threefry2x32_64, threefry2x32_64)
 VSMC_RNG_DEFINE_MACRO(
     ::vsmc::Threefry4x32_64, Threefry4x32_64, threefry4x32_64)
 VSMC_RNG_DEFINE_MACRO(
     ::vsmc::Threefry2x64_64, Threefry2x64_64, threefry2x64_64)
 VSMC_RNG_DEFINE_MACRO(
     ::vsmc::Threefry4x64_64, Threefry4x64_64, threefry4x64_64)
 VSMC_RNG_DEFINE_MACRO(
     ::vsmc::Threefry8x64_64, Threefry8x64_64, threefry8x64_64)
 VSMC_RNG_DEFINE_MACRO(
     ::vsmc::Threefry16x64_64, Threefry16x64_64, threefry16x64_64)

 #if VSMC_HAS_AES_NI
 #define VSMC_RNG_DEFINE_MACRO_AES_NI VSMC_RNG_DEFINE_MACRO
 #else
 #define VSMC_RNG_DEFINE_MACRO_AES_NI VSMC_RNG_DEFINE_MACRO_NA
 #endif

 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x1, AES128x1, aes128x1)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x2, AES128x2, aes128x2)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x4, AES128x4, aes128x4)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x8, AES128x8, aes128x8)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x1_64, AES128x1_64, aes128x1_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x2_64, AES128x2_64, aes128x2_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x4_64, AES128x4_64, aes128x4_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES128x8_64, AES128x8_64, aes128x8_64)

 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x1, AES192x1, aes192x1)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x2, AES192x2, aes192x2)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x4, AES192x4, aes192x4)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x8, AES192x8, aes192x8)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x1_64, AES192x1_64, aes192x1_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x2_64, AES192x2_64, aes192x2_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x4_64, AES192x4_64, aes192x4_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES192x8_64, AES192x8_64, aes192x8_64)

 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x1, AES256x1, aes256x1)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x2, AES256x2, aes256x2)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x4, AES256x4, aes256x4)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x8, AES256x8, aes256x8)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x1_64, AES256x1_64, aes256x1_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x2_64, AES256x2_64, aes256x2_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x4_64, AES256x4_64, aes256x4_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::AES256x8_64, AES256x8_64, aes256x8_64)

 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx1, ARSx1, arsx1)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx2, ARSx2, arsx2)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx4, ARSx4, arsx4)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx8, ARSx8, arsx8)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx1_64, ARSx1_64, arsx1_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx2_64, ARSx2_64, arsx2_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx4_64, ARSx4_64, arsx4_64)
 VSMC_RNG_DEFINE_MACRO_AES_NI(::vsmc::ARSx8_64, ARSx8_64, arsx8_64)

 #undef VSMC_RNG_DEFINE_MACRO_AES_NI

 #if VSMC_HAS_RDRAND
 #define VSMC_RNG_DEFINE_MACRO_RDRAND VSMC_RNG_DEFINE_MACRO
 #else
 #define VSMC_RNG_DEFINE_MACRO_RDRAND VSMC_RNG_DEFINE_MACRO_NA
 #endif

 VSMC_RNG_DEFINE_MACRO_RDRAND(::vsmc::RDRAND16, RDRAND16, rdrand16)
 VSMC_RNG_DEFINE_MACRO_RDRAND(::vsmc::RDRAND32, RDRAND32, rdrand32)
 VSMC_RNG_DEFINE_MACRO_RDRAND(::vsmc::RDRAND64, RDRAND64, rdrand64)

 #undef VSMC_RNG_DEFINE_MACRO_RDRAND
vsmc::RDRANDEngine
RDRAND generator.
Definition: rdrand.hpp:98

vsmc::AES192x2
AES192Engine< std::uint32_t, 12, 2 > AES192x2
AES-192 RNG engine with 32-bit integers output, 2 blocks.
Definition: aes_ni.hpp:1096

vsmc
Definition: monitor.hpp:48

vsmc::AES128x2_64
AES128Engine< std::uint64_t, 10, 2 > AES128x2_64
AES-128 RNG engine with 64-bit integers output, 2 blocks.
Definition: aes_ni.hpp:1073

vsmc::AES256x4_64
AES256Engine< std::uint64_t, 14, 4 > AES256x4_64
AES-256 RNG engine with 64-bit integers output, 4 blocks.
Definition: aes_ni.hpp:1156

VSMC_RNG_DEFINE_MACRO_AES_NI
#define VSMC_RNG_DEFINE_MACRO_AES_NI

vsmc::AES256x8
AES256Engine< std::uint32_t, 14, 8 > AES256x8
AES-256 RNG engine with 32-bit integers output, 8 blocks.
Definition: aes_ni.hpp:1144

vsmc::AES192x2_64
AES192Engine< std::uint64_t, 12, 2 > AES192x2_64
AES-192 RNG engine with 64-bit integers output, 2 blocks.
Definition: aes_ni.hpp:1112

vsmc::AES256x1_64
AES256Engine< std::uint64_t, 14, 1 > AES256x1_64
AES-256 RNG engine with 64-bit integers output, 1 block.
Definition: aes_ni.hpp:1148

vsmc::Philox4x32_64
Philox4x32Engine< std::uint64_t > Philox4x32_64
Philox4x32 RNG engine with 64-bit integer output.
Definition: philox.hpp:574

vsmc::ARSx8
ARSEngine< std::uint32_t, 5, 8 > ARSx8
ARS RNG engine with 32-bit integers output, 8 blocks and default rounds.
Definition: aes_ni.hpp:1188

vsmc::Philox2x64_64
Philox2x64Engine< std::uint64_t > Philox2x64_64
Philox2x64 RNG engine with 64-bit integer output.
Definition: philox.hpp:578

VSMC_RNG_DEFINE_MACRO_RDRAND
#define VSMC_RNG_DEFINE_MACRO_RDRAND

vsmc::Threefry4x32_64
Threefry4x32Engine< std::uint64_t > Threefry4x32_64
Threefry4x32 RNG engine with 64-bit integer output.
Definition: threefry.hpp:646

vsmc::AES192x8_64
AES192Engine< std::uint64_t, 12, 8 > AES192x8_64
AES-192 RNG engine with 64-bit integers output, 8 blocks.
Definition: aes_ni.hpp:1120

vsmc::Threefry2x32
Threefry2x32Engine< std::uint32_t > Threefry2x32
Threefry2x32 RNG engine with 32-bit integer output.
Definition: threefry.hpp:618

vsmc::AES128x1
AES128Engine< std::uint32_t, 10, 1 > AES128x1
AES-128 RNG engine with 32-bit integers output, 1 block.
Definition: aes_ni.hpp:1053

vsmc::RDRAND64
RDRANDEngine< std::uint64_t > RDRAND64
C++11 Engine using 64-bit RDRAND instruction.
Definition: rdrand.hpp:218

vsmc::CounterEngine
Counter based RNG engine.
Definition: counter.hpp:187

vsmc::AES128x4
AES128Engine< std::uint32_t, 10, 4 > AES128x4
AES-128 RNG engine with 32-bit integers output, 4 blocks.
Definition: aes_ni.hpp:1061

vsmc::AES256x8_64
AES256Engine< std::uint64_t, 14, 8 > AES256x8_64
AES-256 RNG engine with 64-bit integers output, 8 blocks.
Definition: aes_ni.hpp:1160

vsmc::ARSx2
ARSEngine< std::uint32_t, 5, 2 > ARSx2
ARS RNG engine with 32-bit integers output, 2 blocks and default rounds.
Definition: aes_ni.hpp:1178

vsmc::AES192x1
AES192Engine< std::uint32_t, 12, 1 > AES192x1
AES-192 RNG engine with 32-bit integers output, 1 block.
Definition: aes_ni.hpp:1092

vsmc::AES256x2
AES256Engine< std::uint32_t, 14, 2 > AES256x2
AES-256 RNG engine with 32-bit integers output, 2 blocks.
Definition: aes_ni.hpp:1136

vsmc::ARSx1
ARSEngine< std::uint32_t, 5, 1 > ARSx1
ARS RNG engine with 32-bit integers output, 1 block and default rounds.
Definition: aes_ni.hpp:1173

vsmc::Threefry8x64
Threefry8x64Engine< std::uint32_t > Threefry8x64
Threefry8x64 RNG engine with 32-bit integer output.
Definition: threefry.hpp:634

vsmc::AES192x1_64
AES192Engine< std::uint64_t, 12, 1 > AES192x1_64
AES-192 RNG engine with 64-bit integers output, 1 block.
Definition: aes_ni.hpp:1108

vsmc::ARSx4_64
ARSEngine< std::uint64_t, 5, 4 > ARSx4_64
ARS RNG engine with 64-bit integers output, 4 blocks and default rounds.
Definition: aes_ni.hpp:1203

vsmc::AES256x4
AES256Engine< std::uint32_t, 14, 4 > AES256x4
AES-256 RNG engine with 32-bit integers output, 4 blocks.
Definition: aes_ni.hpp:1140

vsmc::Philox4x64_64
Philox4x64Engine< std::uint64_t > Philox4x64_64
Philox4x64 RNG engine with 64-bit integer output.
Definition: philox.hpp:582

vsmc::AES128x4_64
AES128Engine< std::uint64_t, 10, 4 > AES128x4_64
AES-128 RNG engine with 64-bit integers output, 4 blocks.
Definition: aes_ni.hpp:1077

vsmc::Threefry16x64_64
Threefry16x64Engine< std::uint64_t > Threefry16x64_64
Threefry16x64 RNG engine with 64-bit integer output.
Definition: threefry.hpp:662

vsmc::Threefry2x64_64
Threefry2x64Engine< std::uint64_t > Threefry2x64_64
Threefry2x64 RNG engine with 64-bit integer output.
Definition: threefry.hpp:650

vsmc::ARSx2_64
ARSEngine< std::uint64_t, 5, 2 > ARSx2_64
ARS RNG engine with 64-bit integers output, 2 blocks and default rounds.
Definition: aes_ni.hpp:1198

vsmc::Threefry8x64_64
Threefry8x64Engine< std::uint64_t > Threefry8x64_64
Threefry8x64 RNG engine with 64-bit integer output.
Definition: threefry.hpp:658

vsmc::Philox2x32
Philox2x32Engine< std::uint32_t > Philox2x32
Philox2x32 RNG engine with 32-bit integer output.
Definition: philox.hpp:554

vsmc::AES256x2_64
AES256Engine< std::uint64_t, 14, 2 > AES256x2_64
AES-256 RNG engine with 64-bit integers output, 2 blocks.
Definition: aes_ni.hpp:1152

vsmc::Philox4x32
Philox4x32Engine< std::uint32_t > Philox4x32
Philox4x32 RNG engine with 32-bit integer output.
Definition: philox.hpp:558

vsmc::AES192x4
AES192Engine< std::uint32_t, 12, 4 > AES192x4
AES-192 RNG engine with 32-bit integers output, 4 blocks.
Definition: aes_ni.hpp:1100

vsmc::Philox2x32_64
Philox2x32Engine< std::uint64_t > Philox2x32_64
Philox2x32 RNG engine with 64-bit integer output.
Definition: philox.hpp:570

vsmc::ARSx8_64
ARSEngine< std::uint64_t, 5, 8 > ARSx8_64
ARS RNG engine with 64-bit integers output, 8 blocks and default rounds.
Definition: aes_ni.hpp:1208

vsmc::ARSx4
ARSEngine< std::uint32_t, 5, 4 > ARSx4
ARS RNG engine with 32-bit integers output, 4 blocks and default rounds.
Definition: aes_ni.hpp:1183

vsmc::RDRAND32
RDRANDEngine< std::uint32_t > RDRAND32
C++11 Engine using 32-bit RDRAND instruction.
Definition: rdrand.hpp:214

vsmc::Threefry2x64
Threefry2x64Engine< std::uint32_t > Threefry2x64
Threefry2x64 RNG engine with 32-bit integer output.
Definition: threefry.hpp:626

vsmc::RDRAND16
RDRANDEngine< std::uint16_t > RDRAND16
C++11 Engine using 16-bit RDRAND instruction.
Definition: rdrand.hpp:210

vsmc::ARSx1_64
ARSEngine< std::uint64_t, 5, 1 > ARSx1_64
ARS RNG engine with 64-bit integers output, 1 block and default rounds.
Definition: aes_ni.hpp:1193

vsmc::AES192x4_64
AES192Engine< std::uint64_t, 12, 4 > AES192x4_64
AES-192 RNG engine with 64-bit integers output, 4 blocks.
Definition: aes_ni.hpp:1116

vsmc::AES128x2
AES128Engine< std::uint32_t, 10, 2 > AES128x2
AES-128 RNG engine with 32-bit integers output, 2 blocks.
Definition: aes_ni.hpp:1057

vsmc::Threefry16x64
Threefry16x64Engine< std::uint32_t > Threefry16x64
Threefry16x64 RNG engine with 32-bit integer output.
Definition: threefry.hpp:638

vsmc::AES256x1
AES256Engine< std::uint32_t, 14, 1 > AES256x1
AES-256 RNG engine with 32-bit integers output, 1 block.
Definition: aes_ni.hpp:1132

vsmc::Threefry4x64
Threefry4x64Engine< std::uint32_t > Threefry4x64
Threefry4x64 RNG engine with 32-bit integer output.
Definition: threefry.hpp:630

vsmc::Philox2x64
Philox2x64Engine< std::uint32_t > Philox2x64
Philox2x64 RNG engine with 32-bit integer output.
Definition: philox.hpp:562

vsmc::Philox4x64
Philox4x64Engine< std::uint32_t > Philox4x64
Philox4x64 RNG engine with 32-bit integer output.
Definition: philox.hpp:566

vsmc::AES192x8
AES192Engine< std::uint32_t, 12, 8 > AES192x8
AES-192 RNG engine with 32-bit integers output, 8 blocks.
Definition: aes_ni.hpp:1104

vsmc::AES128x1_64
AES128Engine< std::uint64_t, 10, 1 > AES128x1_64
AES-128 RNG engine with 64-bit integers output, 1 block.
Definition: aes_ni.hpp:1069

vsmc::Threefry4x32
Threefry4x32Engine< std::uint32_t > Threefry4x32
Threefry4x32 RNG engine with 32-bit integer output.
Definition: threefry.hpp:622

vsmc::Threefry4x64_64
Threefry4x64Engine< std::uint64_t > Threefry4x64_64
Threefry4x64 RNG engine with 64-bit integer output.
Definition: threefry.hpp:654

vsmc::AES128x8_64
AES128Engine< std::uint64_t, 10, 8 > AES128x8_64
AES-128 RNG engine with 64-bit integers output, 8 blocks.
Definition: aes_ni.hpp:1081

vsmc::AES128x8
AES128Engine< std::uint32_t, 10, 8 > AES128x8
AES-128 RNG engine with 32-bit integers output, 8 blocks.
Definition: aes_ni.hpp:1065

vsmc::Threefry2x32_64
Threefry2x32Engine< std::uint64_t > Threefry2x32_64
Threefry2x32 RNG engine with 64-bit integer output.
Definition: threefry.hpp:642