［前：SplitMix64とXorshiftを組み合わせる］［ExRand目次］［次：性能評価］

[QNX]SplitMix64とXorshiftを組み合わせる(高機能版)

[qnx]SplitMix64とXorshiftを組み合わせる(高機能版)

高機能版は既定では qnc.h と同じ系列を生成します。
加えて、高機能版は xorshift 部分のパラメータを変更できます。
xorshift のパラメータは A から V までの２２種類が選べます。
既定のパラメータは U です。これは xorshift の種の数が１０です。
A の種の数は３です。
B,C,D,E,F,G,H,I の種の数は４です。
J,K の種の数は５です。
L,M の種の数は６です。
N,O,P の種の数は７です。
Q,R,S の種の数は８です。
T の種の数は９です。
U,V の種の数は１０です。
コンパイル時に -DXIDA または -DXNSD3 とするとパラメータを A に変更できます。
同様に -DXIDB とするとパラメータを B に変更できます。
-DXIDC または -DXNSD4 とするとパラメータは C になります。
-DXIDK または -DXNSD5 とするとパラメータは K になります。
-DXIDM または -DXNSD6 とするとパラメータは M になります。
-DXIDN または -DXNSD7 とするとパラメータは N になります。
-DXIDS または -DXNSD8 とするとパラメータは S になります。
-DXIDT または -DXNSD9 とするとパラメータは T になります。
-DXIDU または -DXNSD10 とするとパラメータは U になります。

また、高機能版はジャンプしたり、文字列で初期化する機能も加えてあります。

しかし、高機能版には機械語版はありません。

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

define.h, xgf2.h, xgf2.c はこちら

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

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

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

typedef struct Qnx_t { qword cnt,xs[XNSD]; } Qnx_t;

static __inline qword QnxRand(Qnx_t*p) {
    qword z=(p->cnt+=GOLDEN_GAMMA);
    if ((short)z==0) XorNextState1(p->xs);
    return SplitMixFinal(z^p->xs[XNSD-1]);
}

static __inline qword QnxBack(Qnx_t*p) {
    qword z=SplitMixFinal(p->cnt^p->xs[XNSD-1]);
    if ((short)p->cnt==0) XorBackState1(p->xs);
    p->cnt-=GOLDEN_GAMMA; return z;
}

static __inline void QnxJump(Qnx_t*p,double lag)
{ QxJumpHelp(lag,&p->cnt,p->xs,1,0); }

static __inline const char*QnxInit(Qnx_t*p,qword seed) {
    InitByU64(p->xs,seed); p->cnt=0U-GOLDEN_GAMMA;
    QnxRand(p); return 0;
}

static __inline const char*QnxInitByStr(Qnx_t*p,const char*key) {
    InitByStr((unsigned*)p->xs,key); p->cnt=0U-GOLDEN_GAMMA;
    QnxRand(p); return 0;
}

#endif

#if !defined(ExRand)
 #define ExRand      QnxRand
 #define ExBack      QnxBack
 #define ExName     "QnxRand"
 #define ExBName    "QnxBack"
 #define ExInit      QnxInit
 #define ExInitByStr QnxInitByStr
 #define ExJump      QnxJump
 #define ExSExp      0
 #define ExID        XID
 #define ExNsd       XNSD
 #define Ex_t        Qnx_t
 #define ExAlign     8
#endif

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

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

define.h, bincode.h, xgf2.h, xgf2.c はこちら

bincode.h は Visual C++2002 と Visual C++ 2003 でのみ必要です。

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

gcc, clang, vc2002 .. vc2022

*/
#if !defined(QSX_H__)
 #define QSX_H__
 #include "define.h"
 #if !defined(Cpuid)
  #include "bincode.h"
 #endif
 #include "xgf2.h"
 #include <string.h>
 #include <math.h>

 #if !defined(QSXEXP)
  #define QSXEXP 3
 #endif
 #define QSXNUM (1<<QSXEXP)
 #define QSXMUL (1<<(QSXEXP-1))

typedef struct Qsx_t
{ __m128i ret[QSXMUL],cnt[QSXMUL],fix; qword xs[XNSD]; int idx; } Qsx_t;

