> Nawiasem pisząc, mi się spodobał generator whyhash. Dostałem do niego link
> tutaj na grupie. Jest ekstremalnie prosty, a zatem i ekstremalnie szybki:
>
> https://github.com/mmarszik/MRndCPP/blob/master/rnd_
wyhash64.h
>
> U mnie przeszedł test na ponad 11.5 terabajta danych:
> [
> rng=RNG_stdin, seed=0x4175954b
> length= 11.544 terabytes (2^43.529 bytes), time= 345602 seconds no anomalies in 327
test result(s)
> real 5760m3.249s
> user 5636m4.175s
> sys 121m47.242s
> ]
>
> https://github.com/mmarszik/MRndCPP/blob/master/use_
rnd_wyhash64_0.h

Przyjrzałem się dzisiaj temu wyhash64 i działa bardzo podobnie do moich generatorów,
a także generatorów PCG (Melissy O'Neil), tyle, że ja wprowadzam jeszcze rotacje poza
xorowaniem niskich i wysokich bitów (podobnie jak w PCG XSL-RR-RR). Prędkości moich
generatorów są porównywalne z wyhash64. Tyle, że tak jak pisałem według moich
wstępnych ustaleń (nie wiem, czy wszystkie klucze są tak samo dobre) moje generatory
(128-bitowe) można parametryzować za pomocą 2^256 różnych kluczy, czyli można uzyskać
2^256 różnych generatorów (a w każdym generatorze wciąż możemy oczywiście użyć
różnych seedów).

wyhash64 wydaje się być jednym z najszybszych generatorów obecnie na rynku, które
zdają testy (nie licząc prostego lehmer64):

https://github.com/lemire/testingRNG

Jedną z szybkich, świeżych propozycji jest generator ROMU:

https://www.romu-random.org/romupaper.pdf

ale ze względu na rotacje, to chyba nie będzie szybsze niż wyhash.

do góry

Bardzo szybki powinien też być ulepszony przeze mnie PCG Melissy O'Neil o nazwie
XSL-RR-RR (128-bitowy, choć można stworzyć też wersje 64-bitowe i 32-bitowe):

https://en.wikipedia.org/wiki/Permuted_congruential_
generator

Normalnie oblewa on dosyć szybko testy PractRand (kod w Pythonie, sam mixer pewnie
można napisać lepiej w C, może jako jakieś macro):

import struct
import sys

x = 83866140117348733064738400095399246193
#seed

def PCGmixer(x):
count1 = x >> 122
x1 = (x ^ (x >> 64)) & 18446744073709551615
low64 = (x1 >> count1) | (x1 << (64 - count1)) & 18446744073709551615
x2 = (x >> 64) & 18446744073709551615
count2 = low64 & 63
high64 = (x2 >> count2) | (x2 << (64 - count2)) & 18446744073709551615
x = (high64 << 64) | low64
return x

def LCG(x):
x = (x * 47026247687942121848144207491837523525 +
83866140218348733064834828227924511723) & 340282366920938463463374607431768211455
return x

while 1 == 1:

x=LCG(x)
w=PCGmixer(x)

split = [(w >> x) & 0xFFFFFFFF for x in reversed(range(0, 128, 32))]
binary = struct.pack('IIII', split[0], split[1], split[2], split[3])
sys.stdout.buffer.write(binary)

Ale wystarczy dodać xorowanie kolejnych wyników:

import struct
import sys

x = 83866140117348733064738400095399246193

def PCGmixer(x):
count1 = x >> 122
x1 = (x ^ (x >> 64)) & 18446744073709551615
low64 = (x1 >> count1) | (x1 << (64 - count1)) & 18446744073709551615
x2 = (x >> 64) & 18446744073709551615
count2 = low64 & 63
high64 = (x2 >> count2) | (x2 << (64 - count2)) & 18446744073709551615
x = (high64 << 64) | low64
return x

def LCG(x):
x = (x * 47026247687942121848144207491837523525 +
83866140218348733064834828227924511723) & 340282366920938463463374607431768211455
return x

w=0

while 1 == 1:

w_1 = w

x=LCG(x)
w=PCGmixer(x)

w_2 = w_1 ^ w

#split = [(w_2 >> x) & 0xFFFFFFFF for x in reversed(range(0, 128, 32))]
#binary = struct.pack('IIII', split[0], split[1], split[2], split[3])
#sys.stdout.buffer.write(binary)

Żeby zdawał on testy. Oczywiście sam PCGmixer wydłuża czas pracy istotnie (względem
bazowego LCG), ale pewnie można go wykonywać szybciej.

do góry