Ho implementato una serie di funzioni buone, brevi e veloci del generatore di numeri pseudocasuali (PRNG) in JavaScript. Tutti possono essere seminati e fornire numeri di buona qualità.
Prima di tutto, assicurati di inizializzare correttamente i tuoi PRNG. La maggior parte dei generatori di seguito non ha una procedura di generazione dei seed incorporata (per semplicità), ma accetta uno o più valori a 32 bit come stato iniziale del PRNG. Semi simili (ad es. Un seme semplice di 1 e 2) possono causare correlazioni in PRNG più deboli, con conseguente output con proprietà simili (come livelli generati casualmente essere simili). Per evitare ciò, è consigliabile inizializzare i PRNG con un seme ben distribuito.
Per fortuna, le funzioni di hash sono molto buone nel generare semi per PRNG da stringhe brevi. Una buona funzione hash genererà risultati molto diversi anche quando due stringhe sono simili. Ecco un esempio basato sulla funzione di missaggio di MurmurHash3:
function xmur3(str) {
for(var i = 0, h = 1779033703 ^ str.length; i < str.length; i++)
h = Math.imul(h ^ str.charCodeAt(i), 3432918353),
h = h << 13 | h >>> 19;
return function() {
h = Math.imul(h ^ h >>> 16, 2246822507);
h = Math.imul(h ^ h >>> 13, 3266489909);
return (h ^= h >>> 16) >>> 0;
}
}
Ogni chiamata successiva alla funzione return di xmur3produce un nuovo valore hash "casuale" a 32 bit da utilizzare come seed in un PRNG. Ecco come potresti usarlo:
// Create xmur3 state:
var seed = xmur3("apples");
// Output four 32-bit hashes to provide the seed for sfc32.
var rand = sfc32(seed(), seed(), seed(), seed());
// Output one 32-bit hash to provide the seed for mulberry32.
var rand = mulberry32(seed());
// Obtain sequential random numbers like so:
rand();
rand();
In alternativa, è sufficiente scegliere alcuni dati fittizi con cui riempire il seme e far avanzare il generatore alcune volte (12-20 iterazioni) per mescolare accuratamente lo stato iniziale. Questo è spesso visto nelle implementazioni di riferimento dei PRNG, ma limita il numero di stati iniziali.
var seed = 1337 ^ 0xDEADBEEF; // 32-bit seed with optional XOR value
// Pad seed with Phi, Pi and E.
// https://en.wikipedia.org/wiki/Nothing-up-my-sleeve_number
var rand = sfc32(0x9E3779B9, 0x243F6A88, 0xB7E15162, seed);
for (var i = 0; i < 15; i++) rand();
L'output di queste funzioni PRNG produce un numero positivo a 32 bit (da 0 a 2 32 -1) che viene quindi convertito in un numero a virgola mobile compreso tra 0-1 (0 incluso, 1 esclusivo) equivalente Math.random(), se si desidera numeri casuali di un intervallo specifico, leggi questo articolo su MDN . Se si desidera solo i bit grezzi, è sufficiente rimuovere l'operazione di divisione finale.
Un'altra cosa da notare sono i limiti di JS. I numeri possono rappresentare solo numeri interi con una risoluzione fino a 53 bit. E quando si usano operazioni bit a bit, questo è ridotto a 32. Ciò rende difficile implementare algoritmi scritti in C o C ++, che usano numeri a 64 bit. Il porting del codice a 64 bit richiede shim che possono ridurre drasticamente le prestazioni. Quindi, per semplicità ed efficienza, ho preso in considerazione solo algoritmi che usano la matematica a 32 bit, poiché è direttamente compatibile con JS.
Ora, in seguito ai generatori. (Mantengo l'elenco completo con riferimenti qui )
sfc32 (contatore veloce semplice)
sfc32 fa parte della suite di test di numeri casuali di PractRand (che passa ovviamente). sfc32 ha uno stato a 128 bit ed è molto veloce in JS.
function sfc32(a, b, c, d) {
return function() {
a >>>= 0; b >>>= 0; c >>>= 0; d >>>= 0;
var t = (a + b) | 0;
a = b ^ b >>> 9;
b = c + (c << 3) | 0;
c = (c << 21 | c >>> 11);
d = d + 1 | 0;
t = t + d | 0;
c = c + t | 0;
return (t >>> 0) / 4294967296;
}
}
Mulberry32
Mulberry32 è un semplice generatore con uno stato a 32 bit, ma è estremamente veloce e di buona qualità (l'autore afferma che supera tutti i test della suite di test gjrand e ha un periodo completo di 2 32 , ma non ho verificato).
function mulberry32(a) {
return function() {
var t = a += 0x6D2B79F5;
t = Math.imul(t ^ t >>> 15, t | 1);
t ^= t + Math.imul(t ^ t >>> 7, t | 61);
return ((t ^ t >>> 14) >>> 0) / 4294967296;
}
}
Lo consiglierei se hai solo bisogno di un PRNG semplice ma decente e non hai bisogno di miliardi di numeri casuali (vedi Problema di compleanno ).
xoshiro128 **
A partire da maggio 2018, xoshiro128 ** è il nuovo membro della famiglia Xorshift , di Vigna / Blackman (che ha anche scritto xoroshiro, che viene utilizzato in Chrome). È il generatore più veloce che offre uno stato a 128 bit.
function xoshiro128ss(a, b, c, d) {
return function() {
var t = b << 9, r = a * 5; r = (r << 7 | r >>> 25) * 9;
c ^= a; d ^= b;
b ^= c; a ^= d; c ^= t;
d = d << 11 | d >>> 21;
return (r >>> 0) / 4294967296;
}
}
Gli autori sostengono che supera bene i test di casualità ( anche se con avvertimenti ). Altri ricercatori hanno sottolineato che falliscono alcuni test in TestU01 (in particolare LinearComp e BinaryRank). In pratica, non dovrebbe causare problemi quando si utilizzano float (come queste implementazioni), ma può causare problemi se si fa affidamento sui bit bassi non elaborati.
JSF (Jenkins 'Small Fast)
Questo è JSF o 'smallprng' di Bob Jenkins (2007), il ragazzo che ha realizzato ISAAC e SpookyHash . Si passa test PractRand e dovrebbe essere abbastanza veloce, anche se non così velocemente come SFC.
function jsf32(a, b, c, d) {
return function() {
a |= 0; b |= 0; c |= 0; d |= 0;
var t = a - (b << 27 | b >>> 5) | 0;
a = b ^ (c << 17 | c >>> 15);
b = c + d | 0;
c = d + t | 0;
d = a + t | 0;
return (d >>> 0) / 4294967296;
}
}
LCG (alias Lehmer / Park-Miller RNG o MCG)
LCG è estremamente veloce e semplice, ma la qualità della sua casualità è così bassa che un uso improprio può effettivamente causare bug nel tuo programma! Tuttavia, è significativamente meglio di alcune risposte che suggeriscono di usare Math.sino Math.PI! È un one-liner però, che è bello :).
var LCG=s=>()=>(2**31-1&(s=Math.imul(48271,s)))/2**31;
Questa implementazione è chiamata RNG standard minima come proposta da Park-Miller nel 1988 e 1993 e implementata in C ++ 11 come minstd_rand. Tieni presente che lo stato è 31 bit (31 bit danno 2 miliardi di stati possibili, 32 bit danno il doppio). Questo è il tipo di PRNG che altri stanno cercando di sostituire!
Funzionerà, ma non lo userei a meno che tu non abbia davvero bisogno di velocità e non ti interessi della qualità della casualità (che cos'è comunque casuale?). Ottimo per un gioco marmellata o una demo o qualcosa del genere. I LCG soffrono di correlazioni con i semi, quindi è meglio scartare il primo risultato di un LCG. E se insisti nell'utilizzare un LCG, l'aggiunta di un valore di incremento può migliorare i risultati, ma è probabilmente un esercizio di futilità quando esistono opzioni molto migliori.
Sembra che ci siano altri moltiplicatori che offrono uno stato a 32 bit (spazio di stato aumentato):
var LCG=s=>()=>(s=Math.imul(741103597,s)>>>0)/2**32;
var LCG=s=>()=>(s=Math.imul(1597334677,s)>>>0)/2**32;
Questi valori LCG provengono da: P. L'Ecuyer: una tabella di generatori congruenziali lineari di diverse dimensioni e buona struttura reticolare, 30 aprile 1997.