［前：SplitMix64とXorshiftを組み合わせる(小型)］［ExRand目次］［次：SplitMix64とXorshiftを組み合わせる(高機能版)］

[QNC]SplitMix64とXorshiftを組み合わせる(大型)

[QNC]SplitMix64とXorshiftを組み合わせる(大型)
QncRandをtestU01で検定する
QncRandをPractRand ver0.96で検定する
[QSC]組込み関数を使ったSSE2バージョン
[QSB]機械語を使ったSSE2バージョン
[QAC]組込み関数を使ったAVX2バージョン
[QAB]機械語を使ったAVX2バージョン
[QBC]組込み関数を使ったAVX512バージョン
[QBB]機械語を使ったAVX512バージョン

[QNC]SplitMix64とXorshiftを組み合わせる(大型)

anc.h の周期の長さは２²⁵⁶-２⁶⁴ ですが、大規模な実験では不十分かもしれません。
そこで、周期を２⁷⁰⁴-２⁶⁴ にした qnc.h を開発しました。

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

/* qnc.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and Xorshift.

gcc, clang, bcc5.5.1, vc5.0 .. vc2026

*/
#if !defined(QNC_H__)
 #define QNC_H__
 #if defined(_MSC_VER)
  #define _CRT_SECURE_NO_DEPRECATE 1
  #define _CRT_NONSTDC_NO_WARNINGS 1
 #endif
 #if defined(__BORLANDC__)
  #pragma warn -use /* 'identifier' declared but never used */
  #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))

 #define QNABC 10353720 /*25%*/
 #define QID 'U'
 #define QNSD (QNABC/1000000)

typedef struct Qnc_t { qword cnt,xs[QNSD]; } Qnc_t;

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

static void QncNextState(qword*q) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword x=q[0],t=x; int i;
    for (i=0;i<QNSD-1;i++) q[i]=q[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=q[QNSD-1];
    t^=x; x>>=c; t^=x; q[QNSD-1]=t;
}

static void QncBackState(qword*q) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword t=q[QNSD-1],x=q[QNSD-2]; int i;
    for (i=QNSD-1;i>0;i--) q[i]=q[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; q[0]=t;
}

static __inline qword QncRand(Qnc_t*p) {
    qword z=(p->cnt+=GOLDEN_GAMMA);
    if ((short)z==0) QncNextState(p->xs);
    return QncSplitMixHash(z^p->xs[QNSD-1]);
}

static __inline qword QncBack(Qnc_t*p) {
    qword z=QncSplitMixHash(p->cnt^p->xs[QNSD-1]);
    if ((short)p->cnt==0) QncBackState(p->xs);
    p->cnt-=GOLDEN_GAMMA; return z;
}

static void QncInitHelp(Qnc_t*p);

static const char*QncInit(Qnc_t*p,qword seed) {
    int i;
    for (i=0;i<QNSD;i++) p->xs[i]=QncSplitMixHash(seed+=GOLDEN_GAMMA);
    p->cnt=0; QncInitHelp(p); return 0;
}

static qword QncStrHash(qword r,const char*key) {
    if (key) for (;*key;key++) r=QncSplitMixHash(r^(unsigned char)*key);
    return r;
}

static const char*QncInitByStr(Qnc_t*p,const char*key) {
    int i; qword seed=1;
    for (i=0;i<QNSD;i++) p->xs[i]=QncStrHash(seed+=GOLDEN_GAMMA,key);
    p->cnt=QncStrHash(seed+=GOLDEN_GAMMA,key); QncInitHelp(p); return 0;
}

static void QncInitHelp(Qnc_t*p) {
 #if defined(__GNUC__)
    (void)QncInit; (void)QncInitByStr;
 #endif
    p->cnt&=~(qword)65535; p->cnt-=GOLDEN_GAMMA; QncRand(p);
}

#endif

#if !defined(ExRand)
 #define ExRand      QncRand
 #define ExBack      QncBack
 #define ExName     "QncRand"
 #define ExBName    "QncBack"
 #define ExInit      QncInit
 #define ExInitByStr QncInitByStr
 #define ExSExp      0
 #define ExID        QID
 #define ExNsd       QNSD
 #define Ex_t        Qnc_t
 #define ExAlign     8
#endif

QncRandをtestU01で検定する

QnxRand は QncRand をより一般化した疑似乱数です。
10U は QnxRand を QncRand と同じにするパラメータです。
まず testU01 で検定した結果の要約を示します。

type                     , c, test                    , p-value
QnxRand 10U rawhi Seed(1), B, Passed                  , -      
QnxRand 10U rawhi Seed(2), B, Passed                  , -      
QnxRand 10U rawhi Seed(3), B, RandomWalk1 M(L=50,r=25), 6.9e-4 
QnxRand 10U rawhi Seed(4), B, Passed                  , -      
QnxRand 10U rawhi Seed(5), B, Passed                  , -      
QnxRand 10U rawhi Seed(6), B, Passed                  , -      
QnxRand 10U rawlo Seed(1), B, Passed                  , -      
QnxRand 10U rawlo Seed(2), B, Passed                  , -      
QnxRand 10U rawlo Seed(3), B, MatrixRank,L=1000,r=0   , 0.9995 
QnxRand 10U rawlo Seed(4), B, Passed                  , -      
QnxRand 10U rawlo Seed(5), B, Passed                  , -      
QnxRand 10U rawlo Seed(6), B, ClosePairs mNP2,t=5     , 8.3e-4 
QnxRand 10U revhi Seed(1), B, Passed                  , -      
QnxRand 10U revhi Seed(2), B, Passed                  , -      
QnxRand 10U revhi Seed(3), B, Passed                  , -      
QnxRand 10U revhi Seed(4), B, CollisionOver,t=21      , 6.0e-4 
-                        , B, AppearanceSpacings,r=27 , 2.4e-4 
QnxRand 10U revhi Seed(5), B, MatrixRank,L=30,r=0     , 9.1e-4 
-                        , B, LempelZiv,r=15          , 3.9e-4 
QnxRand 10U revhi Seed(6), B, Passed                  , -      
QnxRand 10U revlo Seed(1), B, Passed                  , -      
QnxRand 10U revlo Seed(2), B, Passed                  , -      
QnxRand 10U revlo Seed(3), B, Passed                  , -      
QnxRand 10U revlo Seed(4), B, Passed                  , -      
QnxRand 10U revlo Seed(5), B, HammingCorr,L=1200      , 4.5e-4 
QnxRand 10U revlo Seed(6), B, Passed                  , -      
QnxRand 10U swphi Seed(1), B, WeightDistrib,r=28      , 9.8e-4 
QnxRand 10U swphi Seed(2), B, Passed                  , -      
QnxRand 10U swphi Seed(3), B, CollisionOver,t=3       , 0.9994 
QnxRand 10U swphi Seed(4), B, Passed                  , -      
QnxRand 10U swphi Seed(5), B, CollisionOver,t=21      , 9.4e-4 
QnxRand 10U swphi Seed(6), B, Passed                  , -      
QnxRand 10U swplo Seed(1), B, Passed                  , -      
QnxRand 10U swplo Seed(2), B, Passed                  , -      
QnxRand 10U swplo Seed(3), B, Passed                  , -      
QnxRand 10U swplo Seed(4), B, Passed                  , -      
QnxRand 10U swplo Seed(5), B, Passed                  , -      
QnxRand 10U swplo Seed(6), B, MaxOft AD,t=8           , 3.9e-4 
-                        , B, Savir2                  , 0.9997

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

