［前：rdrandをtestU01とPractRand ver0.96で検定する］［ExRand目次］［次：SplitMix64とXorshiftを組み合わせる(小型)］

[SNC]SplitMix64について

[SNC]SplitMix64について
SplitMix64をtestU01で検定する
SplitMix64をPractRand ver0.96で検定する
[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 .. vc2026
*/
#if !defined(SNC_H__)
 #define SNC_H__
 #include <math.h>
 #if defined(_MSC_VER)
  #define _CRT_SECURE_NO_DEPRECATE 1
  #define _CRT_NONSTDC_NO_WARNINGS 1
 #endif
 #if defined(__BORLANDC__)
  #pragma warn -inl /* Functions containing * are not expanded inline */
 #endif
 #if defined(_M_IX86) || defined(_MSC_VER)
typedef __int64 sqword;
typedef unsigned __int64 qword;
 #else
typedef long long sqword;
typedef unsigned long long qword;
 #endif
 #define GOLDEN_GAMMA 0x9E3779B97F4A7C15U
 #define SPLITMIX_A 0xBF58476D1CE4E5B9U
 #define SPLITMIX_B 0x94D049BB133111EBU
 #define U01(A) ((sqword)((qword)(A)>>11)*(1.0/9007199254740992.0))

typedef qword Snc_t;

static __inline qword SncSplitMixHash(qword z)
{ z=(z^(z>>30))*SPLITMIX_A; z=(z^(z>>27))*SPLITMIX_B; return z^(z>>31); }

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

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

static __inline const char*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;
    return 0;
}

static __inline const char*SncInit(Snc_t*p,qword s) { *p=s; return 0; }

