［前：rdrandをtestU01とPractRandで検定する］［ExRand目次］［次：SplitMix64とXorshiftを組み合わせる］

[SNC]SplitMix64について

[SNC]SplitMix64について
SplitMix64をtestU01で検定する
SplitMix64をPractRandで検定する
[SSC]組込み関数を使ったSSE2バージョン
[SSB]機械語を使ったSSE2バージョン
[SAC]組込み関数を使ったAVX2バージョン
[SAB]機械語を使ったAVX2バージョン
[SBC]組込み関数を使ったAVX512バージョン
[SBB]機械語を使ったAVX512バージョン

[SNC]SplitMix64について

状態の大きさが６４ビットの高速で質の高い疑似乱数 SplitMix64 があります。

SplitMix64 https://github.com/svaarala/duktape/blob/master/misc/splitmix64.c

以下は SplitMix64 をマルチスレッド用に書き替え、逆順とジャンプを加えたものです。

多くのコンパイラでコンパイル可能です。

/* snc.h
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2022
*/
#if !defined(SNC_H__)
 #define SNC_H__
 #include "define.h"
 #include <math.h>

typedef qword Snc_t;

static __inline qword SncRand(Snc_t*p)
{ return SplitMixFinal(*p+=GOLDEN_GAMMA); }

static __inline qword SncBack(Snc_t*p)
{ qword z=*p; *p-=GOLDEN_GAMMA; return SplitMixFinal(z); }

static void SncJump(Snc_t*p,double lag) {
    Snc_t add=GOLDEN_GAMMA;
    if (lag<0.0) { lag=-lag; add=-(sqword)add; }
    for (;lag;add+=add) if (modf(lag/2,&lag)) *p+=add;
}

static const char*SncInitByStr(Snc_t*p,const char*key);

static const char*SncInit(Snc_t*p,qword s) {
 #if defined(__GNUC__)
    (void)SncInitByStr; (void)SncJump;
 #endif
    *p=s; return 0;
}

static const char*SncInitByStr(Snc_t*p,const char*key) {
    qword crc=~(qword)0; int j;
 #if defined(__GNUC__)
    (void)SncInit; (void)SncJump;
 #endif
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    *p=crc; return 0;
}

#endif

#if !defined(ExRand)
 #define ExRand      SncRand
 #define ExBack      SncBack
 #define ExName     "SncRand"
 #define ExBName    "SncBack"
 #define ExInit      SncInit
 #define ExInitByStr SncInitByStr
 #define ExJump      SncJump
 #define ExSExp      0
 #define Ex_t        Snc_t
 #define ExAlign     8
#endif

これは状態の大きさが６４ビットしかないので、周期が短いという欠点があります。
そこで SplitMix64 のコメントにはマルチスレッドでは xoroshiro128+ を、
大規模な計算では xorshift1024* を使うように勧めています。
しかし、この２つの疑似乱数は、
testingRNG : testing popular random-number generators(https://github.com/lemire/testingRNG) で
検定に失敗すると書かれています。

SplitMix64をtestU01で検定する

SplitMix64 を rdrand と同じように testU01 で検定しました。
第１０世代の Core i5-10500T＋Windows11 23H2 で約２０時間かかりました。

type                 , c, test                      , p-value 
SncRand rawhi Seed(1), B, RandomWalk1 C(L=10000,r=0), 0.9994  
SncRand rawhi Seed(2), B, Passed                    , -       
SncRand rawhi Seed(3), B, WeightDistrib,r=0         , 7.9e-5  
SncRand rawhi Seed(4), B, Passed                    , -       
SncRand rawhi Seed(5), B, Passed                    , -       
SncRand rawhi Seed(6), B, Gap,r=20                  , 0.9991  
-                    , B, RandomWalk1 C(L=10000,r=0), 7.1e-4  
SncRand rawlo Seed(1), B, Passed                    , -       
SncRand rawlo Seed(2), B, Passed                    , -       
SncRand rawlo Seed(3), B, Passed                    , -       
SncRand rawlo Seed(4), B, Passed                    , -       
SncRand rawlo Seed(5), B, AppearanceSpacings,r=27   , 9.2e-4  
SncRand rawlo Seed(6), B, ClosePairs mNP,t=16       , 5.9e-4  
SncRand revhi Seed(1), B, Passed                    , -       
SncRand revhi Seed(2), B, ClosePairs mNP2S,t=5      , 1-1.4e-5
SncRand revhi Seed(3), B, MaxOft,t=32               , 0.9995  
-                    , B, AutoCor,d=3,r=27          , 5.6e-4  
SncRand revhi Seed(4), B, Passed                    , -       
SncRand revhi Seed(5), B, Passed                    , -       
SncRand revhi Seed(6), B, Passed                    , -       
SncRand revlo Seed(1), B, Passed                    , -       
SncRand revlo Seed(2), B, Passed                    , -       
SncRand revlo Seed(3), B, Passed                    , -       
SncRand revlo Seed(4), B, Passed                    , -       
SncRand revlo Seed(5), B, Passed                    , -       
SncRand revlo Seed(6), B, Passed                    , -       
SncRand swphi Seed(1), B, Passed                    , -       
SncRand swphi Seed(2), B, Passed                    , -       
SncRand swphi Seed(3), B, Passed                    , -       
SncRand swphi Seed(4), B, BirthdaySpacings,t=16     , 0.9995  
SncRand swphi Seed(5), B, Passed                    , -       
SncRand swphi Seed(6), B, Passed                    , -       
SncRand swplo Seed(1), B, MaxOft AD,t=16            , 0.9993  
SncRand swplo Seed(2), B, Passed                    , -       
SncRand swplo Seed(3), B, Passed                    , -       
SncRand swplo Seed(4), B, Passed                    , -       
SncRand swplo Seed(5), B, Passed                    , -       
SncRand swplo Seed(6), B, Passed                    , -

このように rdrand とほぼ同じ品質であることがわかります。

SplitMix64をPractRandで検定する

SplitMix64 も既定の PractRand(folding=standard:-tf 1) では合格しますが、
'RNG_test stdin64 -tf 2 -multithreaded' として(folding=extra:-tf 2)とすると失敗します。

種が１の場合。

RNG_test stdin64 -tlmin 1GB -tf 2 -multithreaded

length= 8 terabytes (2^43 bytes), time= 45280 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/32]Gap-16:B                 R=  +9.2  p =  8.7e-8   very suspicious  