QncRandをPractRand ver0.96で検定する

次に PractRand ver0.96 での検定です。
以下の６つの検定をしました。

(1)RNG_test stdin64 -tlmin 1GB -multithreaded
(2)RNG_test stdin64 -tlmin 1GB -tf 2 -multithreaded
(3)RNG_test stdin64 -tlmin 1GB -te 1 -tlmax 8TB -multithreaded
(4)RNG_test stdin64 -tlmin 1GB -te 1 -tf 2 -tlmax 8TB -multithreaded
(5)RNG_test stdin64 -tlmin 1GB -te 10 -tlmax 8TB -multithreaded
(6)RNG_test stdin64 -tlmin 1GB -te 10 -tf 2 -tlmax 8TB -multithreaded

本来は -te 1 や -te 10 でも既定の 32TB まで検定したかったのですが、
-te 0 に比べて時間がかかるので 8TB までにしました。
(3),(4),(5),(6)は、種１で異常はありませんでした。
(1)RNG_test stdin64 -tlmin 1GB -tf 2 -multithreadedは、種１で、

RNG_test stdin64 -tlmin 1GB -te 0 -tf 1 -multithreaded
QnxRand te0 tf1 10U Seed(1)
RNG_test using PractRand version 0.96
RNG = RNG_stdin64, seed = unknown
test set = core, folding = standard (64 bit)
...
length= 256 gigabytes (2^38 bytes), time= 1092 seconds
  Test Name                         Raw       Processed     Evaluation       
  [Low4/64]DC6-9x1Bytes-1           R=  -4.9  p =1-2.8e-3   unusual          
...
length= 32 terabytes (2^45 bytes), time= 136572 seconds
  no anomalies in 400 test result(s)

となりましたが、種２で、1GB から 32TB まで異常はありませんでした。

(2)RNG_test stdin64 -tlmin 1GB -tf 2 -multithreadedは、種１で、

RNG_test stdin64 -tlmin 1GB -te 0 -tf 2 -multithreaded
QnxRand te0 tf2 10U Seed(1)
RNG_test using PractRand version 0.96
RNG = RNG_stdin64, seed = unknown
test set = core, folding = extra
...
length= 4 gigabytes (2^32 bytes), time= 26.1 seconds
  Test Name                         Raw       Processed     Evaluation       
  [Low1/32]Gap-16:A                 R=  -4.5  p =1-2.8e-4   unusual          
...
length= 16 terabytes (2^44 bytes), time= 98920 seconds
  Test Name                         Raw       Processed     Evaluation       
  [Low8/32]BCFN(2+1,13-0U)          R=  -8.3  p =1-2.4e-4   unusual          
  ...and 975 test result(s) without anomalies
...
length= 32 terabytes (2^45 bytes), time= 197618 seconds
  no anomalies in 996 test result(s)

となりましたが、種８で、1GB から 32TB まで異常はありませんでした。

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

QnxRand 10U te0 tf1 Seed(7) 4GB  [Low1/64]FPF/16:all p=1-1.0e-4 unusual 
QnxRand 10U te0 tf1 Seed(12) 2GB  DC6-9x1Bytes-1 p=4.7e-4 unusual 
QnxRand 10U te0 tf1 Seed(27) 1GB  BRank(12):score:2560 p=1-4.0e-5 unusual 
QnxRand 10U te0 tf1 Seed(32) 1GB  [Low16/64]BRank(12):score:1792 p=4.2e-4 unusual 
QnxRand 10U te0 tf1 Seed(32) 2GB  [Low16/64]BRank(12):score:2048 p=4.4e-4 unusual 
QnxRand 10U te0 tf1 Seed(32) 2GB  [Low4/64]mod3n(5):(2,9-2) p=1.9e-4 unusual 
QnxRand 10U te0 tf1 Seed(32) 4GB  [Low16/64]BRank(12):score:2560 p=4.5e-4 unusual 
QnxRand 10U te0 tf1 Seed(37) 1GB  [Low1/64]DC6-9x1Bytes-1 p=1-1.5e-3 unusual

QnxRand 10U te0 tf2 Seed(1) 4GB  [Low1/32]Gap-16:A p=1-2.8e-4 unusual 
QnxRand 10U te0 tf2 Seed(4) 1GB  [Low1/8]BCFN(2+1,13-3U) p=1-2.7e-4 unusual 
QnxRand 10U te0 tf2 Seed(7) 4GB  [Low1/64]FPF/16:all p=1-1.0e-4 unusual 
QnxRand 10U te0 tf2 Seed(12) 2GB  DC6-9x1Bytes-1 p=4.7e-4 unusual 
QnxRand 10U te0 tf2 Seed(17) 4GB  [Low1/16]Gap-16:A p=1-3.2e-4 unusual 
QnxRand 10U te0 tf2 Seed(21) 1GB  [Low8/32]Gap-16:A p=1-2.4e-4 unusual 
QnxRand 10U te0 tf2 Seed(23) 2GB  [Low1/16]DC6-9x1Bytes-1 p=8.3e-4 unusual 
QnxRand 10U te0 tf2 Seed(27) 1GB  BRank(12):score:2560 p=1-4.0e-5 unusual 
QnxRand 10U te0 tf2 Seed(28) 2GB  [Low1/32]DC6-9x1Bytes-1 p=1-6.1e-4 unusual

QnxRand 10U te1 tf1 Seed(1) 2GB  [Low1/64]NS3[6:pd:both] p=1.1e-4 unusual 
QnxRand 10U te1 tf1 Seed(5) 4GB  NS3[3:pd:both] p=1.0e-4 unusual 
QnxRand 10U te1 tf1 Seed(12) 2GB  DC7-9x1Bytes-1:both p=4.7e-4 unusual 
QnxRand 10U te1 tf1 Seed(30) 2GB  FPF/4:cross p=1-8.3e-5 unusual 
QnxRand 10U te1 tf1 Seed(32) 1GB  [Low1/64]NS3[3:pd:both] p=2.5e-5 unusual 
QnxRand 10U te1 tf1 Seed(32) 2GB  [Low1/64]NS3[3:pd:both] p=8.9e-5 unusual 
QnxRand 10U te1 tf1 Seed(37) 1GB  [Low1/64]NS3[6:hw:both] p=5.8e-6 mildly suspicious