extern GCC_NOINLINE void QsxGenAll(Qsx_t*p,int dir);
extern const char*QsxInit(Qsx_t*p,qword seed);
extern const char*QsxInitByStr(Qsx_t*p,const char*key);
extern void QsxJump(Qsx_t*p,double lag);

static __inline qword QsxRand(Qsx_t*p) {
    int mod=p->idx&(QSXNUM-1);
    if (mod==0) QsxGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword QsxBack(Qsx_t*p) {
    int mod=--p->idx&(QSXNUM-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) QsxGenAll(p,-1);
    return ret;
}

#endif

#if !defined(ExRand)
 #define ExRand      QsxRand
 #define ExBack      QsxBack
 #define ExName     "QsxRand"
 #define ExBName    "QsxBack"
 #define ExInit      QsxInit
 #define ExInitByStr QsxInitByStr
 #define ExJump      QsxJump
 #define ExSExp      QSXEXP
 #define ExID        XID
 #define ExNsd       XNSD
 #define Ex_t        Qsx_t
 #define ExAlign     16
#endif

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

gcc, clang, vc2002 .. vc2022

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

 #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

 #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

  /* 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); }

static const union tagQsx { qword q[2]; __m128i x; }
 QsxZADD={{GOLDEN_GAMMA*QSXNUM,GOLDEN_GAMMA*QSXNUM}},
 QsxZSMA={{SPLITMIX_A,SPLITMIX_A}},
 QsxZSMB={{SPLITMIX_B,SPLITMIX_B}};

GCC_NOINLINE void QsxGenAll(Qsx_t*p,int dir) {
 #if QSXMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m128i sma=QsxZSMA.x,smb=QsxZSMB.x,fix,add,t,v;
    if (dir>0) {
        add=QsxZADD.x;
        if ((short)p->idx==0) MM_SET1_EPI64X(p->fix,XorNextState1(p->xs))
    } else if (dir<0) {
        fix=_mm_setzero_si128();
        add=_mm_sub_epi64(fix,QsxZADD.x);
        if ((short)p->idx==0) MM_SET1_EPI64X(p->fix,XorBackState1(p->xs))
    } else {
        add=_mm_setzero_si128();
    }
    fix=Load128(p->fix);
 #if QSXMUL > 1
    for (i=0;i<QSXMUL;i++)
 #endif
    {
        t=Load128(p->cnt[i]);
        t=_mm_add_epi64(t,add);
        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));
    }
}

GCC_NOINLINE static void QsxInitSub(Qsx_t*p) {
    enum { n=128/64 };
    qword gg=GOLDEN_GAMMA,w=XorNextState1(p->xs);int i,k;
    for (i=0;i<n;i++) {
        for (k=0;k<QSXMUL;k++) ((qword*)&p->cnt[k])[i]=gg*(k*n+i);
        ((qword*)&p->fix)[i]=w;
    }
    p->idx=1; QsxGenAll(p,0);
}

void QsxJump(Qsx_t*p,double lag) {
    QxJumpHelp(lag,(qword*)p->cnt,p->xs,QSXNUM,&p->idx);
    MM_SET1_EPI64X(p->fix,p->xs[XNSD-1]); QsxGenAll(p,0);
}

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

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

const char*QsxInit(Qsx_t*p,qword seed) {
    if (QsxHaveSse2()==0) return"SSE2";
    InitByU64(p->xs,seed); QsxInitSub(p);
    return 0;
}

const char*QsxInitByStr(Qsx_t*p,const char*key) {
    if (QsxHaveSse2()==0) return"SSE2";
    InitByStr((unsigned*)p->xs,key); QsxInitSub(p);
    return 0;
}

#endif

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

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

define.h, xgf2.h, xgf2.c はこちら

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

gcc, clang, vc2013 .. vc2022

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

 #if !defined(QAXEXP)
  #define QAXEXP 4
 #endif
 #define QAXNUM (1<<QAXEXP)
 #define QAXMUL (1<<(QAXEXP-2))

typedef struct Qax_t
{ __m256i ret[QAXMUL],cnt[QAXMUL],fix; qword xs[XNSD]; int idx; } Qax_t;

extern void QaxGenAll(Qax_t*p,int dir);
extern const char*QaxInit(Qax_t*p,qword seed);
extern const char*QaxInitByStr(Qax_t*p,const char*key);
extern void QaxJump(Qax_t*p,double lag);

static __inline qword QaxRand(Qax_t*p) {
    int mod=p->idx&(QAXNUM-1);
    if (mod==0) QaxGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword QaxBack(Qax_t*p) {
    int mod=--p->idx&(QAXNUM-1);
    qword ret=((qword*)&p->ret)[mod];
    if (mod==0) QaxGenAll(p,-1);
    return ret;
}

#endif

#if !defined(ExRand)
 #define ExRand      QaxRand
 #define ExBack      QaxBack
 #define ExName     "QaxRand"
 #define ExBName    "QaxBack"
 #define ExInit      QaxInit
 #define ExInitByStr QaxInitByStr
 #define ExJump      QaxJump
 #define ExSExp      QAXEXP
 #define ExID        XID
 #define ExNsd       XNSD
 #define Ex_t        Qax_t
 #define ExAlign     32
#endif

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

gcc, clang, vc2013 .. vc2022

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

 #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

 #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 const union tagQax { qword q[4]; __m256i y; }
 QaxZADD={{GOLDEN_GAMMA*QAXNUM,GOLDEN_GAMMA*QAXNUM,
           GOLDEN_GAMMA*QAXNUM,GOLDEN_GAMMA*QAXNUM}},
 QaxZSMA={{SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A}},
 QaxZSMB={{SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B}};

GCC_NOINLINE void QaxGenAll(Qax_t*p,int dir) {
 #if QAXMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m256i sma=QaxZSMA.y,smb=QaxZSMB.y,fix,y2,t,v;
    if (dir>0) {
        y2=QaxZADD.y;
        if ((short)p->idx==0)
            MM256_SET1_EPI64X(p->fix,XorNextState1(p->xs))
    } else if (dir<0) {
        fix=_mm256_setzero_si256();
        y2=_mm256_sub_epi64(fix,QaxZADD.y);
        if ((short)p->idx==0)
            MM256_SET1_EPI64X(p->fix,XorBackState1(p->xs))
    } else {
        y2=_mm256_setzero_si256();
    }
    fix=Load256(p->fix);
 #if QAXMUL > 1
    for (i=0;i<QAXMUL;i++)
 #endif
    {
        t=Load256(p->cnt[i]);
        t=_mm256_add_epi64(t,y2);
        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();
}

GCC_NOINLINE static void QaxInitSub(Qax_t*p) {
    enum { n=256/64 };
    qword gg=GOLDEN_GAMMA,w=XorNextState1(p->xs);int i,k;
    for (i=0;i<n;i++) {
        for (k=0;k<QAXMUL;k++) ((qword*)&p->cnt[k])[i]=gg*(k*n+i);
        ((qword*)&p->fix)[i]=w;
    }
    p->idx=1; QaxGenAll(p,0);
}
void QaxJump(Qax_t*p,double lag) {
    QxJumpHelp(lag,(qword*)p->cnt,p->xs,QAXNUM,&p->idx);
    MM256_SET1_EPI64X(p->fix,p->xs[XNSD-1]); QaxGenAll(p,0);
}

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

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

const char*QaxInit(Qax_t*p,qword seed) {
    if (QaxHaveAvx2()==0) return"AVX2";
    InitByU64(p->xs,seed); QaxInitSub(p);
    return 0;
}

const char*QaxInitByStr(Qax_t*p,const char*key) {
    if (QaxHaveAvx2()==0) return"AVX2";
    InitByStr((unsigned*)p->xs,key); QaxInitSub(p);
    return 0;
}

#endif

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

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

define.h, xgf2.h, xgf2.c はこちら

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

gcc, clang, vc2017 .. vc2022

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

 #if !defined(QBXEXP)
  #define QBXEXP 4
 #endif
 #define QBXNUM (1<<QBXEXP)
 #define QBXMUL (1<<(QBXEXP-3))

typedef struct Qbx_t
{ __m512i ret[QBXMUL],cnt[QBXMUL],fix; qword xs[XNSD]; int idx; } Qbx_t;

extern GCC_NOINLINE void QbxGenAll(Qbx_t*p,int dir);

static __inline qword QbxRand(Qbx_t*p) {
    int mod=p->idx&(QBXNUM-1);
    if (mod==0) QbxGenAll(p,1);
    p->idx++; return((qword*)&p->ret)[mod];
}

static __inline qword QbxBack(Qbx_t*p) {
    int mod=--p->idx&(QBXNUM-1); qword ret=((qword*)&p->ret)[mod];
    if (mod==0) QbxGenAll(p,-1);
    return ret;
}

extern const char*QbxInit(Qbx_t*p,qword s);
extern const char*QbxInitByStr(Qbx_t*p,const char*key);
extern void QbxJump(Qbx_t*p,double lag);

#endif

#if !defined(ExRand)
 #define ExRand      QbxRand
 #define ExBack      QbxBack
 #define ExName     "QbxRand"
 #define ExBName    "QbxBack"
 #define ExInit      QbxInit
 #define ExInitByStr QbxInitByStr
 #define ExJump      QbxJump
 #define ExSExp      QBXEXP
 #define ExID        XID
 #define ExNsd       XNSD
 #define Ex_t        Qbx_t
 #define ExAlign     64
#endif

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

gcc, clang, vc2017 .. vc2022

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

 #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

static const union tagQbx { qword q[8]; __m512i z; }
 QbxZADD={{GOLDEN_GAMMA*QBXNUM,GOLDEN_GAMMA*QBXNUM,
           GOLDEN_GAMMA*QBXNUM,GOLDEN_GAMMA*QBXNUM,
           GOLDEN_GAMMA*QBXNUM,GOLDEN_GAMMA*QBXNUM,
           GOLDEN_GAMMA*QBXNUM,GOLDEN_GAMMA*QBXNUM}},
 QbxZSMA={{SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,
           SPLITMIX_A,SPLITMIX_A,SPLITMIX_A,SPLITMIX_A}},
 QbxZSMB={{SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,
           SPLITMIX_B,SPLITMIX_B,SPLITMIX_B,SPLITMIX_B}};

GCC_NOINLINE void QbxGenAll(Qbx_t*p,int dir) {
 #if QBXMUL > 1
    int i;
 #else
    enum {i};
 #endif
    __m512i sma=QbxZSMA.z,smb=QbxZSMB.z,fix,add,t,v;
    if (dir>0) {
        add=QbxZADD.z;
        if ((short)p->idx==0)
            Save512(p->fix,_mm512_set1_epi64(XorNextState1(p->xs)));
    } else if (dir<0) {
        fix=_mm512_setzero_si512();
        add=_mm512_sub_epi64(fix,QbxZADD.z);
        if ((short)p->idx==0)
            Save512(p->fix,_mm512_set1_epi64(XorBackState1(p->xs)));
    } else {
        add=_mm512_setzero_si512();
    }
    fix=Load512(p->fix);
 #if QBXMUL > 1
    for (i=0;i<QBXMUL;i++)
 #endif
    {
        t=Load512(p->cnt[i]);
        t=_mm512_add_epi64(t,add);
        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();
}

GCC_NOINLINE static void QbxInitSub(Qbx_t*p) {
    enum { n=512/64 };
    qword gg=GOLDEN_GAMMA,w=XorNextState1(p->xs); int i,k;
    for (i=0;i<n;i++) {
        for (k=0;k<QBXMUL;k++) ((qword*)&p->cnt[k])[i]=gg*(k*n+i);
        ((qword*)&p->fix)[i]=w;
    }
    p->idx=1; QbxGenAll(p,0);
}

void QbxJump(Qbx_t*p,double lag) {
    QxJumpHelp(lag,(qword*)p->cnt,p->xs,QBXNUM,&p->idx);
    Save512(p->fix,_mm512_set1_epi64(p->xs[XNSD-1])); QbxGenAll(p,0);
}

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

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

const char*QbxInit(Qbx_t*p,qword seed) {
    if (QbxHaveAvx512DQ()==0) return"AVX512DQ";
    InitByU64(p->xs,seed); QbxInitSub(p);
    return 0;
}

const char*QbxInitByStr(Qbx_t*p,const char*key) {
    if (QbxHaveAvx512DQ()==0) return"AVX512DQ";
    InitByStr((unsigned*)p->xs,key); QbxInitSub(p);
    return 0;
}

#endif

［前：SplitMix64とXorshiftを組み合わせる］［ExRand目次］［次：性能評価］