length= 16 terabytes (2^44 bytes), time= 90304 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/32]Gap-16:A                 R= +11.5  p =  6.2e-8   very suspicious  
  [Low8/32]Gap-16:B                 R= +17.7  p =  5.0e-15    FAIL

種が２の場合。

RNG_test stdin64 -tlmin 1GB -tf 2 -multithreaded

length= 8 terabytes (2^43 bytes), time= 45567 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/32]Gap-16:B                 R=  +7.1  p =  5.4e-6   mildly suspicious

length= 16 terabytes (2^44 bytes), time= 90853 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/32]Gap-16:A                 R=  +9.3  p =  1.9e-6   suspicious       
  [Low8/32]Gap-16:B                 R= +15.7  p =  2.7e-13    FAIL

種が３の場合。

RNG_test stdin64 -tlmin 1GB -tf 2 -multithreaded

length= 8 terabytes (2^43 bytes), time= 30360 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/32]Gap-16:A                 R=  +7.6  p =  2.6e-5   mildly suspicious
  [Low8/32]Gap-16:B                 R= +11.3  p =  1.4e-9    VERY SUSPICIOUS 

length= 16 terabytes (2^44 bytes), time= 59639 seconds
  Test Name                         Raw       Processed     Evaluation
  [Low8/32]Gap-16:A                 R= +12.6  p =  1.2e-8   very suspicious  
  [Low8/32]Gap-16:B                 R= +17.4  p =  7.9e-15    FAIL

このように種１，２，３で検定すると不合格になって途中で終わってしまいます。

[SSC]組込み関数を使ったSSE2バージョン

gcc, clang, vc2002 .. vc2022 でコンパイル可能です。

define.h, bincode.h はこちら
bincode.h は Visual C++2002 と Visual C++ 2003 以外では必要ありません。

/* ssc.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2025
SplitMix64.
gcc, clang, vc2002 .. vc2022
*/
#if !defined(SSC_H__)
 #define SSC_H__
 #include <math.h>
 #include "define.h"
 #if !defined(Cpuid)
  #include "bincode.h"
 #endif

 #if !defined(SSCEXP)
  #define SSCEXP 2
 #endif
 #define SSCNUM (1<<SSCEXP)
 #define SSCMUL (1<<(SSCEXP-1))

  /* D=_mm_mullo_epi64(D,A); */
 #define MM_MULLO_EPI64(D,A)  { __m128i w1,w2;          \
    w1=_mm_srli_epi64(A,32);  w2=_mm_srli_epi64(D,32);  \
    w1=_mm_mul_epu32(w1,D);   w2=_mm_mul_epu32(w2,A);   \
    w1=_mm_slli_epi64(w1,32); w2=_mm_slli_epi64(w2,32); \
    w1=_mm_add_epi64(w1,w2);  D=_mm_mul_epu32(D,A);     \
    D=_mm_add_epi64(D,w1); }

 #if defined(__clang__)
  #pragma clang attribute push(__attribute__((target("sse2"))), \
      apply_to=function)
 #elif defined(__GNUC__)
  #pragma GCC push_options
  #pragma GCC target("sse2")
 #endif

typedef struct Ssc_t
{ __m128i ret[SSCMUL],cnt[SSCMUL]; int idx; } Ssc_t;

static const union tagSsc { qword q[2]; __m128i y; }
 SscZADD={{GOLDEN_GAMMA*SSCNUM,GOLDEN_GAMMA*SSCNUM}},
 SscZSMA={{SPLITMIX_A,SPLITMIX_A}},
 SscZSMB={{SPLITMIX_B,SPLITMIX_B}};

GCC_NOINLINE static void SscGenAll(Ssc_t*p,int dir) {
 #if SSCMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m128i sma=SscZSMA.y, smb=SscZSMB.y, add,t,v;
    if (dir>0) add=SscZADD.y;
    else if (dir<0)
    { t=_mm_setzero_si128(); add=_mm_sub_epi64(t,SscZADD.y); }
    else add=_mm_setzero_si128();
 #if SSCMUL > 1
    for (i=0;i<SSCMUL;i++)
 #endif
    {
        t=Load128(p->cnt[i]);
        v=t=_mm_add_epi64(t,add);
        Save128(p->cnt[i],t);
        t=_mm_srli_epi64(t,30);
        t=_mm_xor_si128(t,v);
        MM_MULLO_EPI64(t,sma) v=t;
        t=_mm_srli_epi64(t,27);
        t=_mm_xor_si128(t,v);
        MM_MULLO_EPI64(t,smb) v=t;
        t=_mm_srli_epi64(t,31);
        Save128(p->ret[i],_mm_xor_si128(t,v));
    }
}

 #if defined(__clang__)
  #pragma clang attribute pop
 #elif defined(__GNUC__)
  #pragma GCC pop_options
 #endif