QnxRand 10U te1 tf2 Seed(6) 4GB  [Low8/32]NS3[0:pd:both] p=1.0e-4 unusual 
QnxRand 10U te1 tf2 Seed(9) 1GB  [Low4/64][C8]DC6-9x1Bytes-1 p=2.4e-4 unusual 
QnxRand 10U te1 tf2 Seed(29) 4GB  [Low1/8]DC7-5x4Bytes-1:even p=1.6e-5 unusual 
QnxRand 10U te1 tf2 Seed(32) 1GB  [Low1/64]NS3[3:pd:both] p=2.5e-5 unusual 
QnxRand 10U te1 tf2 Seed(35) 4GB  [Low4/32][C8]BCFN(2+0,13-4U) p=4.9e-5 unusual 
QnxRand 10U te1 tf2 Seed(36) 2GB  [Low1/32]NS3[6:hw:both] p=5.0e-6 unusual 
QnxRand 10U te1 tf2 Seed(37) 1GB  [Low1/64]NS3[6:hw:both] p=5.8e-6 unusual 
QnxRand 10U te1 tf2 Seed(39) 1GB  [Low1/32]NS3[5:hw:both] p=5.6e-7 mildly suspicious
QnxRand 10U te1 tf2 Seed(39) 1GB  [Low1/32]NS3[5:hw:all-] p=4.4e-6 unusual

te1 で mildly suspicious が出現しますが、
rdrandをtestU01とPractRand ver0.96で検定するの結論より問題ありません。
rdrand とほぼ同じ品質であることがわかります。

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

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

define.h, bincode.h はこちら bincode.h は Visual C++2002 と Visual C++ 2003 でのみ必要です。

/* qsc.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and Xorshift.

gcc, clang, vc2002 .. vc2026

*/
#if !defined(QSC_H__)
 #define QSC_H__
 #include "define.h"
 #if !defined(Cpuid)
  #include "bincode.h"
 #endif

 #if !defined(QSCEXP)
  #define QSCEXP DEFEXP
 #endif
 #if 3*QSCEXP-1 == -3 || QSCEXP < 1
  #undef QSCEXP
  #define QSCEXP 1
 #endif
 #define QSCNUM (1<<QSCEXP)
 #define QSCMUL (1<<(QSCEXP-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 Qsc_t
{ __m128i ret[QSCMUL],cnt[QSCMUL],fix; qword xs[QNSD]; int idx; } Qsc_t;

static const union tagQsc { qword q[2]; __m128i x; }
 QscZADD={{GOLDEN_GAMMA*QSCNUM,GOLDEN_GAMMA*QSCNUM}},
 QscZSMA={{SPLITMIX_A,SPLITMIX_A}},
 QscZSMB={{SPLITMIX_B,SPLITMIX_B}};

static qword QscNextState(qword*p) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword x=p[0],t=x; int i;
    for (i=0;i<QNSD-1;i++) p[i]=p[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=p[QNSD-1];
    t^=x; x>>=c; t^=x; p[QNSD-1]=t; return t;
}

static qword QscBackState(qword*p) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword t=p[QNSD-1],x=p[QNSD-2]; int i;
    for (i=QNSD-1;i>0;i--) p[i]=p[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; p[0]=t; return p[QNSD-1];
}

 #if defined(_M_IX86) || defined(__i386)
  #define MM_SET1_EPI64X(DST,SRC) { qword y[2]; __m128i x; y[0]=SRC; \
   x=_mm_loadu_si128((__m128i*)y); Save128(DST,_mm_unpacklo_epi64(x,x)); }
 #else
  #define MM_SET1_EPI64X(DST,SRC) { Save128(DST,_mm_set1_epi64x(SRC)); }
 #endif