static __inline const char*SncInitByStr(Snc_t*p,const char*key) {
    qword r=GOLDEN_GAMMA+1;
    if (key) for (;*key;key++) r=SncSplitMixHash(r^(unsigned char)*key);
    *p=r; 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 ver0.96で検定する

SplitMix64は統計的性質が優れています。
-te 0 を te0、-te 1 を te1、-te 10 を te10、-tf 1 を tf1、-tf 2 を te2 と表します。
[te0, te1, te10]、[tf1, tf2] の組合せ６つの全てを種１で検定しました。
te0 では 32TB、te1, te10 では8TB まで調べました。 te1 tf2 の場合、

RNG_test stdin64 -tlmin 1GB -te 1 -tf 2 -tlmax 8TB -multithreaded
SncRand te1 tf2 Seed(1)
RNG_test using PractRand version 0.96
RNG = RNG_stdin64, seed = unknown
test set = expanded, folding = extra
...
length= 4 gigabytes (2^32 bytes), time= 118 seconds
  Test Name                         Raw       Processed     Evaluation       
  [Low4/16]NS3[0:hw:both]           R=  +4.2  p~=  1.1e-5   unusual          
  [Low4/32]NS3[1:pd:both]           R=  +4.2  p~=  1.6e-5   unusual          
...
length= 8 gigabytes (2^33 bytes), time= 227 seconds
  Test Name                         Raw       Processed     Evaluation       
  [Low4/16]NS3[0:hw:both]           R=  +4.1  p~=  2.3e-5   unusual          
...
length= 8 terabytes (2^43 bytes), time= 157693 seconds
  no anomalies in 3432 test result(s)

となりました。それ以外の5つに異常はありませんでした。
te1 tf2 の場合でも種２では異常はありませんでした。

PractRand ver0.96で QncRand を種を1～40にして 1GB, 2GB, 4GB の3つの長さで、異常のあったものを表示します。
この120回分を1つのテストとします。
１つのテストを(te0,te1)と(tf1,tf2)の4個の組み合わせをテストして合計480回調べました。

SncRand te0 tf1 Seed(5) 1GB  [Low1/64]DC6-9x1Bytes-1 p=1-3.6e-3 unusual 
SncRand te0 tf1 Seed(7) 4GB  [Low16/64]FPF/16:cross p=1-4.8e-4 unusual 
SncRand te0 tf1 Seed(10) 2GB  [Low4/64]DC6-9x1Bytes-1 p=2.9e-3 unusual 
SncRand te0 tf1 Seed(11) 1GB  [Low16/64]FPF/16:cross p=2.0e-5 mildly suspicious
SncRand te0 tf1 Seed(16) 2GB  DC6-9x1Bytes-1 p=3.1e-3 unusual 
SncRand te0 tf1 Seed(16) 2GB  [Low1/64]mod3n(5):(2,9-3) p=1-5.1e-5 unusual 
SncRand te0 tf1 Seed(27) 1GB  [Low4/64]DC6-9x1Bytes-1 p=1-1.3e-3 unusual

SncRand te0 tf2 Seed(13) 1GB  [Low4/16]BCFN(2+0,13-2U) p=2.7e-4 unusual 
SncRand te0 tf2 Seed(16) 2GB  [Low1/64]mod3n(5):(2,9-3) p=1-5.1e-5 unusual 
SncRand te0 tf2 Seed(19) 4GB  [Low8/32]FPF/16:all p=1-1.4e-4 unusual 
SncRand te0 tf2 Seed(26) 4GB  [Low1/32]DC6-9x1Bytes-1 p=5.6e-4 unusual 
SncRand te0 tf2 Seed(27) 1GB  [Low4/64]DC6-9x1Bytes-1 p=1-1.3e-3 unusual 
SncRand te0 tf2 Seed(27) 4GB  [Low4/16]BCFN(2+1,13-1U) p=1-5.3e-5 unusual

SncRand te1 tf1 Seed(7) 1GB  [Low4/64]DC7-5x4Bytes-1:indep p=1-1e-4 unusual 
SncRand te1 tf1 Seed(10) 4GB  [C8]DC6-9x1Bytes-1 p=1-3.1e-4 unusual 
SncRand te1 tf1 Seed(25) 1GB  [Low1/64]NS3[6:hw:both] p=1.1e-5 unusual 
SncRand te1 tf1 Seed(27) 1GB  [Low4/64]NS3[6:hw:both] p=1.4e-5 unusual 
SncRand te1 tf1 Seed(28) 1GB  [Low1/64]NS3[2:pd:both] p=1-1.5e-5 mildly suspicious
SncRand te1 tf1 Seed(30) 1GB  [Low16/64]NS3[3:pd:both] p=1-1.5e-4 unusual 
SncRand te1 tf1 Seed(35) 1GB  [Low4/64]DC7-5x4Bytes-1:both p=1-2.4e-4 unusual 
SncRand te1 tf1 Seed(35) 4GB  [Low4/64]DC7-9x1Bytes-1:indep p=1-2e-5 unusual 
SncRand te1 tf1 Seed(37) 1GB  [Low1/64]BCFN(0+0,13-4U) p=3.3e-5 unusual

SncRand te1 tf2 Seed(1) 4GB  [Low4/16]NS3[0:hw:both] p=1.1e-5 unusual 
SncRand te1 tf2 Seed(1) 4GB  [Low4/32]NS3[1:pd:both] p=1.6e-5 unusual 
SncRand te1 tf2 Seed(3) 1GB  [Low1/16][C8]BCFN(2+1,13-6U) p=4.1e-5 unusual 
SncRand te1 tf2 Seed(4) 2GB  [Low1/16]BCFN(0+0,13-2U) p=4.1e-5 unusual 
SncRand te1 tf2 Seed(11) 1GB  [Low4/32][C8]mod3n(5):(1,9-4) p=1.0e-5 unusual 
SncRand te1 tf2 Seed(25) 1GB  [Low1/64]NS3[6:hw:both] p=1.1e-5 unusual 
SncRand te1 tf2 Seed(27) 1GB  [Low4/64]NS3[6:hw:both] p=1.4e-5 unusual 
SncRand te1 tf2 Seed(28) 1GB  [Low1/64]NS3[2:pd:both] p=1-1.5e-5 unusual 
SncRand te1 tf2 Seed(35) 4GB  [Low4/64]DC7-9x1Bytes-1:indep p=1-2e-5 unusual 
SncRand te1 tf2 Seed(37) 1GB  [Low1/64]BCFN(0+0,13-4U) p=3.3e-5 unusual

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

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

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

/* ssc.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
SplitMix64.
gcc, clang, vc2002 .. vc2026
*/
#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 DEFEXP
 #endif
 #if 3*SSCEXP-1 == -3 || SSCEXP < 1
  #undef SSCEXP
  #define SSCEXP 1
 #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}};

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 const char*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); return 0;
}

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