static __inline qword SscRand(Ssc_t*p) {
    int mod=p->idx&((1<<SSCEXP)-1);
    if (mod==0) SscGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword SscBack(Ssc_t*p) {
    int mod=--p->idx&((1<<SSCEXP)-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) SscGenAll(p,-1);
    return ret;
}

static void SscJump(Ssc_t*p,double lag) {
    qword add=GOLDEN_GAMMA; int k=1<<SSCEXP,mod=p->idx&(k-1),back=0,i;
    if (lag<0) { lag=-lag; back=1; add*=-1; mod=1-mod; }
    i=(int)(modf(lag/k,&lag)*k+0.25); add<<=SSCEXP;
    if (back) p->idx-=i; else p->idx+=i;
    if (i+((mod-1)&(k-1))>=k) for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    for (;lag;add+=add) if (modf(lag/2.0,&lag)!=0)
      for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    SscGenAll(p,0);
}

static int SscHaveSse2(void)
{ int v[4]; Cpuid(v,1); return (v[3]>>26)&1; }

static qword SscCrc64(const char*key) {
    qword crc=~(qword)0; int j;
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    return crc;
}

GCC_NOINLINE static void SscInitSub(Ssc_t*p,qword seed);

static const char*SscInit(Ssc_t*p,qword seed) {
    if (SscHaveSse2()==0) return"SSE2";
    SscInitSub(p,seed); return 0;
}

static const char*SscInitByStr(Ssc_t*p,const char*key) {
    if (SscHaveSse2()==0) return"SSE2";
    SscInitSub(p,SscCrc64(key));
    return 0;
}

GCC_NOINLINE static void SscInitSub(Ssc_t*p,qword seed) {
    enum { n=128/64 }; qword gg=GOLDEN_GAMMA; int i,k;
 #if defined(__GNUC__)
    (void)SscInit; (void)SscInitByStr; (void)SscJump;
 #endif
    for (k=0;k<SSCMUL;k++) for (i=0;i<n;i++)
        ((qword*)&p->cnt[k])[i]=seed+gg*(k*n+i);
    p->idx=1; SscGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      SscRand
 #define ExBack      SscBack
 #define ExName     "SscRand"
 #define ExBName    "SscBack"
 #define ExInit      SscInit
 #define ExInitByStr SscInitByStr
 #define ExJump      SscJump
 #define ExSExp      SSCEXP
 #define Ex_t        Ssc_t
 #define ExAlign     16
#endif

[SSB]機械語を使ったSSE2バージョン

多くのコンパイラでコンパイル可能です。

define.h, bincode.h はこちら

/* ssb.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2025
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2022
*/
#if !defined(SSB_H__)
 #define SSB_H__
 #include <math.h>
 #include "define.h"
 #include "bincode.h"

 #if !defined(SSBEXP)
  #define SSBEXP 4
 #endif
 #define SSBNUM (1<<SSBEXP)
 #define SSBMUL (1<<(SSBEXP-1))

enum { SsbZRET,SsbZCNT=SsbZRET+SSBMUL,SsbZADD=SsbZCNT+SSBMUL,
       SsbZSMA,SsbZSMB,
 #if CALLER_SAVED
       SsbZXM6,
 #endif
       SsbZEND};

typedef struct Ssb_t {
    union tagSsbUnion {
        qword q[SsbZEND*128/64];
        m128i y[SsbZEND];
    } v;
    int idx;
} Ssb_t;

 #if SSBMUL > 1
  #define LOAD_SSB LOAD_XMMeax
  #define SAVE_SSB SAVE_XMMeax
 #else
  #define LOAD_SSB LOAD_XMM
  #define SAVE_SSB SAVE_XMM
 #endif

static BINCODE__(SsbGenAll__) = {
    FIRST_ARG() SECOND_ARG() /* +8  8 */
 #if CALLER_SAVED
    SAVE_XMM(SsbZXM6,xmm6),  /* +8 16 */
 #endif
 #if ( defined(_M_IX86) || defined(__i386) ) ^ CALLER_SAVED
  #define SSB_NPAD 13     /* +13  5 */
 #else
  #define SSB_NPAD  5     /*  +5  5 */
 #endif
    LOAD_XMM(xmm2,SsbZADD), /* +8 13 */
    0x83,0xfa+RSI__,0,
     /* cmp edx,0              +3 16 */
    0x7f,14+SSB_NPAD,/* jg end +2,18 */
    MOVDQA(xmm3,xmm2),      /* +4,22 */
    PXOR(xmm2,xmm2),        /* +4 26 */
    0x74,4+SSB_NPAD, /* je end +2 28 */
    PSUBQ(xmm2,xmm3),       /* +4,32 */
 #if SSB_NPAD == 5
    NPAD5(),
 #elif SSB_NPAD == 13
    NPAD13(),
 #endif
/* end: */
    LOAD_XMM(xmm6,SsbZSMA), /* +8  8 */
    LOAD_XMM(xmm3,SsbZSMB), /* +8 16 */
 #if SSBMUL > 1
    0xb8,0,0,0,0, /* mov eax,0 +5 21 */
    NPAD11(),              /* +11 32 */
 #endif
/* repeat: */
    LOAD_SSB(xmm0,SsbZCNT), /* + 9,  9 */
    PADDQ(xmm0,xmm2),       /* + 4, 13 */
    SAVE_SSB(SsbZCNT,xmm0), /* + 9, 22 */
    MOVDQA(xmm1,xmm0),      /* + 4, 26 */
    PSRLQ(xmm0,30),         /* + 5, 31 */
    PXOR(xmm0,xmm1),        /* + 4, 35 */
    PMULLQ(xmm0,xmm6),      /* +48, 83 */
    MOVDQA(xmm1,xmm0),      /* + 4, 87 */
    PSRLQ(xmm0,27),         /* + 5, 92 */
    PXOR(xmm0,xmm1),        /* + 4, 96 */
    PMULLQ(xmm0,xmm3),      /* +48,144 */
    MOVDQA(xmm1,xmm0),      /* + 4,148 */
    PSRLQ(xmm0,31),         /* + 5,153 */
    PXOR(xmm0,xmm1),        /* + 4,157 */
    SAVE_SSB(SsbZRET,xmm0), /* + 9,166 */
 #if SSBMUL > 1
    0x83,0xc0,0x10, /* add eax,16 */
                            /* + 3,169 */
    0x3d,INT_BYTE(SSBMUL*16),/* cmp eax,SSBMUL*16 */
                            /* + 5,174 */
    0x0f,0x82,INT_BYTE(-180), /* jb -180 +6,180 */
 #endif
 #if CALLER_SAVED
    LOAD_XMM(xmm6,SsbZXM6),
 #endif
    RET()
};
 #define SsbGenAll ((void(*)(void*p,int d))(size_t)SsbGenAll__)

static __inline qword SsbRand(Ssb_t*p) {
    int mod=p->idx++&((1<<SSBEXP)-1);
    if (mod==0) SsbGenAll(p,1);
    return(p->v.q+SsbZRET*128/64)[mod];
}

static __inline qword SsbBack(Ssb_t*p) {
    int mod=--p->idx&((1<<SSBEXP)-1);
    qword z=(p->v.q+SsbZRET*128/64)[mod];
    if (mod==0) SsbGenAll(p,-1);
    return z;
}

static void SsbJump(Ssb_t*p,double lag) {
    qword add=GOLDEN_GAMMA; int k=1<<SSBEXP,mod=p->idx&(k-1),back=0,i;
    if (lag<0) { lag=-lag; back=1; add*=-1; mod=1-mod; }
    i=(int)(modf(lag/k,&lag)*k+0.25); add<<=SSBEXP;
    if (back) p->idx-=i; else p->idx+=i;
    if (i+((mod-1)&(k-1))>=k) for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    for (;lag;add+=add) if (modf(lag/2.0,&lag)!=0)
      for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    SsbGenAll(p,0);
}

static int SsbHaveSse2(void)
{ int v[4]; Cpuid(v,1); return (v[3]>>26)&1; }

static qword SsbCrc64(const char*key) {
    qword crc=~(qword)0; int j;
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    return crc;
}

static void SsbInitSub(Ssb_t*p,qword seed);

static const char*SsbInit(Ssb_t*p,qword seed) {
    if (SsbHaveSse2()==0) return"SSE2";
    SsbInitSub(p,seed); return 0;
}

static const char*SsbInitByStr(Ssb_t*p,const char*key) {
    if (SsbHaveSse2()==0) return"SSE2";
    SsbInitSub(p,SsbCrc64(key));
    return 0;
}

static void SsbInitSub(Ssb_t*p,qword seed) {
    enum { n=128/64 }; qword gg=GOLDEN_GAMMA; int i,k;
 #if defined(__GNUC__)
    (void)SsbInit; (void)SsbInitByStr; (void)SsbJump;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<SSBMUL;k++) p->v.q[SsbZCNT*n+k*n+i]=seed+gg*(k*n+i);
        p->v.q[SsbZADD*n+i]=gg*SSBNUM;
        p->v.q[SsbZSMA*n+i]=SPLITMIX_A;
        p->v.q[SsbZSMB*n+i]=SPLITMIX_B;
    }
    p->idx=1; SsbGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      SsbRand
 #define ExBack      SsbBack
 #define ExName     "SsbRand"
 #define ExBName    "SsbBack"
 #define ExInit      SsbInit
 #define ExInitByStr SsbInitByStr
 #define ExJump      SsbJump
 #define ExSExp      SSBEXP
 #define Ex_t        Ssb_t
 #define ExAlign     16
#endif

[SAC]組込み関数を使ったAVX2バージョン

gcc, clang, VC++2013 .. VC++2022 でコンパイル可能です。

define.h はこちら

/* sac.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2025
SplitMix64.

gcc, clang, vc2013 .. vc2022

*/
#if !defined(SAC_H__)
 #define SAC_H__
 #include <math.h>
 #include "define.h"
 #if !defined(SACEXP)
  #define SACEXP 3
 #endif
 #define SACNUM (1<<SACEXP)
 #define SACMUL (1<<(SACEXP-2))

  // D=_mm256_mullo_epi64(D,A);
 #define MM256_MULLO_EPI64(D,A)  { __m256i w1,w2;             \
    w1=_mm256_srli_epi64(A,32);  w2=_mm256_srli_epi64(D,32);  \
    w1=_mm256_mul_epu32(w1,D);   w2=_mm256_mul_epu32(w2,A);   \
    w1=_mm256_slli_epi64(w1,32); w2=_mm256_slli_epi64(w2,32); \
    w1=_mm256_add_epi64(w1,w2);  D=_mm256_mul_epu32(D,A);     \
    D=_mm256_add_epi64(D,w1); }

 #if defined(__clang__)
  #pragma clang attribute push(__attribute__((target("avx2"))), \
      apply_to=function)
 #elif defined(__GNUC__)
  #pragma GCC push_options
  #pragma GCC target("avx2")
 #endif