static void QscGenAll(Qsc_t*p,int dir) {
 #if QSCMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m128i sma=QscZSMA.x,smb=QscZSMB.x,fix,y2,t,v;
    if (dir>0) {
        y2=QscZADD.x;
        if ((short)p->idx==0) MM_SET1_EPI64X(p->fix,QscNextState(p->xs))
    } else if (dir<0) {
        fix=_mm_setzero_si128();
        y2=_mm_sub_epi64(fix,QscZADD.x);
        if ((short)p->idx==0) MM_SET1_EPI64X(p->fix,QscBackState(p->xs))
    } else {
        y2=_mm_setzero_si128();
    }
    fix=Load128(p->fix);
 #if QSCMUL > 1
    for (i=0;i<QSCMUL;i++)
 #endif
    {
        t=Load128(p->cnt[i]);
        t=_mm_add_epi64(t,y2);
        Save128(p->cnt[i],t);
        v=t=_mm_xor_si128(t,fix);
        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 QscRand(Qsc_t*p) {
    int mod=p->idx&(QSCNUM-1);
    if (mod==0) QscGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword QscBack(Qsc_t*p) {
    int mod=--p->idx&(QSCNUM-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) QscGenAll(p,-1);
    return ret;
}

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

static void QscInitHelp(Qsc_t*p);

static const char*QscInit(Qsc_t*p,qword seed) {
    if (QscHaveSse2()==0) return"SSE2";
    *(qword*)p=InitByU64(p->xs,QNSD,seed); QscInitHelp(p); return 0;
}

static const char*QscInitByStr(Qsc_t*p,const char*key) {
    if (QscHaveSse2()==0) return"SSE2";
    *(qword*)p=InitByStr(p->xs,QNSD,key); QscInitHelp(p); return 0;
}

static void QscInitHelp(Qsc_t*p) {
    enum { n=128/64 }; int i,k;
    qword gg=GOLDEN_GAMMA,f=QscNextState(p->xs),c=*(qword*)p&~(qword)65535;
 #if defined(__GNUC__)
    (void)QscInit; (void)QscInitByStr;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<QSCMUL;k++) ((qword*)&p->cnt[k])[i]=gg*(k*n+i)+c;
        ((qword*)&p->fix)[i]=f;
    }
    p->idx=1; QscGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      QscRand
 #define ExName     "QscRand"
 #define ExInit      QscInit
 #define ExInitByStr QscInitByStr
 #define Ex_t        Qsc_t
 #define ExBack      QscBack
 #define ExBName    "QscBack"
 #define ExSExp      QSCEXP
 #define ExID        QID
 #define ExNsd       QNSD
 #define ExAlign     16
#endif

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

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

define.h, bincode.h はこちら

/* qsb.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and Xorshift.

gcc, clang, bcc5.5.1, vc5.0 .. vc2026

*/
#if !defined(QSB_H__)
 #define QSB_H__
 #include "define.h"
 #include "bincode.h"

 #if !defined(QSBEXP)
  #define QSBEXP DEFEXP
 #endif
 #if 3*QSBEXP-1 == -3 || QSBEXP < 1
  #undef QSBEXP
  #define QSBEXP 1
 #endif
 #define QSBNUM (1<<QSBEXP)
 #define QSBMUL (1<<(QSBEXP-1))

enum { QsbA=QNABC/10000%100, QsbB=QNABC/100%100, QsbC=QNABC%100 };
enum { QsbZRET,QsbZCNT=QsbZRET+QSBMUL,QsbZFIX=QsbZCNT+QSBMUL,QsbZADD,
       QsbZSMA,QsbZSMB,
 #if defined(CALLER_SAVED)
       QsbZXM6,QsbZXM7,
 #endif
       QsbZEND};

typedef struct Qsb_t {
    union tagQsbUnion {
        qword q[QsbZEND*128/64];
        m128i y[QsbZEND];
    } v;
    qword xs[QNSD]; int idx;
} Qsb_t;

 #if QSBMUL > 1
  #define LOAD_QSB LOAD_XMMeax
  #define SAVE_QSB SAVE_XMMeax
 #else
  #define LOAD_QSB LOAD_XMM
  #define SAVE_QSB SAVE_XMM
 #endif

static qword QsbNextState(qword*p) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword x=p[0],t=x; int i;
    for (i=0;i<QNSD-1;i++) p[i]=p[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=p[QNSD-1];
    t^=x; x>>=c; t^=x; p[QNSD-1]=t; return t;
}

static qword QsbBackState(qword*p) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword t=p[QNSD-1],x=p[QNSD-2]; int i;
    for (i=QNSD-1;i>0;i--) p[i]=p[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; p[0]=t; return p[QNSD-1];
}

static BINCODE__(QsbGenAll__)={
 #if defined(_M_IX86) || defined(__i386)
    FIRST_ARG() SECOND_ARG() /* +8  8 */
  #define QSB_NPAD 13        /* +13 5 */
 #elif defined(CALLER_SAVED)
    SAVE_XMM(QsbZXM6,xmm6),  /* +8  8 */
    SAVE_XMM(QsbZXM7,xmm7),  /* +8 16 */
  #define QSB_NPAD 5         /* +5  5 */
 #else
  #define QSB_NPAD 5         /* +5  5 */
 #endif
    LOAD_XMM(xmm2,QsbZADD), /* +8 13 */
    0x83,0xfa+RSI__,0,
     /* cmp edx,0              +3 16 */
    0x7f,14+QSB_NPAD,/* jg end +2 18 */
    MOVDQA(xmm3,xmm2),      /* +4 22 */
    PXOR(xmm2,xmm2),        /* +4 26 */
    0x74,4+QSB_NPAD, /* je end +2 28 */
    PSUBQ(xmm2,xmm3),       /* +4 32 */
 #if QSB_NPAD == 13
    NPAD13(),
 #elif QSB_NPAD == 5
    NPAD5(),
 #endif
/* end: */
    LOAD_XMM(xmm3,QsbZFIX), /* +8  8 */
    LOAD_XMM(xmm6,QsbZSMA), /* +8 16 */
    LOAD_XMM(xmm7,QsbZSMB), /* +8 24 */
 #if QSBMUL > 1
    0xb8,0,0,0,0, /* mov eax,0 +5 29 */
    NPAD3(),                /* +3 32 */
 #endif
/* repeat: */
    LOAD_QSB(xmm0,QsbZCNT), /* + 9,  9 */
    PADDQ(xmm0,xmm2),       /* + 4, 13 */
    SAVE_QSB(QsbZCNT,xmm0), /* + 9, 22 */
    PXOR(xmm0,xmm3),        /* + 4, 26 */
    MOVDQA(xmm1,xmm0),      /* + 4, 30 */
    PSRLQ(xmm0,30),         /* + 5, 35 */
    PXOR(xmm0,xmm1),        /* + 4, 39 */
    PMULLQ(xmm0,xmm6),        /* +48, 87 */
    MOVDQA(xmm1,xmm0),      /* + 4, 91 */
    PSRLQ(xmm0,27),         /* + 5, 96 */
    PXOR(xmm0,xmm1),        /* + 4,100 */
    PMULLQ(xmm0,xmm7),        /* +48,148 */
    MOVDQA(xmm1,xmm0),      /* + 4,152 */
    PSRLQ(xmm0,31),         /* + 5,157 */
    PXOR(xmm0,xmm1),        /* + 4,161 */
    SAVE_QSB(QsbZRET,xmm0), /* + 9,170 */
 #if QSBMUL > 1
    0x83,0xc0,0x10, /* add eax,16 */
                             /* + 3,173 */
    0x3d,INT_BYTE(QSBMUL*16),/* cmp eax,QSBMUL*16 */
                             /* + 5,178 */
    0x0f,0x82,INT_BYTE(-184), /* jb -184 +6,184 */
 #endif
 #if defined(CALLER_SAVED)
    LOAD_XMM(xmm6,QsbZXM6),
    LOAD_XMM(xmm7,QsbZXM7),
 #endif
    RET()
};
 #define QsbGenAll ((void(*)(Qsb_t*p,int d))(size_t)QsbGenAll__)

static __inline qword QsbRand(Qsb_t*p) {
    int idx=p->idx++,mod=idx&(QSBNUM-1);
    if (mod==0) {
        if ((short)idx==0)
            p->v.q[QsbZFIX*2]=p->v.q[QsbZFIX*2+1]=QsbNextState(p->xs);
        QsbGenAll(p,1);
    }
    return(p->v.q+QsbZRET*2)[mod];
}

static __inline qword QsbBack(Qsb_t*p) {
    int mod=--p->idx&(QSBNUM-1);
    qword z=(p->v.q+QsbZRET*2)[mod];
    if (mod==0) {
        if ((short)p->idx==0)
            p->v.q[QsbZFIX*2]=p->v.q[QsbZFIX*2+1]=QsbBackState(p->xs);
        QsbGenAll(p,-1);
    }
    return z;
}

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

static void QsbInitHelp(Qsb_t*p);

static const char*QsbInit(Qsb_t*p,qword seed) {
    if (QsbHaveSse2()==0) return"SSE2";
    *p->v.q=InitByU64(p->xs,QNSD,seed); QsbInitHelp(p); return 0;
}

static const char*QsbInitByStr(Qsb_t*p,const char*key) {
    if (QsbHaveSse2()==0) return"SSE2";
    *p->v.q=InitByStr(p->xs,QNSD,key); QsbInitHelp(p); return 0;
}

static void QsbInitHelp(Qsb_t*p) {
    enum { n=128/64 }; int i,k;
    qword gg=GOLDEN_GAMMA,f=QsbNextState(p->xs),c=*p->v.q&~(qword)65535;
 #if defined(__GNUC__)
    (void)QsbInit; (void)QsbInitByStr;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<QSBMUL;k++) p->v.q[QsbZCNT*n+k*n+i]=gg*(k*n+i)+c;
        p->v.q[QsbZFIX*n+i]=f;
        p->v.q[QsbZADD*n+i]=gg*QSBNUM;
        p->v.q[QsbZSMA*n+i]=SPLITMIX_A;
        p->v.q[QsbZSMB*n+i]=SPLITMIX_B;
    }
    p->idx=1; QsbGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      QsbRand
 #define ExName     "QsbRand"
 #define ExInit      QsbInit
 #define ExInitByStr QsbInitByStr
 #define Ex_t        Qsb_t
 #define ExBack      QsbBack
 #define ExBName    "QsbBack"
 #define ExSExp      QSBEXP
 #define ExID        QID
 #define ExNsd       QNSD
 #define ExAlign     16
#endif

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

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

define.h はこちら

/* qac.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and Xorshift.

gcc, clang, vc2013 .. vc2026

*/
#if !defined(QAC_H__)
 #define QAC_H__
 #include "define.h"

 #if !defined(QACEXP)
  #define QACEXP DEFEXP
 #endif
 #if 3*QACEXP-1 == -3 || QACEXP < 2
  #undef QACEXP
  #define QACEXP 2
 #endif
 #define QACNUM (1<<QACEXP)
 #define QACMUL (1<<(QACEXP-2))

typedef struct Qac_t
{ __m256i ret[QACMUL],cnt[QACMUL],fix; qword xs[QNSD]; int idx; } Qac_t;

 #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

static const union tagQac { qword q[4]; __m256i y; }
 QacZADD={{GOLDEN_GAMMA*QACNUM,GOLDEN_GAMMA*QACNUM,
           GOLDEN_GAMMA*QACNUM,GOLDEN_GAMMA*QACNUM}},
 QacZSMA={{SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A}},
 QacZSMB={{SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B}};

static qword QacNextState(qword*q) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword x=q[0],t=x; int i;
    for (i=0;i<QNSD-1;i++) q[i]=q[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=q[QNSD-1];
    t^=x; x>>=c; t^=x; q[QNSD-1]=t; return t;
}

static qword QacBackState(qword*q) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword t=q[QNSD-1],x=q[QNSD-2]; int i;
    for (i=QNSD-1;i>0;i--) q[i]=q[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; q[0]=t; return q[QNSD-1];
}

 #if defined(_M_IX86) || defined(__i386)
  #define MM256_SET1_EPI64X(DST,SRC) { qword o[4]; __m256i w1; \
       o[0]=SRC; w1=_mm256_loadu_si256((__m256i*)o);           \
       Save256(DST,_mm256_permute4x64_epi64(w1,0)); }
 #else
  #define MM256_SET1_EPI64X(DST,SRC) { qword o=SRC; __m256i w1; \
       w1=_mm256_set1_epi64x(o); Save256(DST,w1); }
 #endif
   
 // 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); }

