He implementado varias funciones buenas, cortas y rápidas de generador de números pseudoaleatorios (PRNG) en JavaScript simple. Todos ellos pueden sembrarse y proporcionar números de buena calidad.
En primer lugar, tenga cuidado de inicializar sus PRNG correctamente. La mayoría de los generadores a continuación no tienen un procedimiento de generación de semillas incorporado (por simplicidad), pero aceptan uno o más valores de 32 bits como el estado inicial del PRNG. Semillas similares (por ejemplo, una semilla simple de 1 y 2) pueden causar correlaciones en PRNG más débiles, lo que da como resultado que la salida tenga propiedades similares (como que los niveles generados aleatoriamente sean similares). Para evitar esto, es una buena práctica inicializar los PRNG con una semilla bien distribuida.
Afortunadamente, las funciones hash son muy buenas para generar semillas para PRNG a partir de cadenas cortas. Una buena función hash generará resultados muy diferentes incluso cuando dos cadenas sean similares. Aquí hay un ejemplo basado en la función de mezcla de 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;
}
}
Cada llamada posterior a la función de retorno de xmur3produce un nuevo valor hash "aleatorio" de 32 bits que se utilizará como semilla en un PRNG. Así es como puede 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();
Alternativamente, simplemente elija algunos datos ficticios para rellenar la semilla y avance el generador varias veces (12-20 iteraciones) para mezclar bien el estado inicial. Esto se ve a menudo en implementaciones de referencia de PRNG, pero limita el número de estados iniciales.
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();
La salida de estas funciones PRNG produce un número positivo de 32 bits (0 a 2 32 -1) que luego se convierte en un número de coma flotante entre 0-1 (0 inclusive, 1 exclusivo) equivalente a Math.random(), si desea números aleatorios de un rango específico, lea este artículo en MDN . Si solo desea los bits sin procesar, simplemente elimine la operación de división final.
Otra cosa a tener en cuenta son las limitaciones de JS. Los números solo pueden representar enteros enteros de hasta 53 bits de resolución. Y cuando se utilizan operaciones bit a bit, esto se reduce a 32. Esto dificulta la implementación de algoritmos escritos en C o C ++, que usan números de 64 bits. Portar código de 64 bits requiere cuñas que pueden reducir drásticamente el rendimiento. Entonces, por simplicidad y eficiencia, solo he considerado algoritmos que usan matemáticas de 32 bits, ya que es directamente compatible con JS.
Ahora, adelante a los generadores. (Mantengo la lista completa con referencias aquí )
sfc32 (Contador rápido simple)
sfc32 es parte del conjunto de pruebas de números aleatorios PractRand (que, por supuesto, pasa). sfc32 tiene un estado de 128 bits y es muy rápido en 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 es un generador simple con un estado de 32 bits, pero es extremadamente rápido y de buena calidad (el autor declara que pasa todas las pruebas de gjrand testing suite y tiene un período completo de 2 32 , pero no lo he verificado).
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 recomendaría si solo necesita un PRNG simple pero decente y no necesita miles de millones de números aleatorios (consulte Problema de cumpleaños ).
xoshiro128 **
A partir de mayo de 2018, xoshiro128 ** es el nuevo miembro de la familia Xorshift , de Vigna / Blackman (quien también escribió xoroshiro, que se usa en Chrome). Es el generador más rápido que ofrece un estado de 128 bits.
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;
}
}
Los autores afirman que pasa bien las pruebas de aleatoriedad ( aunque con advertencias ). Otros investigadores han señalado que falla algunas pruebas en TestU01 (particularmente LinearComp y BinaryRank). En la práctica, no debería causar problemas cuando se utilizan flotadores (como estas implementaciones), pero puede causar problemas si se confía en los bits bajos sin procesar.
JSF (pequeño ayuno de Jenkins)
Este es JSF o 'smallprng' de Bob Jenkins (2007), el tipo que creó ISAAC y SpookyHash . Se pasa las pruebas PractRand y debe ser bastante rápido, aunque no tan rápido como 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 (también conocido como Lehmer / Park-Miller RNG o MCG)
LCG es extremadamente rápido y simple, pero la calidad de su aleatoriedad es tan baja que el uso incorrecto puede causar errores en su programa. Sin embargo, ¡es significativamente mejor que algunas respuestas que sugieren usar Math.sino Math.PI! Sin embargo, es una frase, lo cual es bueno :).
var LCG=s=>()=>(2**31-1&(s=Math.imul(48271,s)))/2**31;
Esta implementación se denomina RNG estándar mínimo según lo propuesto por Park-Miller en 1988 y 1993 y se implementa en C ++ 11 como minstd_rand. Tenga en cuenta que el estado es de 31 bits (31 bits dan 2 mil millones de estados posibles, 32 bits dan el doble de eso). ¡Este es el tipo de PRNG que otros están tratando de reemplazar!
Funcionará, pero no lo usaría a menos que realmente necesite velocidad y no le importe la calidad de la aleatoriedad (¿qué es al azar de todos modos?). Genial para un juego jam o una demo o algo así. Los LCG sufren correlaciones de semillas, por lo que es mejor descartar el primer resultado de un LCG. Y si insiste en usar un LCG, agregar un valor de incremento puede mejorar los resultados, pero probablemente sea un ejercicio inútil cuando existen opciones mucho mejores.
Parece que hay otros multiplicadores que ofrecen un estado de 32 bits (mayor espacio de estado):
var LCG=s=>()=>(s=Math.imul(741103597,s)>>>0)/2**32;
var LCG=s=>()=>(s=Math.imul(1597334677,s)>>>0)/2**32;
Estos valores LCG son de: P. L'Ecuyer: una tabla de generadores congruentes lineales de diferentes tamaños y buena estructura reticular, 30 de abril de 1997.