typedef struct Sac_t
{ __m256i ret[SACMUL],cnt[SACMUL]; int idx; } Sac_t;

static const union tagSac { qword q[4]; __m256i y; }
 SacZADD={{GOLDEN_GAMMA*SACNUM,GOLDEN_GAMMA*SACNUM,
           GOLDEN_GAMMA*SACNUM,GOLDEN_GAMMA*SACNUM}},
 SacZSMA={{SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A}},
 SacZSMB={{SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B}};

GCC_NOINLINE static void SacGenAll(Sac_t*p,int dir) {
 #if SACMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m256i sma=SacZSMA.y, smb=SacZSMB.y, add,t,v;
    if (dir>0) add=SacZADD.y;
    else if (dir<0)
    { t=_mm256_setzero_si256(); add=_mm256_sub_epi64(t,SacZADD.y); }
    else add=_mm256_setzero_si256();
 #if SACMUL > 1
    for (i=0;i<SACMUL;i++)
 #endif
    {
        t=Load256(p->cnt[i]);
        v=t=_mm256_add_epi64(t,add);
        Save256(p->cnt[i],t);
        t=_mm256_srli_epi64(t,30);
        t=_mm256_xor_si256(t,v);
        MM256_MULLO_EPI64(t,sma) v=t;
        t=_mm256_srli_epi64(t,27);
        t=_mm256_xor_si256(t,v);
        MM256_MULLO_EPI64(t,smb) v=t;
        t=_mm256_srli_epi64(t,31);
        Save256(p->ret[i],_mm256_xor_si256(t,v));
    }
    _mm256_zeroupper();
}

 #if defined(__clang__)
  #pragma clang attribute pop
 #elif defined(__GNUC__)
  #pragma GCC pop_options
 #endif