static void QacGenAll(Qac_t*p,int dir) {
 #if QACMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m256i sma=QacZSMA.y,smb=QacZSMB.y,fix,add,t,v;
    if (dir>0) {
        add=QacZADD.y;
        if ((short)p->idx==0)
            MM256_SET1_EPI64X(p->fix,QacNextState(p->xs))
    } else if (dir<0) {
        fix=_mm256_setzero_si256();
        add=_mm256_sub_epi64(fix,QacZADD.y);
        if ((short)p->idx==0)
            MM256_SET1_EPI64X(p->fix,QacBackState(p->xs))
    } else {
        add=_mm256_setzero_si256();
    }
    fix=Load256(p->fix);
 #if QACMUL > 1
    for (i=0;i<QACMUL;i++)
 #endif
    {
        t=Load256(p->cnt[i]);
        t=_mm256_add_epi64(t,add);
        Save256(p->cnt[i],t);
        v=t=_mm256_xor_si256(t,fix);
        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 QacRand(Qac_t*p) {
    int mod=p->idx&(QACNUM-1);
    if (mod==0) QacGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword QacBack(Qac_t*p) {
    int mod=--p->idx&(QACNUM-1);
    qword z=((qword*)&p->ret)[mod];
    if (mod==0) QacGenAll(p,-1);
    return z;
}

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

static void QacInitHelp(Qac_t*p);

static const char*QacInit(Qac_t*p,qword seed) {
    if (QacHaveAvx2()==0) return"AVX2";
    *((qword*)p)=InitByU64(p->xs,QNSD,seed); QacInitHelp(p); return 0;
}

static const char*QacInitByStr(Qac_t*p,const char*key) {
    if (QacHaveAvx2()==0) return"AVX2";
    *(qword*)p=InitByStr(p->xs,QNSD,key); QacInitHelp(p); return 0;
}

static void QacInitHelp(Qac_t*p) {
    enum { n=256/64 }; int i,k;
    qword gg=GOLDEN_GAMMA,f=QacNextState(p->xs),c=*(qword*)p&~(qword)65535;
 #if defined(__GNUC__)
    (void)QacInit; (void)QacInitByStr;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<QACMUL;k++) ((qword*)&p->cnt[k])[i]=gg*(k*n+i)+c;
        ((qword*)&p->fix)[i]=f;
    }
    p->idx=1; QacGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      QacRand
 #define ExBack      QacBack
 #define ExInit      QacInit
 #define ExInitByStr QacInitByStr
 #define Ex_t        Qac_t
 #define ExName     "QacRand"
 #define ExBName    "QacBack"
 #define ExSExp      QACEXP
 #define ExID        QID
 #define ExNsd       QNSD
 #define ExAlign     32
#endif

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

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

define.h, bincode.h はこちら

/* qab.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and rdtsc.

gcc, clang, bcc5.5.1, vc5.0 .. vc2026

*/
#if !defined(QAB_H__)
 #define QAB_H__
 #include "define.h"
 #include "bincode.h"

 #if !defined(QABEXP)
  #define QABEXP DEFEXP
 #endif
 #if 3*QABEXP-1 == -3 || QABEXP < 2
  #undef QABEXP
  #define QABEXP 2
 #endif
 #define QABNUM (1<<QABEXP)
 #define QABMUL (1<<(QABEXP-2))

enum { QabZRET,QabZCNT=QabZRET+QABMUL,QabZFIX=QabZCNT+QABMUL,
       QabZADD,QabZSMA,QabZSMB,
 #if defined(CALLER_SAVED)
       QabZYM6,QabZYM7,
 #endif
       QabZEND};

typedef struct Qab_t {
    union tagQabUnion {
        qword q[QabZEND*256/64];
        m256i y[QabZEND];
    } v;
    qword xs[QNSD]; int idx;
} Qab_t;

 #if QABMUL > 1
  #define LOAD_QAB LOAD_YMMeax
  #define SAVE_QAB SAVE_YMMeax
 #else
  #define LOAD_QAB LOAD_YMM
  #define SAVE_QAB SAVE_YMM
 #endif

static qword QabNextState(qword*q) {
    enum { z=QNABC,n=QNSD,h=100,a=z/h/h%h,b=z/h%h,c=z%h };
    qword x=q[0],t=x; int i;
    for (i=0;i<n-1;i++) q[i]=q[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=q[n-1];
    t^=x; x>>=c; t^=x; q[n-1]=t; return t;
}

static qword QabBackState(qword*q) {
    enum { z=QNABC,n=QNSD,h=100,a=z/h/h%h,b=z/h%h,c=z%h };
    qword t=q[n-1],x=q[n-2]; int i;
    for (i=n-1;i>0;i--) q[i]=q[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; q[0]=t; return q[n-1];
}

static BINCODE__(QabGenAll__)={
 #if defined(_M_IX86) || defined(__i386)
    #define QAB_NPAD 13     /* +13 13 */
    FIRST_ARG() SECOND_ARG() /* +8 21(16+5) */
 #else
    #define QAB_NPAD  5     /* +5  5 */
 #endif
 #if defined(CALLER_SAVED)
    SAVE_YMM(QabZYM6,ymm6),
    SAVE_YMM(QabZYM7,ymm7),
 #endif
    LOAD_YMM(ymm2,QabZADD), /* +8 13 */
    0x83,0xfa+RSI__,0,
     /* cmp edx,0              +3 16 */
    0x7f,14+QAB_NPAD,/* jg end +2,18 */
    VPXOR(ymm3,ymm3,ymm3),  /* +4,22 */
    VPSUBQ(ymm2,ymm3,ymm2), /* +4,26 */
    0x7c,4+QAB_NPAD, /* jl end +2 28 */
    VPXOR(ymm2,ymm2,ymm2),  /* +4 32 */
 #if QAB_NPAD == 13
    NPAD13(),
 #elif QAB_NPAD == 5
    NPAD5(),
 #endif
/* end: */
    LOAD_YMM(ymm3,QabZFIX), /* +8  8 */
    LOAD_YMM(ymm6,QabZSMA), /* +8 16 */
    LOAD_YMM(ymm7,QabZSMB), /* +8 24 */
 #if QABMUL > 1
    0xb8,0,0,0,0, /* mov eax,0 +5 29 */
    NPAD3(),                /* +3 32 */
 #endif
/* repeat: */
    LOAD_QAB(ymm0,QabZCNT),    /* + 9,  9 */
    VPADDQ(ymm0,ymm0,ymm2),    /* + 4, 13 */
    SAVE_QAB(QabZCNT,ymm0),    /* + 9, 22 */
    VPXOR(ymm0,ymm3,ymm0),     /* + 4, 26 */
    VMOVDQA(ymm1,ymm0),        /* + 4, 30 */
    VPSRLQ(ymm0,ymm0,30),      /* + 5, 35 */
    VPXOR(ymm0,ymm1,ymm0),     /* + 4, 39 */
    VPMULLQ(ymm0,ymm6),        /* +40, 79 */
    VMOVDQA(ymm1,ymm0),        /* + 4, 83 */
    VPSRLQ(ymm0,ymm0,27),      /* + 5, 88 */
    VPXOR(ymm0,ymm1,ymm0),     /* + 4, 92 */
    VPMULLQ(ymm0,ymm7),        /* +40,132 */
    VMOVDQA(ymm1,ymm0),        /* + 4,136 */
    VPSRLQ(ymm0,ymm0,31),      /* + 5,141 */
    VPXOR(ymm0,ymm1,ymm0),     /* + 4,145 */
    SAVE_QAB(QabZRET,ymm0),    /* + 9,154 */
 #if QABMUL > 1
    0x83,0xc0,0x20, /* add eax,32 */
                             /* + 3,157 */
    0x3d,INT_BYTE(QABMUL*32),/* cmp eax,QABMUL*32 */
                             /* + 5,162 */
    0x0f,0x82,INT_BYTE(-168), /* jb -168 +6,168 */
 #endif
 #if defined(CALLER_SAVED)
    LOAD_YMM(ymm6,QabZYM6),
    LOAD_YMM(ymm7,QabZYM7),
 #endif
    VZEROUPPER(),
    RET()
};
 #define QabGenAll ((void(*)(Qab_t*p,int d))(size_t)QabGenAll__)

 #if defined(_MSC_VER)
static __inline qword QabRand(Qab_t*p) {
    int idx=p->idx++,mod=idx&(QABNUM-1);
    if (mod==0) {
        if ((short)idx==0) {
            qword fix=QabNextState(p->xs); int i;
            for (i=0;i<4;i++) p->v.q[QabZFIX*4+i]=fix;
        }
        QabGenAll(p,1);
    }
    return(p->v.q+QabZRET*256/64)[mod];
}
 #else
static __inline qword QabRand(Qab_t*p) {
    int mod=p->idx&(QABNUM-1);
    if (mod==0) {
        if ((short)p->idx==0) {
            qword fix=QabNextState(p->xs); int i;
            for (i=0;i<4;i++) p->v.q[QabZFIX*4+i]=fix;
        }
        QabGenAll(p,1);
    }
    p->idx++; return(p->v.q+QabZRET*256/64)[mod];
}
 #endif
static __inline qword QabBack(Qab_t*p) {
    int idx=--p->idx,mod=idx&(QABNUM-1);
    qword z=(p->v.q+QabZRET*256/64)[mod];
    if (mod==0) {
        if ((short)idx==0) {
            qword fix=QabBackState(p->xs); int i;
            for (i=0;i<4;i++) p->v.q[QabZFIX*4+i]=fix;
        }
        QabGenAll(p,-1);
    }
    return z;
}

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

static void QabInitHelp(Qab_t*p);

static const char*QabInit(Qab_t*p,qword seed) {
    if (QabHaveAvx2()==0) return"AVX2";
    *p->v.q=InitByU64(p->xs,QNSD,seed); QabInitHelp(p); return 0;
}

static const char*QabInitByStr(Qab_t*p,const char*key) {
    if (QabHaveAvx2()==0) return"AVX2";
    *p->v.q=InitByStr(p->xs,QNSD,key); QabInitHelp(p); return 0;
}

static void QabInitHelp(Qab_t*p) {
    enum { n=256/64 }; int i,k;
    qword gg=GOLDEN_GAMMA,f=QabNextState(p->xs),c=*p->v.q&~(qword)65535;
 #if defined(__GNUC__)
    (void)QabInit; (void)QabInitByStr;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<QABMUL;k++) p->v.q[QabZCNT*n+k*n+i]=gg*(k*n+i)+c;
        p->v.q[QabZFIX*n+i]=f;
        p->v.q[QabZADD*n+i]=gg*QABNUM;
        p->v.q[QabZSMA*n+i]=SPLITMIX_A;
        p->v.q[QabZSMB*n+i]=SPLITMIX_B;
    }
    p->idx=1; QabGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      QabRand
 #define ExName     "QabRand"
 #define ExInit      QabInit
 #define ExInitByStr QabInitByStr
 #define Ex_t        Qab_t
 #define ExBack      QabBack
 #define ExBName    "QabBack"
 #define ExSExp      QABEXP
 #define ExID        QID
 #define ExNsd       QNSD
 #define ExAlign     32
#endif

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

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

define.h はこちら

/* qbc.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and Xorshift.

gcc, clang, vc2017 .. vc2026

*/
#if !defined(QBC_H__)
 #define QBC_H__
 #include "define.h"

 #if !defined(QBCEXP)
  #define QBCEXP DEFEXP
 #endif
 #if 3*QBCEXP-1 == -3 || QBCEXP < 3
  #undef QBCEXP
  #define QBCEXP 3
 #endif
 #define QBCNUM (1<<QBCEXP)
 #define QBCMUL (1<<(QBCEXP-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 Qbc_t {
    __m512i ret[QBCMUL],cnt[QBCMUL],fix;
    qword xs[QNSD];
    int idx;
} Qbc_t;

static const union tagQbc { qword q[8]; __m512i z; }
 QbcZADD={{GOLDEN_GAMMA*QBCNUM,GOLDEN_GAMMA*QBCNUM,
           GOLDEN_GAMMA*QBCNUM,GOLDEN_GAMMA*QBCNUM,
           GOLDEN_GAMMA*QBCNUM,GOLDEN_GAMMA*QBCNUM,
           GOLDEN_GAMMA*QBCNUM,GOLDEN_GAMMA*QBCNUM}},
 QbcZSMA={{SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,
           SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A}},
 QbcZSMB={{SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,
           SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B}};

static qword QbcNextState(qword*p) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword x=p[0],t=x; int i;
    for (i=0;i<QNSD-1;i++) p[i]=p[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=p[QNSD-1];
    t^=x; x>>=c; t^=x; p[QNSD-1]=t; return t;
}

static qword QbcBackState(qword*p) {
    enum { a=(QNABC/10000)%100,b=(QNABC/100)%100,c=QNABC%100 };
    qword t=p[QNSD-1],x=p[QNSD-2]; int i;
    for (i=QNSD-1;i>0;i--) p[i]=p[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; p[0]=t; return p[QNSD-1];
}

static void QbcGenAll(Qbc_t*p,int dir) {
 #if QBCMUL > 1
    int i; 
 #else
    enum {i};
 #endif
    __m512i sma=QbcZSMA.z,smb=QbcZSMB.z,fix,y2,t,v;
    if (dir>0) {
        y2=QbcZADD.z;
        if ((short)p->idx==0)
            Save512(p->fix,_mm512_set1_epi64(QbcNextState(p->xs)));
    } else if (dir<0) {
        fix=_mm512_setzero_si512();
        y2=_mm512_sub_epi64(fix,QbcZADD.z);
        if ((short)p->idx==0)
            Save512(p->fix,_mm512_set1_epi64(QbcBackState(p->xs)));
    } else {
        y2=_mm512_setzero_si512();
    }
    fix=Load512(p->fix);
 #if QBCMUL > 1
    for (i=0;i<QBCMUL;i++)
 #endif
    {
        t=Load512(p->cnt[i]);
        t=_mm512_add_epi64(t,y2);
        Save512(p->cnt[i],t);
        v=t=_mm512_xor_si512(t,fix);
        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 QbcRand(Qbc_t*p) {
    int mod=p->idx&(QBCNUM-1);
    if (mod==0) QbcGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword QbcBack(Qbc_t*p) {
    int mod=--p->idx&(QBCNUM-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) QbcGenAll(p,-1);
    return ret;
}

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

static void QbcInitHelp(Qbc_t*p);

static const char*QbcInit(Qbc_t*p,qword seed) {
    if (QbcHaveAvx512DQ()==0) return"AVX512DQ";
    *(qword*)p=InitByU64(p->xs,QNSD,seed); QbcInitHelp(p); return 0;
}

static const char*QbcInitByStr(Qbc_t*p,const char*key) {
    if (QbcHaveAvx512DQ()==0) return"AVX512DQ";
    *(qword*)p=InitByStr(p->xs,QNSD,key); QbcInitHelp(p); return 0;
}

static void QbcInitHelp(Qbc_t*p) {
    enum { n=512/64 }; int i,k;
    qword gg=GOLDEN_GAMMA,f=QbcNextState(p->xs),c=*(qword*)p&~(qword)65535;
 #if defined(__GNUC__)
    (void)QbcInit; (void)QbcInitByStr;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<QBCMUL;k++) ((qword*)&p->cnt[k])[i]=gg*(k*n+i)+c;
        ((qword*)&p->fix)[i]=f;
    }
    p->idx=1; QbcGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      QbcRand
 #define ExName     "QbcRand"
 #define ExInit      QbcInit
 #define ExInitByStr QbcInitByStr
 #define Ex_t        Qbc_t
 #define ExBack      QbcBack
 #define ExBName    "QbcBack"
 #define ExSExp      QBCEXP
 #define ExID        QID
 #define ExNsd       QNSD
 #define ExAlign     64
#endif

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

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

define.h, bincode.h はこちら

/* qbb.h : coded by Isaku WADA(isaku@pb4.so-net.ne.jp) 2026
A PRNG combining SplitMix64 and Xorshift.

gcc, clang, bcc5.5.1, vc5.0 .. vc2026

*/
#if !defined(QBB_H__)
 #define QBB_H__
 #include "define.h"
 #include "bincode.h"

 #if !defined(QBBEXP)
  #define QBBEXP DEFEXP
 #endif
 #if 3*QBBEXP-1 == -3 || QBBEXP < 3
  #undef QBBEXP
  #define QBBEXP 3
 #endif
 #define QBBNUM (1<<QBBEXP)
 #define QBBMUL (1<<(QBBEXP-3))

enum { QbbA=QNABC/10000%100, QbbB=QNABC/100%100, QbbC=QNABC%100 };
enum { QbbZRET,QbbZCNT=QbbZRET+QBBMUL,QbbZFIX=QbbZCNT+QBBMUL,QbbZADD,
       QbbZSMA,QbbZSMB,QbbZEND};

typedef struct Qbb_t {
    union tagQbbUnion {
        qword q[QbbZEND*512/64];
        m512i z[QbbZEND];
    } v;
    qword xs[QNSD];
    int idx;
} Qbb_t;

 #if QBBMUL > 1
  #define LOAD_QBB LOAD_ZMMeax
  #define SAVE_QBB SAVE_ZMMeax
 #else
  #define LOAD_QBB LOAD_ZMM
  #define SAVE_QBB SAVE_ZMM
 #endif

static qword QbbNextState(qword*q) {
    enum { h=100,a=QNABC/h/h%h,b=QNABC/h%h,c=QNABC%h };
    qword x=q[0],t=x; int i;
    for (i=0;i<QNSD-1;i++) q[i]=q[i+1];
    x<<=a; t^=x; x=t; x>>=b; t^=x; x=q[QNSD-1];
    t^=x; x>>=c; t^=x; q[QNSD-1]=t; return t;
}

static qword QbbBackState(qword*q) {
    enum { h=100,a=QNABC/h/h%h,b=QNABC/h%h,c=QNABC%h };
    qword t=q[QNSD-1],x=q[QNSD-2]; int i;
    for (i=QNSD-1;i>0;i--) q[i]=q[i-1];
    t^=x; x>>=c; t^=x; x=t; x>>=b; t^=x;
    x=t; x<<=a; t^=x; q[0]=t; return q[QNSD-1];
}

static BINCODE__(QbbGenAll__)={
 #if defined(_M_IX86) || defined(__i386)
    #define QBB_NPAD 5       /* +5  5 */
    FIRST_ARG() SECOND_ARG() /* +8 13 */
 #else
    #define QBB_NPAD 13
 #endif
    LOAD_ZMM(zmm2,QbbZADD), /* +10 23 */
    0x83,0xfa+RSI__,0,
     /* cmp edx,0               +3 26 */
    0x7f,20+QBB_NPAD,/* jg end: +2,28 */
    VPXORD(zmm3,zmm3,zmm3), /*  +6,34 */
    VPSUBQz(zmm2,zmm3,zmm2), /* +6,40 */
    0x7c,6+QBB_NPAD, /* jl end: +2 42 */
    VPXORD(zmm2,zmm2,zmm2),  /* +6 48 */
 #if QBB_NPAD == 5
    NPAD5(),
 #elif QBB_NPAD == 13
    NPAD13(),
 #endif
/* end: */
    LOAD_ZMM(zmm3,QbbZFIX), /* +10 10 */
    LOAD_ZMM(zmm4,QbbZSMA), /* +10 20 */
    LOAD_ZMM(zmm5,QbbZSMB), /* +10 30 */
 #if QBBMUL > 1
    0x31,0xc0, /* xor eax,eax   +2 32 */
 #endif
/* repeat: */
    LOAD_QBB(zmm0,QbbZCNT),  /* +11, 11 */
    VPADDQz(zmm0,zmm2,zmm0), /* + 6, 17 */
    SAVE_QBB(QbbZCNT,zmm0),  /* +11, 28 */
    VPXORD(zmm0,zmm3,zmm0),  /* + 6, 34 */
    VMOVDQA64(zmm1,zmm0),    /* + 6, 40 */
    VPSRLQz(zmm0,zmm0,30),   /* + 7, 47 */
    VPXORD(zmm0,zmm1,zmm0),  /* + 6, 53 */
    VPMULLQz(zmm0,zmm4,zmm0),/* + 6, 59 */
    VMOVDQA64(zmm1,zmm0),    /* + 6, 65 */
    VPSRLQz(zmm0,zmm0,27),   /* + 7, 72 */
    VPXORD(zmm0,zmm1,zmm0),  /* + 6, 78 */
    VPMULLQz(zmm0,zmm5,zmm0),/* + 6, 84 */
    VMOVDQA64(zmm1,zmm0),    /* + 6, 90 */
    VPSRLQz(zmm0,zmm0,31),   /* + 7, 97 */
    VPXORD(zmm0,zmm1,zmm0),  /* + 6,103 */
    SAVE_QBB(QbbZRET,zmm0),  /* +11,114 */
 #if QBBMUL > 1
    0x83,0xc0,0x40, /* add eax,64 */
                             /* + 3,117 */
    0x3d,INT_BYTE(QBBMUL*64),/* cmp eax,QBBMUL*64 */
                             /* + 5,122 */
    0x72,-124&255, /* jb -124   + 2,124 */
 #endif
    VZEROUPPER(),
    RET()
};
 #define QbbGenAll ((void(*)(Qbb_t*p,int d))(size_t)QbbGenAll__)

 #if defined(_MSC_VER) && 0
static __inline qword QbbRand(Qbb_t*p) {
    int idx=p->idx++,mod=idx&(QBBNUM-1);
    if (mod==0) {
        if ((short)idx==0) {
            qword fix=QbbNextState(p->xs); int i;
            for (i=0;i<8;i++) p->v.q[QbbZFIX*8+i]=fix;
        }
        QbbGenAll(p,1);
    }
    return(p->v.q+QbbZRET*8)[mod];
}
 #else
static __inline qword QbbRand(Qbb_t*p) {
    int mod=p->idx&(QBBNUM-1);
    if (mod==0) {
        if ((short)p->idx==0) {
            qword fix=QbbNextState(p->xs); int i;
            for (i=0;i<8;i++) p->v.q[QbbZFIX*8+i]=fix;
        }
        QbbGenAll(p,1);
    }
    p->idx++; return(p->v.q+QbbZRET*8)[mod];
}
 #endif

static __inline qword QbbBack(Qbb_t*p) {
    int mod=--p->idx&(QBBNUM-1);
    qword z=(p->v.q+QbbZRET*8)[mod];
    if (mod==0) {
        if ((short)p->idx==0) {
            qword fix=QbbBackState(p->xs); int i;
            for (i=0;i<8;i++) p->v.q[QbbZFIX*8+i]=fix;
        }
        QbbGenAll(p,-1);
    }
    return z;
}

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

static void QbbInitHelp(Qbb_t*p);

static const char*QbbInit(Qbb_t*p,qword seed) {
    if (QbbHaveAvx512DQ()==0) return"AVX512DQ";
    *p->v.q=InitByU64(p->xs,QNSD,seed); QbbInitHelp(p); return 0;
}

static const char*QbbInitByStr(Qbb_t*p,const char*key) {
    if (QbbHaveAvx512DQ()==0) return"AVX512DQ";
    *p->v.q=InitByStr(p->xs,QNSD,key); QbbInitHelp(p); return 0;
}

static void QbbInitHelp(Qbb_t*p) {
    enum { n=512/64 }; int i,k;
    qword gg=GOLDEN_GAMMA,f=QbbNextState(p->xs),c=*p->v.q&~(qword)65535;
 #if defined(__GNUC__)
    (void)QbbInit; (void)QbbInitByStr;
 #endif
    for (i=0;i<n;i++) {
        for (k=0;k<QBBMUL;k++) p->v.q[QbbZCNT*n+k*n+i]=gg*(k*n+i)+c;
        p->v.q[QbbZFIX*n+i]=f;
        p->v.q[QbbZADD*n+i]=gg*QBBNUM;
        p->v.q[QbbZSMA*n+i]=SPLITMIX_A;
        p->v.q[QbbZSMB*n+i]=SPLITMIX_B;
    }
    p->idx=1; QbbGenAll(p,0);
}

#endif

#if !defined(ExRand)
 #define ExRand      QbbRand
 #define ExName     "QbbRand"
 #define ExInit      QbbInit
 #define ExInitByStr QbbInitByStr
 #define Ex_t        Qbb_t
 #define ExBack      QbbBack
 #define ExBName    "QbbBack"
 #define ExSExp      QBBEXP
 #define ExID        QID
 #define ExNsd       QNSD
 #define ExAlign     64
#endif

［前：SplitMix64とXorshiftを組み合わせる(小型)］［ExRand目次］［次：SplitMix64とXorshiftを組み合わせる(高機能版)］