static void SscInitHelp(Ssc_t*p);

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

static const char*SscInitByStr(Ssc_t*p,const char*key) {
    if (SscHaveSse2()==0) return"SSE2";
    InitByStr((qword*)p->ret,1,key); SscInitHelp(p); return 0;
}

static void SscInitHelp(Ssc_t*p) {
    enum { n=128/64 }; qword gg=GOLDEN_GAMMA,seed=*(qword*)p->ret; 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) 2026
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2026
*/
#if !defined(SSB_H__)
 #define SSB_H__
 #include <math.h>
 #include "define.h"
 #include "bincode.h"

 #if !defined(SSBEXP)
  #define SSBEXP DEFEXP
 #endif
 #if 3*SSBEXP-1 == -3 || SSBEXP < 1
  #undef SSBEXP
  #define SSBEXP 1
 #endif
 #define SSBNUM (1<<SSBEXP)
 #define SSBMUL (1<<(SSBEXP-1))

enum { SsbZRET,SsbZCNT=SsbZRET+SSBMUL,SsbZADD=SsbZCNT+SSBMUL,SsbZSMA,SsbZSMB,
 #if defined(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__) = {
 #if defined(_M_IX86) || defined(__i386)
    FIRST_ARG() SECOND_ARG() /* +8  8 */
  #define SSB_NPAD 13        /* +13 5 */
 #elif defined(CALLER_SAVED)
    SAVE_XMM(SsbZXM6,xmm6),  /* +8  8 */
  #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 defined(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 const char*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); return 0;
}

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

static void SsbInitHelp(Ssb_t*p);

static const char*SsbInit(Ssb_t*p,qword seed) {
    if (SsbHaveSse2()==0) return"SSE2";
    *p->v.q=seed; SsbInitHelp(p); return 0;
}

static const char*SsbInitByStr(Ssb_t*p,const char*key) {
    if (SsbHaveSse2()==0) return"SSE2";
    InitByStr(p->v.q,1,key); SsbInitHelp(p); return 0;
}

static void SsbInitHelp(Ssb_t*p) {
    enum { n=128/64 }; qword gg=GOLDEN_GAMMA,seed=*p->v.q; 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++2026 でコンパイル可能です。

define.h はこちら

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

gcc, clang, vc2013 .. vc2026

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

 #if !defined(SACEXP)
  #define SACEXP DEFEXP
 #endif
 #if 3*SACEXP-1 == -3 || SACEXP < 2
  #undef SACEXP
  #define SACEXP 2
 #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}};

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 const char*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); return 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 void SacInitHelp(Sac_t*p);

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

static const char*SacInitByStr(Sac_t*p,const char*key) {
    if (SacHaveAvx2()==0) return"AVX2";
    InitByStr((qword*)p->ret,1,key); SacInitHelp(p); return 0;
}

static void SacInitHelp(Sac_t*p) {
    enum { n=256/64 }; qword gg=GOLDEN_GAMMA,seed=*(qword*)p->ret; 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) 2026
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2026
*/
#if !defined(SAB_H__)
 #define SAB_H__
 #include <math.h>
 #include "define.h"
 #include "bincode.h"

 #if !defined(SABEXP)
  #define SABEXP DEFEXP
 #endif
 #if 3*SABEXP-1 == -3 || SABEXP < 2
  #undef SABEXP
  #define SABEXP 2
 #endif
 #define SABNUM (1<<SABEXP)
 #define SABMUL (1<<(SABEXP-2))