static __inline qword SacRand(Sac_t*p) {
    int mod=p->idx&((1<<SACEXP)-1);
    if (mod==0) SacGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword SacBack(Sac_t*p) {
    int mod=--p->idx&((1<<SACEXP)-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) SacGenAll(p,-1);
    return ret;
}

static void SacJump(Sac_t*p,double lag) {
    qword add=GOLDEN_GAMMA; int k=1<<SACEXP,mod=p->idx&(k-1),back=0,i;
    if (lag<0) { lag=-lag; back=1; add*=-1; mod=1-mod; }
    i=(int)(modf(lag/k,&lag)*k+0.25); add<<=SACEXP;
    if (back) p->idx-=i; else p->idx+=i;
    if (i+((mod-1)&(k-1))>=k) for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    for (;lag;add+=add) if (modf(lag/2.0,&lag)!=0)
      for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    SacGenAll(p,0);
}

static int SacHaveAvx2(void) {
    int v[4],w[4]; CpuidEcx0(v,7); Cpuid(w,1);
    return((v[1]>>5)&(w[2]>>27))&1;
}

static qword SacCrc64(const char*key) {
    qword crc=~(qword)0; int j;
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    return crc;
}

static void SacInitSub(Sac_t*p,qword seed);

static const char*SacInit(Sac_t*p,qword seed) {
    if (SacHaveAvx2()==0) return"AVX2";
    SacInitSub(p,seed); return 0;
}

static const char*SacInitByStr(Sac_t*p,const char*key) {
    if (SacHaveAvx2()==0) return"AVX2";
    SacInitSub(p,SacCrc64(key));
    return 0;
}

static void SacInitSub(Sac_t*p,qword seed) {
    enum { n=256/64 }; qword gg=GOLDEN_GAMMA; int i,k;
 #if defined(__GNUC__)
    (void)SacInit; (void)SacInitByStr; (void)SacJump;
 #endif
    for (k=0;k<SACMUL;k++) for (i=0;i<n;i++)
        ((qword*)&p->cnt[k])[i]=seed+gg*(k*n+i);
    p->idx=1; SacGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      SacRand
 #define ExBack      SacBack
 #define ExName     "SacRand"
 #define ExBName    "SacBack"
 #define ExInit      SacInit
 #define ExInitByStr SacInitByStr
 #define ExJump      SacJump
 #define ExSExp      SACEXP
 #define Ex_t        Sac_t
 #define ExAlign     32
#endif

[SAB]機械語を使ったAVX2バージョン

多くのコンパイラでコンパイル可能です。

define.h, bincode.h はこちら

/* sab.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2025
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2022
*/
#if !defined(SAB_H__)
 #define SAB_H__
 #include <math.h>
 #include "define.h"
 #include "bincode.h"

 #if !defined(SABEXP)
  #define SABEXP 4
 #endif
 #define SABNUM (1<<SABEXP)
 #define SABMUL (1<<(SABEXP-2))

enum { SabZRET,SabZCNT=SabZRET+SABMUL,SabZADD=SabZCNT+SABMUL,
       SabZSMA,SabZSMB,
 #if CALLER_SAVED
       SabZYM6,
 #endif
       SabZEND};

typedef struct Sab_t {
    union tagSabUnion {
        qword q[SabZEND*256/64];
        m256i y[SabZEND];
    } v;
    int idx;
} Sab_t;

 #if SABMUL > 1
  #define LOAD_SAB LOAD_YMMeax
  #define SAVE_SAB SAVE_YMMeax
 #else
  #define LOAD_SAB LOAD_YMM
  #define SAVE_SAB SAVE_YMM
 #endif

static BINCODE__(SabGenAll__) = {
    FIRST_ARG() SECOND_ARG() /* +8  8 */
 #if CALLER_SAVED
    SAVE_YMM(SabZYM6,ymm6),  /* +8 16 */
 #endif
 #if ( defined(_M_IX86) || defined(__i386) ) ^ CALLER_SAVED
  #define SAB_NPAD 13     /* +13  5 */
 #else
  #define SAB_NPAD  5     /*  +5  5 */
 #endif
    LOAD_YMM(ymm2,SabZADD), /* +8 13 */
    0x83,0xfa+RSI__,0,
     /* cmp edx,0              +3 16 */
    0x7f,14+SAB_NPAD,/* jg end +2,18 */
    VPXOR(ymm3,ymm3,ymm3),  /* +4,22 */
    VPSUBQ(ymm2,ymm3,ymm2), /* +4,26 */
    0x7c,4+SAB_NPAD, /* jl end +2 28 */
    VPXOR(ymm2,ymm2,ymm2),  /* +4 32 */
 #if SAB_NPAD == 5
    NPAD5(),
 #elif SAB_NPAD == 13
    NPAD13(),
 #endif
/* end: */
    LOAD_YMM(ymm6,SabZSMA), /* +8  8 */
    LOAD_YMM(ymm3,SabZSMB), /* +8 16 */
 #if SABMUL > 1
    0xb8,0,0,0,0, /* mov eax,0 +5 21 */
    NPAD11(),              /* +11 32 */
 #endif
/* repeat: */
    LOAD_SAB(ymm0,SabZCNT),    /* + 9,  9 */
    VPADDQ(ymm0,ymm0,ymm2),    /* + 4, 13 */
    SAVE_SAB(SabZCNT,ymm0),    /* + 9, 22 */
    VMOVDQA(ymm1,ymm0),        /* + 4, 26 */
    VPSRLQ(ymm0,ymm0,30),      /* + 5, 31 */
    VPXOR(ymm0,ymm1,ymm0),     /* + 4, 35 */
    VPMULLQ(ymm0,ymm6),        /* +40, 75 */
    VMOVDQA(ymm1,ymm0),        /* + 4, 79 */
    VPSRLQ(ymm0,ymm0,27),      /* + 5, 84 */
    VPXOR(ymm0,ymm1,ymm0),     /* + 4, 88 */
    VPMULLQ(ymm0,ymm3),        /* +40,128 */
    VMOVDQA(ymm1,ymm0),        /* + 4,132 */
    VPSRLQ(ymm0,ymm0,31),      /* + 5,137 */
    VPXOR(ymm0,ymm1,ymm0),     /* + 4,141 */
    SAVE_SAB(SabZRET,ymm0),    /* + 9,150 */
 #if SABMUL > 1
    0x83,0xc0,0x20, /* add eax,32 */
                             /* + 3,153 */
    0x3d,INT_BYTE(SABMUL*32),/* cmp eax,SABMUL*32 */
                             /* + 5,158 */
    0x0f,0x82,INT_BYTE(-164), /* jb -164 +6,164 */
 #endif
 #if CALLER_SAVED
    LOAD_YMM(ymm6,SabZYM6),
 #endif
    VZEROUPPER(),
    RET()
};
 #define SabGenAll ((void(*)(void*p,int d))(size_t)SabGenAll__)

static __inline qword SabRand(Sab_t*p) {
    int mod=p->idx&((1<<SABEXP)-1);
    if (mod==0) SabGenAll(p,1);
    p->idx++; return(p->v.q+SabZRET*256/64)[mod];
}

static __inline qword SabBack(Sab_t*p) {
    int mod=--p->idx&((1<<SABEXP)-1);
    qword z=(p->v.q+SabZRET*256/64)[mod];
    if (mod==0) SabGenAll(p,-1);
    return z;
}

static void SabJump(Sab_t*p,double lag) {
    qword add=GOLDEN_GAMMA; int k=1<<SABEXP,mod=p->idx&(k-1),back=0,i;
    if (lag<0) { lag=-lag; back=1; add*=-1; mod=1-mod; }
    i=(int)(modf(lag/k,&lag)*k+0.25); add<<=SABEXP;
    if (back) p->idx-=i; else p->idx+=i;
    if (i+((mod-1)&(k-1))>=k) for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    for (;lag;add+=add) if (modf(lag/2.0,&lag)!=0)
      for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    SabGenAll(p,0);
}

static int SabHaveAvx2(void) {
    int v[4],w[4]; CpuidEcx0(v,7); Cpuid(w,1);
    return((v[1]>>5)&(w[2]>>27))&1;
}

static qword SabCrc64(const char*key) {
    qword crc=~(qword)0; int j;
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    return crc;
}

static void SabInitSub(Sab_t*p,qword seed);

static const char*SabInit(Sab_t*p,qword seed) {
    if (SabHaveAvx2()==0) return"AVX2";
    SabInitSub(p,seed); return 0;
}

static const char*SabInitByStr(Sab_t*p,const char*key) {
    if (SabHaveAvx2()==0) return"AVX2";
    SabInitSub(p,SabCrc64(key));
    return 0;
}

static void SabInitSub(Sab_t*p,qword seed) {
    enum { n=256/64 }; qword gg=GOLDEN_GAMMA; int i,k;
 #if defined(__GNUC__)
    (void)SabInit; (void)SabInitByStr; (void)SabJump;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<SABMUL;k++) p->v.q[SabZCNT*n+k*n+i]=seed+gg*(k*n+i);
        p->v.q[SabZADD*n+i]=gg*SABNUM;
        p->v.q[SabZSMA*n+i]=SPLITMIX_A;
        p->v.q[SabZSMB*n+i]=SPLITMIX_B;
    }
    p->idx=1; SabGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      SabRand
 #define ExBack      SabBack
 #define ExName     "SabRand"
 #define ExBName    "SabBack"
 #define ExInit      SabInit
 #define ExInitByStr SabInitByStr
 #define ExJump      SabJump
 #define ExSExp      SABEXP
 #define Ex_t        Sab_t
 #define ExAlign     32
#endif

[SBC]組込み関数を使ったAVX512バージョン

gcc, clang, vc2017 .. vc2022 でコンパイル可能です。

define.h はこちら

/* sbc.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2025
SplitMix64.

gcc, clang, vc2017 .. vc2022

*/
#if !defined(SBC_H__)
 #define SBC_H__
 #include <math.h>
 #include "define.h"

 #if !defined(SBCEXP)
  #define SBCEXP 4
 #endif
 #define SBCNUM (1<<SBCEXP)
 #define SBCMUL (1<<(SBCEXP-3))

 #if defined(__clang__)
  #pragma clang attribute push(__attribute__((target("avx512dq"))), \
      apply_to=function)
 #elif defined(__GNUC__)
  #pragma GCC push_options
  #pragma GCC target("avx512dq")
 #endif