enum { SabZRET,SabZCNT=SabZRET+SABMUL,SabZADD=SabZCNT+SABMUL,
       SabZSMA,SabZSMB,
 #if defined(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__)={
 #if defined(_M_IX86) || defined(__i386)
    FIRST_ARG() SECOND_ARG() /* +8  8 */
  #define SAB_NPAD 13      /*  +13  5 */
 #elif defined(CALLER_SAVED)
    SAVE_YMM(SabZYM6,ymm6),  /* +8  8 */
  #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 defined(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 const char*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); return 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 void SabInitHelp(Sab_t*p);

static const char*SabInit(Sab_t*p,qword seed) {
    if (SabHaveAvx2()==0) return"AVX2";
    *p->v.q=seed; SabInitHelp(p); return 0;
}

static const char*SabInitByStr(Sab_t*p,const char*key) {
    if (SabHaveAvx2()==0) return"AVX2";
    InitByStr(p->v.q,1,key); SabInitHelp(p); return 0;
}

static void SabInitHelp(Sab_t*p) {
    enum { n=256/64 }; qword gg=GOLDEN_GAMMA,seed=*p->v.q; 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 .. vc2026 でコンパイル可能です。

define.h はこちら

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

gcc, clang, vc2017 .. vc2026

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

 #if !defined(SBCEXP)
  #define SBCEXP DEFEXP
 #endif
 #if 3*SBCEXP-1 == -3 || SBCEXP < 3
  #undef SBCEXP
  #define SBCEXP 3
 #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 void SbcInitHelp(Sbc_t*p);

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}};

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 const char*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); return 0;
}

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

static void SbcInitHelp(Sbc_t*p);

static const char*SbcInit(Sbc_t*p,qword seed) {
    if (SbcHaveAvx512DQ()==0) return"AVX512DQ";
    *(qword*)p->ret=seed; SbcInitHelp(p); return 0;
}

static const char*SbcInitByStr(Sbc_t*p,const char*key) {
    if (SbcHaveAvx512DQ()==0) return"AVX512DQ";
    InitByStr((qword*)p->ret,1,key); SbcInitHelp(p); return 0;
}

static void SbcInitHelp(Sbc_t*p) {
    enum { n=512/64 }; qword gg=GOLDEN_GAMMA,seed=*(qword*)p->ret; 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) 2026
SplitMix64.
gcc, clang, bcc5.5.1, vc5.0 .. vc2026
*/
#if !defined(SBB_H__)
 #define SBB_H__
 #include <math.h>
 #include "define.h"
 #include "bincode.h"

 #if !defined(SBBEXP)
  #define SBBEXP DEFEXP
 #endif
 #if 3*SBBEXP-1 == -3 || SBBEXP < 3
  #undef SBBEXP
  #define SBBEXP 3
 #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 const char*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); return 0;
}

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

static void SbbInitHelp(Sbb_t*p);

static const char*SbbInit(Sbb_t*p,qword seed) {
    if (SbbHaveAvx512DQ()==0) return"AVX512DQ";
    *p->v.q=seed; SbbInitHelp(p); return 0;
}

static const char*SbbInitByStr(Sbb_t*p,const char*key) {
    if (SbbHaveAvx512DQ()==0) return"AVX512DQ";
    InitByStr(p->v.q,1,key); SbbInitHelp(p); return 0;
}

static void SbbInitHelp(Sbb_t*p) {
    enum { n=512/64 }; qword gg=GOLDEN_GAMMA,seed=*p->v.q; 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 ver0.96で検定する］［ExRand目次］［次：SplitMix64とXorshiftを組み合わせる(小型)］