typedef struct Sbc_t
{ __m512i ret[SBCMUL],cnt[SBCMUL]; int idx; } Sbc_t;

static const union tagSbc { qword q[8]; __m512i z; }
 SbcZADD={{GOLDEN_GAMMA*SBCNUM,GOLDEN_GAMMA*SBCNUM,
           GOLDEN_GAMMA*SBCNUM,GOLDEN_GAMMA*SBCNUM,
           GOLDEN_GAMMA*SBCNUM,GOLDEN_GAMMA*SBCNUM,
           GOLDEN_GAMMA*SBCNUM,GOLDEN_GAMMA*SBCNUM}},
 SbcZSMA={{SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,
           SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A}},
 SbcZSMB={{SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,
           SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B}};

GCC_NOINLINE static void SbcGenAll(Sbc_t*p,int dir) {
 #if SBCMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m512i sma=SbcZSMA.z,smb=SbcZSMB.z,y2,t,v;
    if (dir>0)      y2=SbcZADD.z;
    else if (dir<0) y2=_mm512_sub_epi64(_mm512_setzero_si512(),SbcZADD.z);
    else            y2=_mm512_setzero_si512();
 #if SBCMUL > 1
    for (i=0;i<SBCMUL;i++)
 #endif
    {
        t=Load512(p->cnt[i]);
        v=t=_mm512_add_epi64(t,y2);
        Save512(p->cnt[i],t);
        t=_mm512_srli_epi64(t,30);
        t=_mm512_xor_si512(t,v);
        v=t=_mm512_mullo_epi64(t,sma);
        t=_mm512_srli_epi64(t,27);
        t=_mm512_xor_si512(t,v);
        v=t=_mm512_mullo_epi64(t,smb);
        t=_mm512_srli_epi64(t,31);
        Save512(p->ret[i],_mm512_xor_si512(t,v));
    }
    _mm256_zeroupper();
}

 #if defined(__clang__)
  #pragma clang attribute pop
 #elif defined(__GNUC__)
  #pragma GCC pop_options
 #endif

static __inline qword SbcRand(Sbc_t*p) {
    int mod=p->idx&((1<<SBCEXP)-1);
    if (mod==0) SbcGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword SbcBack(Sbc_t*p) {
    int mod=--p->idx&((1<<SBCEXP)-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) SbcGenAll(p,-1);
    return ret;
}

static void SbcJump(Sbc_t*p,double lag) {
    qword add=GOLDEN_GAMMA; int k=1<<SBCEXP,mod=p->idx&(k-1),back=0,i;
    if (lag<0) { lag=-lag; back=1; add*=-1; mod=1-mod; }
    i=(int)(modf(lag/k,&lag)*k+0.25); add<<=SBCEXP;
    if (back) p->idx-=i; else p->idx+=i;
    if (i+((mod-1)&(k-1))>=k) for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    for (;lag;add+=add) if (modf(lag/2.0,&lag)!=0)
      for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    SbcGenAll(p,0);
}

static int SbcHaveAvx512DQ(void)
{ int v[4]; CpuidEcx0(v,7); return(v[1]>>17)&1; }

static qword SbcCrc64(const char*key) {
    qword crc=~(qword)0; int j;
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    return crc;
}

static void SbcInitSub(Sbc_t*p,qword seed);

static __inline const char*SbcInit(Sbc_t*p,qword seed) {
    if (SbcHaveAvx512DQ()==0) return"AVX512DQ";
    SbcInitSub(p,seed); return 0;
}

static const char*SbcInitByStr(Sbc_t*p,const char*key) {
    if (SbcHaveAvx512DQ()==0) return"AVX512DQ";
    SbcInitSub(p,SbcCrc64(key));
    return 0;
}

static void SbcInitSub(Sbc_t*p,qword seed) {
    enum { n=512/64 }; qword gg=GOLDEN_GAMMA; int i,k;
 #if defined(__GNUC__)
    (void)SbcInit; (void)SbcInitByStr; (void)SbcJump;
 #endif
    for (k=0;k<SBCMUL;k++) for (i=0;i<n;i++)
        ((qword*)&p->cnt[k])[i]=seed+gg*(k*n+i);
    p->idx=1; SbcGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      SbcRand
 #define ExBack      SbcBack
 #define ExName     "SbcRand"
 #define ExBName    "SbcBack"
 #define ExInit      SbcInit
 #define ExInitByStr SbcInitByStr
 #define ExJump      SbcJump
 #define ExSExp      SBCEXP
 #define Ex_t        Sbc_t
 #define ExAlign     64
#endif

[SBB]機械語を使ったAVX512バージョン

多くのコンパイラでコンパイル可能です。

define.h, bincode.h はこちら

/* sbb.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2025
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2022
*/
#if !defined(SBB_H__)
 #define SBB_H__
 #include <math.h>
 #include "define.h"
 #include "bincode.h"

 #if !defined(SBBEXP)
  #define SBBEXP 4
 #endif
 #define SBBNUM (1<<SBBEXP)
 #define SBBMUL (1<<(SBBEXP-3))

enum { SbbZRET,SbbZCNT=SbbZRET+SBBMUL,SbbZADD=SbbZCNT+SBBMUL,
       SbbZSMA,SbbZSMB,SbbZEND};

typedef struct Sbb_t {
    union tagSbbUnion {
        qword q[SbbZEND*512/64];
        m512i y[SbbZEND];
    } v;
    int idx;
} Sbb_t;

 #if SBBMUL > 1
  #define LOAD_SBB LOAD_ZMMeax
  #define SAVE_SBB SAVE_ZMMeax
 #else
  #define LOAD_SBB LOAD_ZMM
  #define SAVE_SBB SAVE_ZMM
 #endif

static BINCODE__(SbbGenAll__) = {
 #if defined(_M_IX86) || defined(__i386)
    #define SBB_NPAD 5       /* +5  5 */
    FIRST_ARG() SECOND_ARG() /* +8 13 */
 #else
    #define SBB_NPAD 13
 #endif
    LOAD_ZMM(zmm2,SbbZADD), /* +10 23 */
    0x83,0xfa+RSI__,0,
     /* cmp edx,0               +3 26 */
    0x7f,20+SBB_NPAD,/* jg end: +2,28 */
    VPXORD(zmm3,zmm3,zmm3), /*  +6,34 */
    VPSUBQz(zmm2,zmm3,zmm2), /* +6,40 */
    0x7c,6+SBB_NPAD, /* jl end: +2 42 */
    VPXORD(zmm2,zmm2,zmm2),  /* +6 48 */
 #if SBB_NPAD == 5
    NPAD5(),
 #elif SBB_NPAD == 13
    NPAD13(),
 #endif
/* end: */
    LOAD_ZMM(zmm4,SbbZSMA), /* +10 10 */
    LOAD_ZMM(zmm5,SbbZSMB), /* +10 20 */
 #if SBBMUL > 1
    0xb8,0,0,0,0, /* mov eax,0  +5 25 */
    NPAD7(),               /*   +7 32 */
 #endif
/* repeat: */
    LOAD_SBB(zmm0,SbbZCNT),  /* +11, 11 */
    VPADDQz(zmm0,zmm2,zmm0), /* + 6, 17 */
    SAVE_SBB(SbbZCNT,zmm0),  /* +11, 28 */
    VMOVDQA64(zmm1,zmm0),    /* + 6, 34 */
    VPSRLQz(zmm0,zmm0,30),   /* + 7, 41 */
    VPXORD(zmm0,zmm1,zmm0),  /* + 6, 47 */
    VPMULLQz(zmm0,zmm4,zmm0),/* + 6, 53 */
    VMOVDQA64(zmm1,zmm0),    /* + 6, 59 */
    VPSRLQz(zmm0,zmm0,27),   /* + 7, 66 */
    VPXORD(zmm0,zmm1,zmm0),  /* + 6, 72 */
    VPMULLQz(zmm0,zmm5,zmm0),/* + 6, 78 */
    VMOVDQA64(zmm1,zmm0),    /* + 6, 84 */
    VPSRLQz(zmm0,zmm0,31),   /* + 7, 91 */
    VPXORD(zmm0,zmm1,zmm0),  /* + 6, 97 */
    SAVE_SBB(SbbZRET,zmm0),  /* +11,108 */
 #if SBBMUL > 1
    0x83,0xc0,0x40, /* add eax,64 */
                             /* + 3,111 */
    0x3d,INT_BYTE(SBBMUL*64),/* cmp eax,SBBMUL*64 */
                             /* + 5,116 */
    0x72,-118&255, /* jb repeat: +2,118 */
 #endif
    VZEROUPPER(),
    RET()
};
 #define SbbGenAll ((void(*)(void*p,int d))(size_t)SbbGenAll__)

static __inline qword SbbRand(Sbb_t*p) {
    int mod=p->idx++&((1<<SBBEXP)-1);
    if (mod==0) SbbGenAll(p,1);
    return(p->v.q+SbbZRET*8)[mod];
}

static __inline qword SbbBack(Sbb_t*p) {
    int mod=--p->idx&((1<<SBBEXP)-1);
    qword z=(p->v.q+SbbZRET*8)[mod];
    if (mod==0) SbbGenAll(p,-1);
    return z;
}

static void SbbJump(Sbb_t*p,double lag) {
    qword add=GOLDEN_GAMMA; int k=1<<SBBEXP,mod=p->idx&(k-1),back=0,i;
    if (lag<0) { lag=-lag; back=1; add*=-1; mod=1-mod; }
    i=(int)(modf(lag/k,&lag)*k+0.25); add<<=SBBEXP;
    if (back) p->idx-=i; else p->idx+=i;
    if (i+((mod-1)&(k-1))>=k) for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    for (;lag;add+=add) if (modf(lag/2.0,&lag)!=0)
      for (i=0;i<k;i++) ((qword*)p)[k+i]+=add;
    SbbGenAll(p,0);
}

static int SbbHaveAvx512DQ(void)
{ int v[4]; CpuidEcx0(v,7); return(v[1]>>17)&1; }

static qword SbbCrc64(const char*key) {
    qword crc=~(qword)0; int j;
    for (;*key;key++) {
        crc^=(qword)*key<<56;
        for (j=0;j<8;j++) {
            if (crc&0x8000000000000000U)
                crc=(crc<<1)^0xC96C5795D7870F42U; /* CRC64-ISO polynomial */
            else crc<<=1;
        }
    }
    return crc;
}

static void SbbInitSub(Sbb_t*p,qword seed);

static const char*SbbInit(Sbb_t*p,qword seed) {
    if (SbbHaveAvx512DQ()==0) return"AVX512DQ";
    SbbInitSub(p,seed); return 0;
}

static const char*SbbInitByStr(Sbb_t*p,const char*key) {
    if (SbbHaveAvx512DQ()==0) return"AVX512DQ";
    SbbInitSub(p,SbbCrc64(key));
    return 0;
}

static void SbbInitSub(Sbb_t*p,qword seed) {
    enum { n=512/64 }; qword gg=GOLDEN_GAMMA; int i,k;
 #if defined(__GNUC__)
    (void)SbbInit; (void)SbbInitByStr; (void)SbbJump;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<SBBMUL;k++) p->v.q[SbbZCNT*n+k*n+i]=seed+gg*(k*n+i);
        p->v.q[SbbZADD*n+i]=gg*SBBNUM;
        p->v.q[SbbZSMA*n+i]=SPLITMIX_A;
        p->v.q[SbbZSMB*n+i]=SPLITMIX_B;
    }
    p->idx=1; SbbGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      SbbRand
 #define ExBack      SbbBack
 #define ExName     "SbbRand"
 #define ExBName    "SbbBack"
 #define ExInit      SbbInit
 #define ExInitByStr SbbInitByStr
 #define ExJump      SbbJump
 #define ExSExp      SBBEXP
 #define Ex_t        Sbb_t
 #define ExAlign     64
#endif

［前：rdrandをtestU01とPractRandで検定する］［ExRand目次］［次：SplitMix64とXorshiftを組み合わせる］