diff --git a/reference/random/book.xml b/reference/random/book.xml
new file mode 100644
index 000000000..2d987d38d
--- /dev/null
+++ b/reference/random/book.xml
@@ -0,0 +1,55 @@
+
+
+
+
+
+ Generadores de números aleatorios y funciones relacionadas con la aleatoriedad.
+ Random
+
+
+ &reftitle.intro;
+
+
+
+
+
+ &reference.random.constants;
+ &reference.random.examples;
+ &reference.random.reference;
+
+ &reference.random.random.randomizer;
+ &reference.random.random.intervalboundary;
+
+ &reference.random.random.engine;
+ &reference.random.random.cryptosafeengine;
+
+ &reference.random.random.engine.secure;
+ &reference.random.random.engine.mt19937;
+ &reference.random.random.engine.pcgoneseq128xslrr64;
+ &reference.random.random.engine.xoshiro256starstar;
+
+ &reference.random.random.randomerror;
+ &reference.random.random.brokenrandomengineerror;
+ &reference.random.random.randomexception;
+
+
+
diff --git a/reference/random/constants.xml b/reference/random/constants.xml
new file mode 100644
index 000000000..de1f25f8f
--- /dev/null
+++ b/reference/random/constants.xml
@@ -0,0 +1,64 @@
+
+
+
+
+ &reftitle.constants;
+ &extension.constants.core;
+
+
+
+
+ MT_RAND_MT19937
+ (int)
+
+
+
+ Indica que la implementación correcta de Mt19937 (Mersenne Twister)
+ será utilizada por el algoritmo al crear una instancia de Random\Engine\Mt19937
+ utilizando Random\Engine\Mt19937::__construct o al inicializar el Mersenne Twister global
+ con mt_srand.
+
+
+
+
+
+ MT_RAND_PHP
+ (int)
+
+
+
+ Indica que una implementación incorrecta de Mersenne Twister será utilizada por el algoritmo, al
+ crear una instancia de Random\Engine\Mt19937 utilizando
+ Random\Engine\Mt19937::__construct o al inicializar el Mersenne Twister global
+ con mt_srand.
+
+
+ La implementación incorrecta está disponible para garantizar la compatibilidad ascendente con
+ mt_srand anterior a PHP 7.1.0.
+
+ &warn.deprecated.feature-8-3-0;
+
+
+
+
+
+
diff --git a/reference/random/examples.xml b/reference/random/examples.xml
new file mode 100644
index 000000000..e191bd887
--- /dev/null
+++ b/reference/random/examples.xml
@@ -0,0 +1,44 @@
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo Random
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
diff --git a/reference/random/functions/getrandmax.xml b/reference/random/functions/getrandmax.xml
new file mode 100644
index 000000000..5f71a705d
--- /dev/null
+++ b/reference/random/functions/getrandmax.xml
@@ -0,0 +1,65 @@
+
+
+
+
+
+
+
+ getrandmax
+ Valor aleatorio máximo posible
+
+
+ &reftitle.description;
+
+ intgetrandmax
+
+
+
+ Devuelve el valor aleatorio máximo posible
+ retornado por rand.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ El valor aleatorio máximo posible retornado por rand.
+
+
+
+ &reftitle.seealso;
+
+
+ rand
+ srand
+ mt_getrandmax
+
+
+
+
+
+
diff --git a/reference/random/functions/lcg-value.xml b/reference/random/functions/lcg-value.xml
new file mode 100644
index 000000000..62303bd68
--- /dev/null
+++ b/reference/random/functions/lcg-value.xml
@@ -0,0 +1,114 @@
+
+
+
+
+
+
+
+ lcg_value
+ Generador de congruencia lineal combinada
+
+
+
+ &warn.deprecated.function-8-4-0;
+
+
+
+ &reftitle.description;
+
+ #[\Deprecated]
+ floatlcg_value
+
+
+
+ lcg_value devuelve un número pseudoaleatorio,
+ comprendido entre 0 y 1. lcg_value combina dos
+ generadores de congruencia, con períodos respectivos de
+ 2^31 - 85 y 2^31 - 249.
+ El período de esta función es el producto de estos dos
+ números primos (es decir, (2^31 - 85)*(2^31 - 249)).
+
+ &caution.cryptographically-insecure;
+
+
+ Escalar el valor de retorno a un intervalo diferente utilizando la multiplicación
+ o la adición (una transformación afín) puede provocar un sesgo
+ en el valor resultante, ya que los números de punto flotante no están distribuidos uniformemente
+ en la línea numérica.
+ Como no todos los valores pueden ser representados exactamente por un número de punto flotante, el
+ resultado de la transformación afín también puede dar valores fuera
+ del intervalo solicitado.
+
+
+ Utilice Random\Randomizer::getFloat para generar un
+ número de punto flotante aleatorio en un intervalo arbitrario. Utilice Random\Randomizer::getInt
+ para generar un entero aleatorio en un intervalo arbitrario.
+
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Un valor pseudoaleatorio, en el intervalo de 0.0 a 1.0 inclusive.
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 8.4.0
+
+ Esta función ha sido deprecada.
+
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ Random\Randomizer::getFloat
+ Random\Randomizer::getInt
+ random_int
+
+
+
+
+
diff --git a/reference/random/functions/mt-getrandmax.xml b/reference/random/functions/mt-getrandmax.xml
new file mode 100644
index 000000000..f1ede8076
--- /dev/null
+++ b/reference/random/functions/mt-getrandmax.xml
@@ -0,0 +1,69 @@
+
+
+
+
+
+
+
+ mt_getrandmax
+ El valor aleatorio más grande posible
+
+
+ &reftitle.description;
+
+ intmt_getrandmax
+
+
+
+ Devuelve el valor aleatorio más grande posible que puede
+ devolver la función mt_rand sin argumento, lo que
+ corresponde al valor máximo que puede ser utilizado para su parámetro
+ max sin que el resultado sea ampliado (y por lo tanto menos
+ aleatorio).
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Devuelve el valor aleatorio más grande posible devuelto por
+ la función mt_rand
+
+
+
+ &reftitle.seealso;
+
+
+ mt_rand
+ mt_srand
+ getrandmax
+
+
+
+
+
+
diff --git a/reference/random/functions/mt-rand.xml b/reference/random/functions/mt-rand.xml
new file mode 100644
index 000000000..5e2360ae3
--- /dev/null
+++ b/reference/random/functions/mt-rand.xml
@@ -0,0 +1,202 @@
+
+
+
+
+
+
+
+ mt_rand
+ Genera un valor aleatorio mediante el generador de números aleatorios Mersenne Twister
+
+
+ &reftitle.description;
+
+ intmt_rand
+
+
+
+ intmt_rand
+ intmin
+ intmax
+
+
+ Muchos generadores de números aleatorios
+ provenientes de viejas bibliotecas libcs tienen comportamientos
+ dudosos y son muy lentos. mt_rand es una
+ función de reemplazo para rand. Utiliza un
+ generador de números aleatorios de característica
+ conocida, el " Mersenne Twister " que
+ es 4 veces más rápido que la función estándar libc.
+
+
+ Llamada sin los argumentos opcionales min y
+ max, mt_rand devuelve un número
+ pseudoaleatorio, entre 0 y mt_getrandmax.
+ Para obtener un número entre 5 y 15 inclusive, se debe utilizar
+ mt_rand(5,15).
+
+ &caution.cryptographically-insecure;
+
+
+
+ &reftitle.parameters;
+
+
+
+ min
+
+
+ Valor más bajo que puede ser devuelto (por omisión: 0)
+
+
+
+
+ max
+
+
+ Valor más alto que puede ser devuelto (por omisión: mt_getrandmax).
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Un &integer; aleatorio comprendido entre min (o 0)
+ y max (o mt_getrandmax, inclusivo).
+
+
+
+ &reftitle.errors;
+
+
+
+ Si max es inferior a min,
+ se lanzará una excepción ValueError.
+
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 8.0.0
+
+ Se lanzará una excepción ValueError si max es inferior a min;
+ anteriormente, se emitía un E_WARNING y la función devolvía &false;.
+
+
+
+ 7.2.0
+
+ mt_rand recibió una corrección de error para un bug de polarización módulo. Esto significa que las secuencias generadas con un valor de inicialización específico pueden diferir de PHP 7.1 en máquinas de 64 bits.
+
+
+
+ 7.1.0
+
+ rand se convirtió en un alias de mt_rand.
+
+
+
+ 7.1.0
+
+ mt_rand
+ fue actualizado
+ para utilizar la versión corregida, correcta, del algoritmo Twister
+ Mersenne. Para volver al comportamiento anterior, utilice
+ mt_srand con MT_RAND_PHP
+ como segundo parámetro.
+
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+
+ Ejemplo con <function>mt_rand</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
+ &reftitle.notes;
+
+
+ El rango minmax debe estar
+ dentro del rango mt_getrandmax. es decir,
+ (max - min) <=
+ mt_getrandmax de lo contrario, mt_rand puede
+ devolver números aleatorios de menor calidad de lo que debería.
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ mt_srand
+ mt_getrandmax
+ random_int
+ random_bytes
+
+
+
+
+
+
diff --git a/reference/random/functions/mt-srand.xml b/reference/random/functions/mt-srand.xml
new file mode 100644
index 000000000..91b2fcbb9
--- /dev/null
+++ b/reference/random/functions/mt-srand.xml
@@ -0,0 +1,145 @@
+
+
+
+
+
+
+ mt_srand
+ Inicializa el generador de números aleatorios Mersenne Twister
+
+
+ &reftitle.description;
+
+ voidmt_srand
+ intnullseed
+&null;
+ intmodeMT_RAND_MT19937
+
+
+ mt_srand inicializa el generador de
+ valores aleatorios con seed o con
+ un valor aleatorio si ningún parámetro
+ seed es proporcionado.
+
+ ¬e.randomseed;
+ &caution.mt19937-tiny-seed;
+
+
+
+
+ &reftitle.parameters;
+
+
+
+ seed
+
+
+ Rellena el estado con valores generados por un generador congruencial lineal
+ que ha sido inicializado con seed interpretado como un entero sin signo
+ de 32 bits.
+
+
+ Si seed es omitido o &null;, un entero sin signo
+ de 32 bits será utilizado de manera aleatoria.
+
+
+
+
+ mode
+
+
+ Utilice una de las constantes siguientes para especificar la implementación del algoritmo a utilizar.
+
+
+ MT_RAND_MT19937:
+ La implementación correcta de Mt19937, disponible a partir de PHP 7.1.0.
+
+
+ MT_RAND_PHP
+ Utiliza una implementación incorrecta de Mersenne Twister que era el valor por omisión antes de PHP 7.1.0.
+ Este modo está disponible para asegurar la compatibilidad ascendente.
+
+
+
+ &warn.deprecated.feature-8-3-0;
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 8.3.0
+
+ seed es ahora nullable.
+
+
+
+ 7.1.0
+
+ srand ha sido cambiado para ser un alias de mt_srand.
+
+
+
+ 7.1.0
+
+ mt_rand ha sido actualizado para utilizar la versión corregida, correcta
+ del algoritmo de Mersenne Twister. Para volver al comportamiento anterior,
+ utilice mt_srand con MT_RAND_PHP como segundo parámetro.
+
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ mt_rand
+ mt_getrandmax
+ srand
+
+
+
+
+
diff --git a/reference/random/functions/rand.xml b/reference/random/functions/rand.xml
new file mode 100644
index 000000000..32cd07f4a
--- /dev/null
+++ b/reference/random/functions/rand.xml
@@ -0,0 +1,183 @@
+
+
+
+
+
+
+
+ rand
+ Genera un valor aleatorio
+
+
+ &reftitle.description;
+
+ intrand
+
+
+
+ intrand
+ intmin
+ intmax
+
+
+ Llamada sin los argumentos min y
+ max, rand devuelve un
+ número pseudoaleatorio entre 0 y getrandmax.
+ Si se desea un número aleatorio entre 5 y 15
+ (inclusive), por ejemplo, se puede utilizar rand (5, 15).
+
+ &caution.cryptographically-insecure;
+
+
+ Antes de PHP 7.1.0, getrandmax valía solo 32767 en ciertas plataformas
+ (como Windows). Si se necesita un rango superior a 32767, se recomienda especificar
+ un valor límite superior a 32767, al especificar min y
+ max, se permitirá utilizar un intervalo
+ más grande que mt_getrandmax, o bien, utilizar la función
+ mt_rand en su lugar.
+
+
+ A partir de PHP 7.1.0, rand utiliza el mismo
+ generador de números aleatorios que mt_rand. Para
+ preservar la compatibilidad ascendente, rand permite que
+ max sea más pequeño que min
+ en oposición al retorno &false; de mt_rand
+
+
+
+ &reftitle.parameters;
+
+
+
+ min
+
+
+ El valor más pequeño a devolver (por omisión, 0)
+
+
+
+
+ max
+
+
+ El valor más grande a devolver (por omisión, mt_getrandmax)
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Un valor pseudoaleatorio, comprendido entre
+ min (o 0) y
+ max (o mt_getrandmax, inclusive).
+
+
+
+ &reftitle.changelog;
+
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 7.2.0
+
+ rand
+ recibió una corrección de error
+ para un bug de polarización módulo. Esto significa que las secuencias
+ generadas en ciertos casos específicos pueden diferir de PHP 7.1 en
+ las máquinas de 64 bits.
+
+
+
+ 7.1.0
+
+ rand fue hecho un alias de mt_rand.
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+
+ Ejemplo con <function>rand</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
+ &reftitle.notes;
+
+
+ El rango minmax debe situarse
+ dentro del rango getrandmax. es decir, (max
+ - min) <= getrandmax de lo contrario,
+ rand puede devolver números aleatorios de mala
+ calidad.
+
+
+
+
+ &reftitle.seealso;
+
+
+ srand
+ getrandmax
+ mt_rand
+ random_int
+ random_bytes
+
+
+
+
+
+
diff --git a/reference/random/functions/random-bytes.xml b/reference/random/functions/random-bytes.xml
new file mode 100644
index 000000000..43e5182d9
--- /dev/null
+++ b/reference/random/functions/random-bytes.xml
@@ -0,0 +1,141 @@
+
+
+
+
+
+ random_bytes
+ Obtiene bytes aleatorios criptográficamente seguros
+
+
+
+ &reftitle.description;
+
+ stringrandom_bytes
+ intlength
+
+
+ Genera una cadena que contiene bytes seleccionados uniformemente de manera aleatoria con el valor de length.
+
+
+ Dado que los bytes devueltos se eligen completamente al azar, la cadena resultante probablemente contendrá
+ caracteres no imprimibles o secuencias UTF-8 inválidas. Puede ser necesario
+ codificarlos antes de la transmisión o visualización.
+
+
+ La aleatorización generada por esta función es adecuada para todas las aplicaciones, incluyendo
+ la generación de secretos a largo plazo, como claves de cifrado.
+
+ &csprng.sources;
+ &csprng.function.backport;
+
+
+
+ &reftitle.parameters;
+
+
+ length
+
+
+ La longitud de la &string; aleatoria que debe ser devuelta en bytes; debe ser mayor o igual a 1.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Devuelve una &string; que contiene el número solicitado de bytes criptográficamente seguros.
+
+
+
+
+ &reftitle.errors;
+
+ &csprng.errors;
+
+
+ Si el valor de length es menor que 1,
+ se lanzará una ValueError.
+
+
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 8.2.0
+
+ En caso de fallo CSPRNG, esta función lanzará
+ ahora una Random\RandomException.
+ Anteriormente se lanzaba una Exception básica.
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo con <function>random_bytes</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Randomizer::getBytes
+ random_int
+ bin2hex
+ base64_encode
+
+
+
+
+
diff --git a/reference/random/functions/random-int.xml b/reference/random/functions/random-int.xml
new file mode 100644
index 000000000..32cbc43b4
--- /dev/null
+++ b/reference/random/functions/random-int.xml
@@ -0,0 +1,148 @@
+
+
+
+
+
+
+ random_int
+ Obtiene un integer seleccionado de manera uniforme y criptográficamente segura
+
+
+
+ &reftitle.description;
+
+ intrandom_int
+ intmin
+ intmax
+
+
+ Genera un integer seleccionado uniformemente entre los valores mínimo y máximo proporcionados.
+
+
+ La aleatorización generada por esta función es adecuada para todas las aplicaciones, incluyendo
+ la generación de secretos a largo plazo, como claves de cifrado.
+
+ &csprng.sources;
+ &csprng.function.backport;
+
+
+
+ &reftitle.parameters;
+
+
+ min
+
+
+ El valor mínimo a retornar.
+
+
+
+
+ max
+
+
+ El valor máximo a retornar.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Un integer seleccionado de manera uniforme y criptográficamente segura desde
+ el intervalo cerrado [min, max].
+ Ambos valores min y max pueden ser retornados.
+
+
+
+
+ &reftitle.errors;
+
+ &csprng.errors;
+
+
+ Si max es menor que min,
+ se lanzará una ValueError.
+
+
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 8.2.0
+
+ En caso de fallo CSPRNG, esta función lanzará
+ ahora una Random\RandomException.
+ Anteriormente se lanzaba una Exception básica.
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo con <function>random_int</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Randomizer::getInt
+ random_bytes
+
+
+
+
+
+
diff --git a/reference/random/functions/srand.xml b/reference/random/functions/srand.xml
new file mode 100644
index 000000000..0e10f6dcf
--- /dev/null
+++ b/reference/random/functions/srand.xml
@@ -0,0 +1,121 @@
+
+
+
+
+
+
+ srand
+ Inicializa el generador de números aleatorios
+
+
+ &reftitle.description;
+
+ voidsrand
+ intnullseed&null;
+
+ intmodeMT_RAND_MT19937
+
+
+ srand inicializa el generador de
+ números aleatorios con seed,
+ o con un valor aleatorio si seed es
+ 0.
+
+
+ ¬e.randomseed;
+ &caution.mt19937-tiny-seed;
+
+ Desde PHP 7.1.0, srand es un alias de mt_srand.
+
+
+
+
+
+ &reftitle.parameters;
+
+
+
+ seed
+
+
+ Rellena el estado con valores generados por un generador congruencial lineal
+ que ha sido inicializado con seed interpretado como un entero sin signo
+ de 32 bits.
+
+
+ Si seed es omitido o &null;, se utilizará un entero sin signo
+ de 32 bits de manera aleatoria.
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.changelog;
+
+
+
+
+
+ &Version;
+ &Description;
+
+
+
+
+ 8.3.0
+
+ seed es ahora nullable.
+
+
+
+ 7.1.0
+
+ srand se ha convertido en un alias de mt_srand.
+
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+
+ rand
+ getrandmax
+ mt_srand
+
+
+
+
+
diff --git a/reference/random/random.brokenrandomengineerror.xml b/reference/random/random.brokenrandomengineerror.xml
new file mode 100644
index 000000000..771b5a950
--- /dev/null
+++ b/reference/random/random.brokenrandomengineerror.xml
@@ -0,0 +1,72 @@
+
+
+
+
+ La clase Random\BrokenRandomEngineError
+ Random\BrokenRandomEngineError
+
+
+
+
+
+ &reftitle.intro;
+
+ Indica que el Random\Engine utilizado está roto, por ejemplo porque está fuertemente sesgado.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ Random\BrokenRandomEngineError
+
+
+
+ extends
+ Random\RandomError
+
+
+ &InheritedProperties;
+
+
+
+
+ &InheritedMethods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/reference/random/random.cryptosafeengine.xml b/reference/random/random.cryptosafeengine.xml
new file mode 100644
index 000000000..1fc92597b
--- /dev/null
+++ b/reference/random/random.cryptosafeengine.xml
@@ -0,0 +1,64 @@
+
+
+
+
+ La interfaz Random\CryptoSafeEngine
+ Random\CryptoSafeEngine
+
+
+
+
+
+ &reftitle.intro;
+
+ Interfaz de marcado que indica que el Random\Engine devuelve datos aleatorios seguros desde el punto de vista criptográfico.
+
+
+
+
+
+ &reftitle.interfacesynopsis;
+
+
+
+
+ Random\CryptoSafeEngine
+
+
+
+ extends
+ Random\Engine
+
+
+ &InheritedMethods;
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/reference/random/random.engine.mt19937.xml b/reference/random/random.engine.mt19937.xml
new file mode 100644
index 000000000..347cf3bae
--- /dev/null
+++ b/reference/random/random.engine.mt19937.xml
@@ -0,0 +1,70 @@
+
+
+
+
+ La clase Random\Engine\Mt19937
+ Random\Engine\Mt19937
+
+
+
+
+
+ &reftitle.intro;
+
+ Implementa el algoritmo Mt19937 ("Mersenne Twister").
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ final
+ Random\Engine\Mt19937
+
+
+
+ implements
+ Random\Engine
+
+
+ &Methods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &reference.random.random.engine.entities.mt19937;
+
+
+
diff --git a/reference/random/random.engine.pcgoneseq128xslrr64.xml b/reference/random/random.engine.pcgoneseq128xslrr64.xml
new file mode 100644
index 000000000..4f530bd0c
--- /dev/null
+++ b/reference/random/random.engine.pcgoneseq128xslrr64.xml
@@ -0,0 +1,71 @@
+
+
+
+
+ La clase Random\Engine\PcgOneseq128XslRr64
+ Random\Engine\PcgOneseq128XslRr64
+
+
+
+
+
+ &reftitle.intro;
+
+ Implementa un generador congruencial permutado (PCG) con
+ 128 bits de estado, transformaciones de salida XSL y RR, y 64 bits de salida.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ final
+ Random\Engine\PcgOneseq128XslRr64
+
+
+
+ implements
+ Random\Engine
+
+
+ &Methods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &reference.random.random.engine.entities.pcgoneseq128xslrr64;
+
+
+
diff --git a/reference/random/random.engine.secure.xml b/reference/random/random.engine.secure.xml
new file mode 100644
index 000000000..d7527a9e7
--- /dev/null
+++ b/reference/random/random.engine.secure.xml
@@ -0,0 +1,76 @@
+
+
+
+
+ La clase Random\Engine\Secure
+ Random\Engine\Secure
+
+
+
+
+
+ &reftitle.intro;
+
+ Genera un valor aleatorio criptográficamente seguro utilizando el CSPRNG del sistema operativo.
+
+
+ El valor aleatorio generado por esta Random\Engine es adecuado
+ para todas las aplicaciones, incluyendo la generación de secretos a largo plazo, tales como
+ las claves de cifrado.
+
+
+ El motor Random\Engine\Secure es la opción predeterminada recomendada y segura,
+ a menos que la aplicación requiera secuencias reproducibles o un rendimiento muy elevado.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ final
+ Random\Engine\Secure
+
+
+
+ implements
+ Random\CryptoSafeEngine
+
+
+ &Methods;
+
+
+
+
+
+
+
+
+
+
+ &reference.random.random.engine.entities.secure;
+
+
+
diff --git a/reference/random/random.engine.xml b/reference/random/random.engine.xml
new file mode 100644
index 000000000..ed249c375
--- /dev/null
+++ b/reference/random/random.engine.xml
@@ -0,0 +1,75 @@
+
+
+
+
+ La interfaz Random\Engine
+ Random\Engine
+
+
+
+
+
+ &reftitle.intro;
+
+ Un Random\Engine constituye una fuente de aleatoriedad de bajo nivel al
+ devolver bytes aleatorios que son consumidos por las API de alto nivel para realizar sus operaciones.
+ La interfaz Random\Engine permite intercambiar el algoritmo
+ utilizado para generar aleatoriedad, ya que cada algoritmo realiza compromisos diferentes
+ para responder a casos de uso específicos. Algunos algoritmos son muy rápidos,
+ pero generan aleatoriedad de menor calidad, mientras que otros algoritmos son más lentos,
+ pero generan mejor aleatoriedad, hasta aleatoriedad criptográficamente segura
+ como la proporcionada por el motor Random\Engine\Secure.
+
+
+
+ PHP proporciona varios motores Random\Engine para responder a
+ diferentes casos de uso. El motor Random\Engine\Secure que está
+ respaldado por un CSPRNG es la opción por omisión recomendada, a menos que
+ la aplicación requiera secuencias reproducibles o un rendimiento muy elevado.
+
+
+
+
+
+ &reftitle.interfacesynopsis;
+
+
+
+
+ Random\Engine
+
+
+ &Methods;
+
+
+
+
+
+
+
+
+
+
+ &reference.random.random.engine.generate;
+
+
+
diff --git a/reference/random/random.engine.xoshiro256starstar.xml b/reference/random/random.engine.xoshiro256starstar.xml
new file mode 100644
index 000000000..c3eefd437
--- /dev/null
+++ b/reference/random/random.engine.xoshiro256starstar.xml
@@ -0,0 +1,70 @@
+
+
+
+
+ La clase Random\Engine\Xoshiro256StarStar
+ Random\Engine\Xoshiro256StarStar
+
+
+
+
+
+ &reftitle.intro;
+
+ Implementa el algoritmo xoshiro256**.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ final
+ Random\Engine\Xoshiro256StarStar
+
+
+
+ implements
+ Random\Engine
+
+
+ &Methods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &reference.random.random.engine.entities.xoshiro256starstar;
+
+
+
diff --git a/reference/random/random.intervalboundary.xml b/reference/random/random.intervalboundary.xml
new file mode 100644
index 000000000..54d5c04c2
--- /dev/null
+++ b/reference/random/random.intervalboundary.xml
@@ -0,0 +1,81 @@
+
+
+
+
+ La enumeración Random\IntervalBoundary
+ Random\IntervalBoundary
+
+
+
+ &reftitle.intro;
+
+ La enumeración Random\IntervalBoundary especifica
+ si un intervalo incluye los valores límite en el conjunto de valores
+ que se encuentran en el intervalo.
+
+
+
+
+ &reftitle.enumsynopsis;
+
+
+ Random\IntervalBoundary
+
+
+ ClosedOpen
+
+ Un intervalo cerrado a la derecha.
+ El límite inferior está incluido en el intervalo,
+ el límite superior no lo está.
+
+
+
+
+ ClosedClosed
+
+ Un intervalo cerrado.
+ Ambos valores límite están incluidos en el intervalo.
+
+
+
+
+ OpenClosed
+
+ Un intervalo cerrado a la izquierda.
+ El límite superior está incluido en el intervalo,
+ el límite inferior no lo está.
+
+
+
+
+ OpenOpen
+
+ Un intervalo abierto.
+ Ninguno de los valores límite está incluido en el intervalo.
+
+
+
+
+
+
+
+
diff --git a/reference/random/random.randomerror.xml b/reference/random/random.randomerror.xml
new file mode 100644
index 000000000..c124042cc
--- /dev/null
+++ b/reference/random/random.randomerror.xml
@@ -0,0 +1,72 @@
+
+
+
+
+ La clase Random\RandomError
+ Random\RandomError
+
+
+
+
+
+ &reftitle.intro;
+
+ Clase base para los Errores que se producen durante la generación o el uso de aleatoriedad.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ Random\RandomError
+
+
+
+ extends
+ Error
+
+
+ &InheritedProperties;
+
+
+
+
+ &InheritedMethods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/reference/random/random.randomexception.xml b/reference/random/random.randomexception.xml
new file mode 100644
index 000000000..de866a17a
--- /dev/null
+++ b/reference/random/random.randomexception.xml
@@ -0,0 +1,72 @@
+
+
+
+
+ La clase Random\RandomException
+ Random\RandomException
+
+
+
+
+
+ &reftitle.intro;
+
+ Clase base para las Exceptiones que se producen durante la generación o el uso de aleatoriedad.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ Random\RandomException
+
+
+
+ extends
+ Exception
+
+
+ &InheritedProperties;
+
+
+
+
+ &InheritedMethods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/reference/random/random.randomizer.xml b/reference/random/random.randomizer.xml
new file mode 100644
index 000000000..fa3e159c7
--- /dev/null
+++ b/reference/random/random.randomizer.xml
@@ -0,0 +1,89 @@
+
+
+
+
+ La clase Random\Randomizer
+ Random\Randomizer
+
+
+
+
+
+ &reftitle.intro;
+
+ Proporciona una API de alto nivel para la aleatoriedad proporcionada por Random\Engine.
+
+
+
+
+
+ &reftitle.classsynopsis;
+
+
+
+
+ final
+ Random\Randomizer
+
+
+ &Properties;
+
+ public
+ readonly
+ Random\Engine
+ engine
+
+
+ &Methods;
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &reftitle.properties;
+
+
+ engine
+
+
+ Fuente de aleatoriedad de bajo nivel para los métodos de Random\Randomizer.
+
+
+
+
+
+
+
+
+
+ &reference.random.random.entities.randomizer;
+
+
+
diff --git a/reference/random/random/engine/generate.xml b/reference/random/random/engine/generate.xml
new file mode 100644
index 000000000..22e659b1a
--- /dev/null
+++ b/reference/random/random/engine/generate.xml
@@ -0,0 +1,161 @@
+
+
+
+
+
+ Random\Engine::generate
+ Genera aleatoriedad
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Engine::generate
+
+
+
+ Retorna aleatoriedad y avanza el estado del algoritmo en un paso.
+
+
+ La aleatoriedad está representada por una cadena binaria que contiene octetos aleatorios. Esta representación
+ permite interpretar sin ambigüedad los bits aleatorios generados por el algoritmo, por ejemplo para
+ tener en cuenta los diferentes tamaños de salida utilizados por los distintos algoritmos.
+
+
+ Los algoritmos que operan nativamente sobre valores enteros deben retornar el entero con los octetos en orden
+ little-endian, por ejemplo utilizando la función pack con el código de formato
+ P. La interfaz de alto nivel proporcionada por el
+ Random\Randomizer interpretará los octetos aleatorios retornados como enteros no signados
+ little-endian si se requiere una representación numérica.
+
+
+ Se recomienda encarecidamente que cada bit de la cadena retornada sea seleccionado de manera uniforme e independiente,
+ ya que ciertas aplicaciones requieren aleatoriedad a nivel de bits para funcionar correctamente.
+ Por ejemplo, los generadores congruenciales lineales generan a menudo aleatoriedad de menor calidad para los bits
+ de menor peso del valor entero retornado y por lo tanto no serían adecuados para aplicaciones
+ que requieren aleatoriedad a nivel de bits.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Una cadena no vacía que contiene octetos aleatorios.
+
+
+
+
+ El Random\Randomizer utiliza internamente enteros no signados de 64 bits.
+ Si la cadena retornada contiene más de 64 bits (8 octetos) de aleatoriedad, los octetos excedentes
+ serán ignorados. Otras aplicaciones pueden ser capaces de procesar más de 64 bits a la vez.
+
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si la generación de aleatoriedad falla, una Random\RandomException
+ debe ser emitida. Cualquier otra Exception emitida durante la generación debería ser
+ capturada y envuelta en una Random\RandomException.
+
+
+
+
+ Si la cadena retornada está vacía, una Random\BrokenRandomEngineError
+ será emitida por el Random\Randomizer.
+
+
+
+
+ Si el algoritmo implementado está fuertemente sesgado, una Random\BrokenRandomEngineError
+ puede ser emitida por el Random\Randomizer para evitar bucles infinitos
+ si un muestreo por rechazo es necesario para retornar resultados no sesgados.
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine::generate</function>
+
+state = $seed & 0xffff;
+ }
+
+ public function generate(): string
+ {
+ $this->state = (61 * $this->state + 17) & 0xffff;
+
+ return pack('C', $this->state >> 8);
+ }
+}
+
+$r = new \Random\Randomizer(
+ new LinearCongruentialGenerator(seed: 1)
+);
+
+echo "Número afortunado: ", $r->getInt(0, 99), "\n";
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/mt19937/construct.xml b/reference/random/random/engine/mt19937/construct.xml
new file mode 100644
index 000000000..2620e1924
--- /dev/null
+++ b/reference/random/random/engine/mt19937/construct.xml
@@ -0,0 +1,117 @@
+
+
+
+
+
+ Random\Engine\Mt19937::__construct
+ Construye un nuevo motor Mt19937
+
+
+
+ &reftitle.description;
+
+ publicRandom\Engine\Mt19937::__construct
+ intnullseed&null;
+ intmodeMT_RAND_MT19937
+
+
+
+
+
+ &caution.mt19937-tiny-seed;
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ seed
+
+
+ Rellena el estado con valores generados con un generador congruencial lineal
+ que ha sido inicializado con seed interpretado como un entero
+ sin signo de 32 bits.
+
+
+
+ Si seed es omitido o &null;, se utilizará un entero sin signo aleatorio
+ de 32 bits.
+
+
+
+
+ mode
+
+
+ El uso de una de las constantes siguientes para especificar la implementación del algoritmo a utilizar.
+
+
+ MT_RAND_MT19937:
+ La implementación correcta de Mt19937.
+
+
+ MT_RAND_PHP:
+ Una implementación incorrecta para la retrocompatibilidad con mt_srand antes de
+ PHP 7.1.0.
+
+
+
+ &warn.deprecated.feature-8-3-0;
+
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Mt19937::__construct</function>
+
+
+]]>
+
+
+
+
+
+
diff --git a/reference/random/random/engine/mt19937/debuginfo.xml b/reference/random/random/engine/mt19937/debuginfo.xml
new file mode 100644
index 000000000..79615f22f
--- /dev/null
+++ b/reference/random/random/engine/mt19937/debuginfo.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Engine\Mt19937::__debugInfo
+ Devuelve el estado interno del motor
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Engine\Mt19937::__debugInfo
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Mt19937::__debugInfo</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/mt19937/generate.xml b/reference/random/random/engine/mt19937/generate.xml
new file mode 100644
index 000000000..e75da5360
--- /dev/null
+++ b/reference/random/random/engine/mt19937/generate.xml
@@ -0,0 +1,56 @@
+
+
+
+
+
+ Random\Engine\Mt19937::generate
+ Generar 32 bits de datos aleatorios
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Engine\Mt19937::generate
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Una cadena que representa un entero sin signo de 32 bits en orden little-endian.
+
+
+
+
+
diff --git a/reference/random/random/engine/mt19937/serialize.xml b/reference/random/random/engine/mt19937/serialize.xml
new file mode 100644
index 000000000..250e6798c
--- /dev/null
+++ b/reference/random/random/engine/mt19937/serialize.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Engine\Mt19937::__serialize
+ Serializa el objeto Mt19937
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Engine\Mt19937::__serialize
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Mt19937::__serialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/mt19937/unserialize.xml b/reference/random/random/engine/mt19937/unserialize.xml
new file mode 100644
index 000000000..391783615
--- /dev/null
+++ b/reference/random/random/engine/mt19937/unserialize.xml
@@ -0,0 +1,87 @@
+
+
+
+
+
+ Random\Engine\Mt19937::__unserialize
+ Deserializa el argumento data en un objeto Mt19937
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Engine\Mt19937::__unserialize
+ arraydata
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ data
+
+
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Mt19937::__unserialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/pcgoneseq128xslrr64/construct.xml b/reference/random/random/engine/pcgoneseq128xslrr64/construct.xml
new file mode 100644
index 000000000..fe59be7e7
--- /dev/null
+++ b/reference/random/random/engine/pcgoneseq128xslrr64/construct.xml
@@ -0,0 +1,157 @@
+
+
+
+
+
+ Random\Engine\PcgOneseq128XslRr64::__construct
+ Construye un nuevo motor PCG Oneseq 128 XSL RR 64
+
+
+
+ &reftitle.description;
+
+ publicRandom\Engine\PcgOneseq128XslRr64::__construct
+ stringintnullseed&null;
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ seed
+
+
+ El estado interno de 128 bits (16 bytes) compuesto por un entero sin signo de 128 bits es
+ inicializado dependiendo del tipo utilizado como seed.
+
+
+
+
+ Tipo
+ &Description;
+
+
+
+
+ null
+
+ Rellena el estado con 16 bytes aleatorios generados utilizando el CSPRNG.
+
+
+
+ int
+
+ Rellena el estado estableciendo el estado a 0, avanzando el motor un paso,
+ añadiendo el valor de seed interpretado como un entero sin signo de 64 bits,
+ y avanzando el motor otro paso.
+
+
+
+ string
+
+ Rellena el estado interpretando una cadena de 16 bytes string como un entero sin signo
+ de 128 bits en little-endian.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si la longitud de un stringseed no es de 16 bytes,
+ se lanzará una ValueError.
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\PcgOneseq128XslRr64::__construct</function>
+
+
+]]>
+
+
+
+ Derivar una semilla de un &string;
+
+generate()), "\n";
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/pcgoneseq128xslrr64/debuginfo.xml b/reference/random/random/engine/pcgoneseq128xslrr64/debuginfo.xml
new file mode 100644
index 000000000..b273a3766
--- /dev/null
+++ b/reference/random/random/engine/pcgoneseq128xslrr64/debuginfo.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Engine\PcgOneseq128XslRr64::__debugInfo
+ Devuelve el estado interno del motor
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Engine\PcgOneseq128XslRr64::__debugInfo
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\PcgOneseq128XslRr64::__debugInfo</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/pcgoneseq128xslrr64/generate.xml b/reference/random/random/engine/pcgoneseq128xslrr64/generate.xml
new file mode 100644
index 000000000..13555ce33
--- /dev/null
+++ b/reference/random/random/engine/pcgoneseq128xslrr64/generate.xml
@@ -0,0 +1,56 @@
+
+
+
+
+
+ Random\Engine\PcgOneseq128XslRr64::generate
+ Generar 64 bits de datos aleatorios
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Engine\PcgOneseq128XslRr64::generate
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Una cadena que representa un entero sin signo de 64 bits en little-endian.
+
+
+
+
+
diff --git a/reference/random/random/engine/pcgoneseq128xslrr64/jump.xml b/reference/random/random/engine/pcgoneseq128xslrr64/jump.xml
new file mode 100644
index 000000000..394f369ca
--- /dev/null
+++ b/reference/random/random/engine/pcgoneseq128xslrr64/jump.xml
@@ -0,0 +1,137 @@
+
+
+
+
+
+ Random\Engine\PcgOneseq128XslRr64::jump
+ Avanza el motor varios pasos
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Engine\PcgOneseq128XslRr64::jump
+ intadvance
+
+
+ Avanza el estado del algoritmo el número de pasos indicado por advance, como si
+ Random\Engine\PcgOneseq128XslRr64::generate fuera llamado tantas veces.
+
+
+
+
+ &reftitle.parameters;
+
+
+ advance
+
+
+ El número de pasos a avanzar; debe ser 0 o más.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si advance es inferior a 0,
+ se lanzará una ValueError.
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\PcgOneseq128XslRr64::jump</function>
+
+generate();
+}
+$b->jump(1_000);
+
+echo "A: ", bin2hex($a->generate()), "\n";
+echo "B: ", bin2hex($b->generate()), "\n";
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+ Los métodos de Randomizer pueden llamar al motor más de una vez
+
+engine);
+
+$a->getInt(1, 1572864); // Realiza dos llamadas a generate().
+$a->getInt(1, 1572864);
+
+$b->engine->jump(2);
+
+// Como la primera llamada a ->getInt() llamó a ->generate() dos veces
+// los motores no coinciden después de realizar un ->jump(2).
+echo "A: ", bin2hex($a->engine->generate()), "\n";
+echo "B: ", bin2hex($b->engine->generate()), "\n";
+
+// Ahora el motor B coincide con el motor A.
+echo "B: ", bin2hex($b->engine->generate()), "\n";
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/pcgoneseq128xslrr64/serialize.xml b/reference/random/random/engine/pcgoneseq128xslrr64/serialize.xml
new file mode 100644
index 000000000..1b58756fd
--- /dev/null
+++ b/reference/random/random/engine/pcgoneseq128xslrr64/serialize.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Engine\PcgOneseq128XslRr64::__serialize
+ Serializa el objeto PcgOneseq128XslRr64
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Engine\PcgOneseq128XslRr64::__serialize
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\PcgOneseq128XslRr64::__serialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/pcgoneseq128xslrr64/unserialize.xml b/reference/random/random/engine/pcgoneseq128xslrr64/unserialize.xml
new file mode 100644
index 000000000..db12df49c
--- /dev/null
+++ b/reference/random/random/engine/pcgoneseq128xslrr64/unserialize.xml
@@ -0,0 +1,87 @@
+
+
+
+
+
+ Random\Engine\PcgOneseq128XslRr64::__unserialize
+ Deserializa el parámetro data en un objeto PcgOneseq128XslRr64
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Engine\PcgOneseq128XslRr64::__unserialize
+ arraydata
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ data
+
+
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\PcgOneseq128XslRr64::__unserialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/secure/generate.xml b/reference/random/random/engine/secure/generate.xml
new file mode 100644
index 000000000..4241dab22
--- /dev/null
+++ b/reference/random/random/engine/secure/generate.xml
@@ -0,0 +1,62 @@
+
+
+
+
+
+ Random\Engine\Secure::generate
+ Genera datos aleatorios de manera criptográficamente segura
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Engine\Secure::generate
+
+
+
+ Devuelve datos aleatorios de manera criptográficamente segura.
+
+
+ &csprng.sources;
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Una string que contiene PHP_INT_SIZE bytes de aleatoriedad criptográficamente segura.
+
+
+
+
+ &reftitle.errors;
+
+ &csprng.errors;
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/construct.xml b/reference/random/random/engine/xoshiro256starstar/construct.xml
new file mode 100644
index 000000000..28d06cd5a
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/construct.xml
@@ -0,0 +1,162 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::__construct
+ Construye un nuevo motor xoshiro256**
+
+
+
+ &reftitle.description;
+
+ publicRandom\Engine\Xoshiro256StarStar::__construct
+ stringintnullseed&null;
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ seed
+
+
+ Los 256 bits (32 bytes) internos del estado, compuestos por cuatro enteros sin signo de 64 bits,
+ se inicializan según el tipo utilizado como seed.
+
+
+
+
+ Tipo
+ &Description;
+
+
+
+
+ null
+
+ Rellena el estado con 32 bytes aleatorios generados utilizando el CSPRNG.
+
+
+
+ int
+
+ Rellena el estado con cuatro valores consecutivos generados con el algoritmo SplitMix64
+ que ha sido inicializado con seed interpretado como un entero sin signo de 64 bits.
+
+
+
+ string
+
+ Rellena el estado interpretando una cadena de 32 bytes string como cuatro enteros sin signo de 64 bits en
+ little-endian.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si la longitud de una stringseed no es
+ de 32 bytes, se lanzará una ValueError.
+
+
+
+
+ Si una stringseed está compuesta
+ por 32 bytes NUL ("\x00"), se lanzará una ValueError.
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Xoshiro256StarStar::__construct</function>
+
+
+]]>
+
+
+
+ Derivar una semilla de una &string;
+
+generate()), "\n";
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/debuginfo.xml b/reference/random/random/engine/xoshiro256starstar/debuginfo.xml
new file mode 100644
index 000000000..19fa4b778
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/debuginfo.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::__debugInfo
+ Devuelve el estado interno del motor
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Engine\Xoshiro256StarStar::__debugInfo
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Xoshiro256StarStar::__debugInfo</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/generate.xml b/reference/random/random/engine/xoshiro256starstar/generate.xml
new file mode 100644
index 000000000..742105593
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/generate.xml
@@ -0,0 +1,56 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::generate
+ Generar 64 bits de datos aleatorios
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Engine\Xoshiro256StarStar::generate
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Una cadena que representa un entero sin signo de 64 bits en little-endian.
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/jump.xml b/reference/random/random/engine/xoshiro256starstar/jump.xml
new file mode 100644
index 000000000..a5c556bef
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/jump.xml
@@ -0,0 +1,140 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::jump
+ Avanza el motor de manera eficiente 2^128 pasos
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Engine\Xoshiro256StarStar::jump
+
+
+
+ Avanza el estado del algoritmo 2128 pasos, como si
+ Random\Engine\Xoshiro256StarStar::generate fuera llamado
+ 2128 veces.
+
+
+ El objetivo de un salto es facilitar la creación de un nuevo motor Random\Engine\Xoshiro256StarStar
+ a partir de un motor Random\Engine\Xoshiro256StarStar existente inicializado.
+ El motor inicializado actúa como un modelo, que puede ser clonado
+ y saltado varias veces para crear 2128 secuencias no superpuestas con
+ 2128 valores cada una.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Xoshiro256StarStar::jump</function>
+
+jump();
+
+ $fiber = new Fiber(static function () use ($fiberRng, $i): void {
+ $randomizer = new Randomizer($fiberRng);
+
+ while (true) {
+ Fiber::suspend();
+
+ echo "{$i}: ", $randomizer->getInt(0, 100), "\n";
+ }
+ });
+ $fiber->start();
+
+ $fibers[] = $fiber;
+}
+
+// Aunque las fibras se ejecuten en un orden aleatorio, imprimirán el mismo valor
+// cada vez, ya que cada una tiene su propia instancia única del RNG.
+$randomizer = new Randomizer();
+
+$fibers = $randomizer->shuffleArray($fibers);
+foreach ($fibers as $fiber) {
+ $fiber->resume();
+}
+
+$fibers = $randomizer->shuffleArray($fibers);
+foreach ($fibers as $fiber) {
+ $fiber->resume();
+}
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Engine\Xoshiro256StarStar::jumpLong
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/jumplong.xml b/reference/random/random/engine/xoshiro256starstar/jumplong.xml
new file mode 100644
index 000000000..1221c9101
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/jumplong.xml
@@ -0,0 +1,121 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::jumpLong
+ Avanza de manera eficiente el motor 2^192 pasos
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Engine\Xoshiro256StarStar::jumpLong
+
+
+
+ Avanza el estado del algoritmo 2192 pasos, como si
+ Random\Engine\Xoshiro256StarStar::generate fuera llamado
+ 2192 veces.
+
+
+ El objetivo de un salto largo es facilitar la creación de un nuevo Random\Engine\Xoshiro256StarStar
+ a partir de un motor Random\Engine\Xoshiro256StarStar inicializado existente.
+ El motor inicializado actúa como una plantilla, que puede ser clonada
+ y saltada repetidamente para crear 264 secuencias no superpuestas con
+ 2192 valores cada una.
+
+
+ Los saltos largos pueden combinarse con Random\Engine\Xoshiro256StarStar::jump
+ para dividir aún más cada una de las 264 secuencias generadas por un salto largo,
+ en 264 secuencias de 2128 valores cada una.
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Xoshiro256StarStar::jumpLong</function>
+
+jumpLong();
+
+$parent2 = clone $blueprintRng;
+$blueprintRng->jumpLong();
+
+// Cada uno de los motores hijos tendrá su propio trozo de 2**128 valores
+// tomados del trozo de 2**192 valores de su motor padre.
+$child1a = clone $parent1;
+$parent1->jump();
+$child1b = clone $parent1;
+$parent1->jump();
+
+$child2a = clone $parent2;
+$parent2->jump();
+$child2b = clone $parent2;
+$parent2->jump();
+
+echo "Child 1A: ", bin2hex($child1a->generate()), "\n";
+echo "Child 1B: ", bin2hex($child1b->generate()), "\n";
+echo "Child 2A: ", bin2hex($child2a->generate()), "\n";
+echo "Child 2B: ", bin2hex($child2b->generate()), "\n";
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Engine\Xoshiro256StarStar::jump
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/serialize.xml b/reference/random/random/engine/xoshiro256starstar/serialize.xml
new file mode 100644
index 000000000..88c3ef9a8
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/serialize.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::__serialize
+ Serializa el objeto Xoshiro256StarStar
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Engine\Xoshiro256StarStar::__serialize
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Xoshiro256StarStar::__serialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/engine/xoshiro256starstar/unserialize.xml b/reference/random/random/engine/xoshiro256starstar/unserialize.xml
new file mode 100644
index 000000000..b74a20d28
--- /dev/null
+++ b/reference/random/random/engine/xoshiro256starstar/unserialize.xml
@@ -0,0 +1,87 @@
+
+
+
+
+
+ Random\Engine\Xoshiro256StarStar::__unserialize
+ Deserializa el argumento data en un objeto Xoshiro256StarStar
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Engine\Xoshiro256StarStar::__unserialize
+ arraydata
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ data
+
+
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Engine\Xoshiro256StarStar::__unserialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/randomizer/construct.xml b/reference/random/random/randomizer/construct.xml
new file mode 100644
index 000000000..b36e3ac3b
--- /dev/null
+++ b/reference/random/random/randomizer/construct.xml
@@ -0,0 +1,95 @@
+
+
+
+
+
+ Random\Randomizer::__construct
+ Construye un nuevo Randomizer
+
+
+
+ &reftitle.description;
+
+ publicRandom\Randomizer::__construct
+ Random\Enginenullengine&null;
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ engine
+
+
+ El Random\Engine a utilizar para generar aleatoriedad.
+
+
+
+ Si engine se omite o es &null;, se utilizará un nuevo objeto Random\Engine\Secure.
+
+
+
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::__construct</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/randomizer/getbytes.xml b/reference/random/random/randomizer/getbytes.xml
new file mode 100644
index 000000000..abe305fc5
--- /dev/null
+++ b/reference/random/random/randomizer/getbytes.xml
@@ -0,0 +1,111 @@
+
+
+
+
+
+ Random\Randomizer::getBytes
+ Devuelve bytes aleatorios
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Randomizer::getBytes
+ intlength
+
+
+ Genera una cadena que contiene bytes aleatorios seleccionados uniformemente de la length solicitada.
+
+
+ Dado que los bytes devueltos se seleccionan de manera completamente aleatoria, la cadena resultante puede contener
+ caracteres no imprimibles o secuencias UTF-8 no válidas. Puede ser necesario codificarla antes de transmitirla o mostrarla.
+
+
+
+
+ &reftitle.parameters;
+
+
+ length
+
+
+ La longitud de la cadena aleatoria &string; que debe ser devuelta en bytes; debe ser 1 o más.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Una &string; que contiene el número solicitado de bytes aleatorios.
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si el valor de length es inferior a 1,
+ se lanzará una ValueError.
+
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::getBytes</function>
+
+getBytes(8)), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ random_bytes
+ bin2hex
+ base64_encode
+ Random\Randomizer::getBytesFromString
+
+
+
+
+
diff --git a/reference/random/random/randomizer/getbytesfromstring.xml b/reference/random/random/randomizer/getbytesfromstring.xml
new file mode 100644
index 000000000..c1db9d187
--- /dev/null
+++ b/reference/random/random/randomizer/getbytesfromstring.xml
@@ -0,0 +1,170 @@
+
+
+
+
+
+ Random\Randomizer::getBytesFromString
+ Devuelve bytes aleatorios a partir de una cadena
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Randomizer::getBytesFromString
+ stringstring
+ intlength
+
+
+ Genera una cadena que contiene bytes aleatorios seleccionados uniformemente de la
+ string de entrada con la length solicitada.
+
+
+ La probabilidad de que un byte sea seleccionado es proporcional a su parte
+ de la string de entrada. Si cada byte ocurre
+ el mismo número de veces, cada byte tiene la misma probabilidad de ser seleccionado.
+
+
+
+
+ &reftitle.parameters;
+
+
+
+ string
+
+
+ La &string; de entrada a partir de la cual se seleccionan los bytes devueltos.
+
+
+
+
+ length
+
+
+ La longitud de la cadena aleatoria &string; que debe ser devuelta en bytes; debe ser 1 o más.
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Una &string; que contiene el número solicitado de bytes aleatorios tomados de la entrada string.
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si string está vacía,
+ se lanzará una ValueError.
+
+
+
+
+ Si el valor de length es inferior a 1,
+ se lanzará una ValueError.
+
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <methodname>Random\Randomizer::getBytesFromString</methodname>
+
+getBytesFromString('abcdefghijklmnopqrstuvwxyz0123456789', 16)
+);
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+ Generar un código aleatorio para la autenticación multi-factor
+
+getBytesFromString('0123456789', 20), 5));
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+ Seleccionar a partir de una cadena con una distribución no uniforme
+
+getBytesFromString('aaaaabcdef', 20);
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Randomizer::getBytes
+
+
+
+
+
diff --git a/reference/random/random/randomizer/getfloat.xml b/reference/random/random/randomizer/getfloat.xml
new file mode 100644
index 000000000..564fd2149
--- /dev/null
+++ b/reference/random/random/randomizer/getfloat.xml
@@ -0,0 +1,376 @@
+
+
+
+
+
+ Random\Randomizer::getFloat
+ Devuelve un float seleccionado uniformemente
+
+
+
+ &reftitle.description;
+
+ publicfloatRandom\Randomizer::getFloat
+ floatmin
+ floatmax
+ Random\IntervalBoundaryboundaryRandom\IntervalBoundary::ClosedOpen
+
+
+ Devuelve un float seleccionado uniformemente y equidistribuido de un intervalo solicitado.
+
+
+ Debido a la precisión limitada, no todos los números reales pueden ser
+ representados exactamente como floats.
+
+ Si un número no puede ser representado exactamente, se redondea al número
+ exactamente representable más cercano.
+
+ Además, los floats no son igualmente densos en toda la línea de números.
+
+ Debido a que los floats utilizan un exponente binario, la distancia entre dos
+ floats vecinos se duplica en cada potencia de dos.
+
+ En otras palabras: Hay el mismo número de floats representables entre
+ 1.0 y 2.0
+ que entre
+ 2.0 y 4.0,
+ 4.0 y 8.0,
+ 8.0 y 16.0,
+ y así sucesivamente.
+
+
+ Seleccionar un número aleatorio en un intervalo arbitrario, por ejemplo
+ dividiendo dos enteros, podría resultar en una distribución sesgada por esta razón.
+
+ El redondeo necesario hará que algunos floats sean devueltos con más frecuencia que
+ otros, en particular alrededor de las potencias de dos cuando la densidad de los floats
+ cambia.
+
+
+ Random\Randomizer::getFloat implementa un algoritmo que
+ devolverá un float seleccionado uniformemente del conjunto más grande posible
+ de floats exactamente representables y equidistribuidos en el intervalo solicitado.
+
+ La distancia entre los floats seleccionables (« paso ») corresponde a la distancia
+ entre los floats con la densidad más baja, es decir, la distancia entre los
+ floats en los límites del intervalo con el valor absoluto más grande.
+
+ Esto significa que no todos los floats representables en un intervalo dado pueden
+ ser devueltos si el intervalo cruza una o más potencias de dos.
+
+ El paso comenzará en el límite del intervalo con el valor absoluto más grande
+ para garantizar que los pasos se alineen con los floats exactamente representables.
+
+
+ Los límites de intervalo cerrados siempre estarán incluidos en el conjunto de floats
+ seleccionables.
+
+ Por lo tanto, si el tamaño del intervalo no es un múltiplo exacto del paso y el límite
+ con el valor absoluto más pequeño es un límite cerrado, la distancia entre este límite
+ y su float más cercano será más pequeña que el paso.
+
+
+
+ El postprocesamiento de los floats devueltos corre el riesgo de romper la equidistribución uniforme,
+ ya que los floats intermedios en una operación matemática sufren un redondeo implícito.
+
+ El intervalo solicitado debe corresponder lo más estrechamente posible al intervalo deseado
+ y el redondeo solo debe realizarse como una operación explícita justo antes
+ de mostrar el número seleccionado a un usuario.
+
+
+
+ Explicaciones del algoritmo utilizando valores de ejemplo
+
+ Para dar un ejemplo del funcionamiento del algoritmo, consideremos una representación
+ en coma flotante que utiliza una mantisa de 3 bits.
+
+ Esto es capaz de representar 8 valores float
+ diferentes entre las potencias de dos consecutivas.
+
+ Esto significa que entre
+ 1.0 y 2.0 todos los pasos de tamaño 0.125
+ son exactamente representables y entre 2.0 y 4.0
+ todos los pasos de tamaño 0.25 son exactamente representables.
+
+ En realidad, los floats de PHP utilizan una mantisa de 52 bits y pueden representar
+ 252 valores diferentes entre cada potencia de dos.
+
+ Esto significa que
+
+ 1.0
+ 1.125
+ 1.25
+ 1.375
+ 1.5
+ 1.625
+ 1.75
+ 1.875
+ 2.0
+ 2.25
+ 2.5
+ 2.75
+ 3.0
+ 3.25
+ 3.5
+ 3.75
+ 4.0
+
+ son los floats exactamente representables entre
+ 1.0 y 4.0.
+
+
+ Ahora consideremos que $randomizer->getFloat(1.625, 2.5, IntervalBoundary::ClosedOpen)
+ es llamado, es decir, que se solicita un float aleatorio comenzando en 1.625 hasta,
+ pero sin incluir, 2.5.
+
+ El algoritmo determina primero el paso en el límite con el valor absoluto más grande
+ (2.5). El paso en este límite es 0.25.
+
+
+ Es de notar que el tamaño del intervalo solicitado es 0.875, que no es
+ un múltiplo exacto de 0.25.
+
+ Si el algoritmo comenzara a caminar en el límite inferior 1.625, encontraría
+ 2.125, que no es exactamente representable y sufriría
+ un redondeo implícito.
+
+ Por lo tanto, el algoritmo comienza a caminar en el límite superior 2.5.
+
+ Los valores seleccionables son:
+
+ 2.25
+ 2.0
+ 1.75
+ 1.625
+
+
+ 2.5 no está incluido, ya que el límite superior del intervalo solicitado
+ es un límite abierto.
+
+ 1.625 está incluido, incluso si su distancia al valor más cercano
+ 1.75 es 0.125, que es más pequeña que el paso
+ determinado previamente de 0.25.
+
+ La razón por la que es así es que el intervalo solicitado está cerrado en el límite
+ inferior (1.625) y los límites cerrados siempre están incluidos.
+
+
+ Finalmente, el algoritmo selecciona uniformemente uno de los cuatro valores seleccionables
+ al azar y lo devuelve.
+
+
+ Por qué dividir dos enteros no funciona
+
+ En el ejemplo anterior, hay ocho números float representables
+ entre cada subintervalo delimitado por una potencia de dos.
+
+ Para dar un ejemplo de por qué dividir dos enteros no funcionaría bien
+ para generar un float aleatorio, consideremos que hay 16 números float
+ uniformemente distribuidos en el intervalo abierto a la derecha de 0.0
+ hasta, pero sin incluir, 1.0. La mitad de ellos son los
+ ocho valores exactamente representables entre 0.5 y 1.0,
+ la otra mitad son los valores entre 0.0 y 1.0
+ con un paso de 0.0625.
+
+ Estos valores pueden generarse fácilmente dividiendo un entero aleatorio entre
+ 0 y 15 por 16 para obtener
+ uno de los siguientes valores:
+
+
+ 0.0
+ 0.0625
+ 0.125
+ 0.1875
+ 0.25
+ 0.3125
+ 0.375
+ 0.4375
+ 0.5
+ 0.5625
+ 0.625
+ 0.6875
+ 0.75
+ 0.8125
+ 0.875
+ 0.9375
+
+
+
+ Este float aleatorio podría escalarse al intervalo abierto a la derecha
+ de 1.625 hasta, pero sin incluir, 2.75 multiplicándolo por el tamaño
+ del intervalo (0.875) y añadiendo el mínimo 1.625.
+ Esta transformación afín daría los siguientes valores:
+
+
+ 1.625 redondeado a 1.625
+ 1.679 redondeado a 1.625
+ 1.734 redondeado a 1.75
+ 1.789 redondeado a 1.75
+ 1.843 redondeado a 1.875
+ 1.898 redondeado a 1.875
+ 1.953 redondeado a 2.0
+ 2.007 redondeado a 2.0
+ 2.062 redondeado a 2.0
+ 2.117 redondeado a 2.0
+ 2.171 redondeado a 2.25
+ 2.226 redondeado a 2.25
+ 2.281 redondeado a 2.25
+ 2.335 redondeado a 2.25
+ 2.390 redondeado a 2.5
+ 2.445 redondeado a 2.5
+
+
+ Es de notar cómo el límite superior de 2.5 sería devuelto,
+ a pesar del hecho de que sea un límite abierto y por lo tanto excluido.
+
+ También es de notar cómo 2.0 y 2.25 tienen el doble de
+ probabilidades de ser devueltos en comparación con los otros valores.
+
+
+
+
+
+
+ &reftitle.parameters;
+
+
+
+ min
+
+
+ El límite inferior del intervalo.
+
+
+
+
+ max
+
+
+ El límite superior del intervalo.
+
+
+
+
+ boundary
+
+
+ Especifica si los límites del intervalo son valores de retorno posibles.
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Un valor float seleccionado uniformemente y equidistribuido del intervalo especificado por
+ min, max y boundary.
+
+ Si boundary es Random\IntervalBoundary::ClosedClosed,
+ min y max son valores de retorno posibles.
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si el valor de min no es finito (is_finite),
+ se lanzará una ValueError.
+
+
+
+
+ Si el valor de max no es finito (is_finite),
+ se lanzará una ValueError.
+
+
+
+
+ Si el intervalo solicitado no contiene ningún valor,
+ se lanzará una ValueError.
+
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <methodname>Random\Randomizer::getFloat</methodname>
+
+getFloat(-90, 90, \Random\IntervalBoundary::ClosedClosed),
+ $randomizer->getFloat(-180, 180, \Random\IntervalBoundary::OpenClosed),
+);
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.notes;
+
+
+ Este método implementa el algoritmo de la sección γ tal como se publicó en
+
+ Dibujar números float aleatorios de un intervalo.
+ Frédéric Goual
+
+ para obtener las propiedades de comportamiento deseadas.
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Randomizer::nextFloat
+ Random\Randomizer::getInt
+
+
+
+
+
diff --git a/reference/random/random/randomizer/getint.xml b/reference/random/random/randomizer/getint.xml
new file mode 100644
index 000000000..d346582bc
--- /dev/null
+++ b/reference/random/random/randomizer/getint.xml
@@ -0,0 +1,121 @@
+
+
+
+
+
+ Random\Randomizer::getInt
+ Devuelve un integer seleccionado de manera uniforme
+
+
+
+ &reftitle.description;
+
+ publicintRandom\Randomizer::getInt
+ intmin
+ intmax
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ min
+
+
+ El valor más bajo a devolver.
+
+
+
+
+ max
+
+
+ El valor más alto a devolver.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Un valor integer seleccionado de manera uniforme en el intervalo
+ cerrado [min, max]. Ambos
+ min y max son valores
+ de retorno posibles.
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si min o max no son
+ integers, se lanzará una TypeError.
+
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::getInt</function>
+
+getInt(1, 100), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ random_int
+ Random\Randomizer::getFloat
+
+
+
+
+
diff --git a/reference/random/random/randomizer/nextfloat.xml b/reference/random/random/randomizer/nextfloat.xml
new file mode 100644
index 000000000..3e4b37bd9
--- /dev/null
+++ b/reference/random/random/randomizer/nextfloat.xml
@@ -0,0 +1,183 @@
+
+
+
+
+
+ Random\Randomizer::nextFloat
+ Devuelve un float seleccionado del intervalo abierto a la derecha [0.0, 1.0)
+
+
+
+ &reftitle.description;
+
+ publicfloatRandom\Randomizer::nextFloat
+
+
+
+ Devuelve un float seleccionado de manera uniforme y equidistribuida del intervalo abierto a la derecha
+ de 0.0 hasta, pero sin incluir, 1.0.
+
+
+
+ La probabilidad de que un float devuelto esté en un subintervalo dado abierto a la derecha
+ es proporcional al tamaño del subintervalo.
+
+ Esto significa que la probabilidad de que un float sea menor que0.5
+ es del 50 %, lo cual es igual a la probabilidad de que un float sea al menos0.5.
+
+ Del mismo modo, la probabilidad de que un float esté en el intervalo abierto a la derecha de
+ 0.2 hasta, pero sin incluir, 0.25
+ es exactamente del 5 %.
+
+
+
+ Esta propiedad permite utilizar fácilmente Random\Randomizer::nextFloat
+ para generar un bool aleatorio con una probabilidad dada verificando si el float devuelto es
+ menor que una probabilidad dada.
+
+
+
+
+ El dominio de los floats devueltos por Random\Randomizer::nextFloat
+ es idéntico al de Randomizer::getFloat(0.0, 1.0, IntervalBoundary::ClosedOpen).
+
+
+
+ La implementación interna de Random\Randomizer::nextFloat es más
+ eficiente.
+
+
+
+
+
+ Escalar el valor devuelto a un intervalo diferente utilizando la multiplicación
+ o la adición (una transformación afín) podría resultar en un sesgo
+ en el valor resultante, ya que los floats no son igualmente densos a lo largo de la línea
+ de los números. Como no todos los valores pueden ser representados exactamente por un float, el
+ resultado de la transformación afín podría también resultar en valores fuera
+ del intervalo solicitado debido a redondeos implícitos.
+
+ Una explicación detallada
+ de los problemas con la transformación afín se proporciona en la documentación
+ para Random\Randomizer::getFloat.
+
+
+ Utilizar Random\Randomizer::getFloat para generar un
+ float aleatorio en un intervalo arbitrario. Utilizar Random\Randomizer::getInt
+ para generar un integer aleatorio en un intervalo arbitrario.
+
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Un float seleccionado de manera uniforme en el intervalo abierto a la derecha
+ (IntervalBoundary::ClosedOpen) [0.0, 1.0).
+
+ 0.0 es un valor de retorno posible, 1.0 no lo es.
+
+
+
+
+ &reftitle.errors;
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <methodname>Random\Randomizer::nextFloat</methodname>
+
+nextFloat() < $chance;
+
+echo ($bool ? "You won" : "You lost"), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+ Escalado incorrecto utilizando una transformación afín
+
+nextFloat() * ($max - $min) + $min);
+
+// Correcto:
+// $randomizer->getFloat($min, $max, \Random\IntervalBoundary::ClosedOpen);
+?>
+]]>
+
+ &example.outputs;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ Random\Randomizer::getFloat
+
+
+
+
+
diff --git a/reference/random/random/randomizer/nextint.xml b/reference/random/random/randomizer/nextint.xml
new file mode 100644
index 000000000..2678fee02
--- /dev/null
+++ b/reference/random/random/randomizer/nextint.xml
@@ -0,0 +1,98 @@
+
+
+
+
+
+ Random\Randomizer::nextInt
+ Devuelve un integer positivo
+
+
+
+ &reftitle.description;
+
+ publicintRandom\Randomizer::nextInt
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+ Un integer positivo entre 0 y un valor máximo dependiendo del número de bytes
+ devueltos por Random\Engine::generate.
+ El valor máximo exacto puede ser calculado como 2$engine_bytes * 8 - 1 - 1.
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Para evitar incoherencias, PHP 32 bits lanzará Random\RandomException
+ si el tamaño de salida de Random\Engine::generate excede 32 bits,
+ ya que el integer seleccionado no puede ser devuelto sin pérdida.
+ Esto afecta a los motores nativos 64 bits Random\Engine\PcgOneseq128XslRr64 y
+ Random\Engine\Xoshiro256StarStar. Cualquier motor de usuario
+ que devuelva más de 4 bytes de aleatoriedad también se ve afectado.
+
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::nextInt</function>
+
+nextInt(), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/randomizer/pickarraykeys.xml b/reference/random/random/randomizer/pickarraykeys.xml
new file mode 100644
index 000000000..5fa9765d9
--- /dev/null
+++ b/reference/random/random/randomizer/pickarraykeys.xml
@@ -0,0 +1,164 @@
+
+
+
+
+
+ Random\Randomizer::pickArrayKeys
+ Selecciona claves de array aleatorias
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Randomizer::pickArrayKeys
+ arrayarray
+ intnum
+
+
+ Selecciona de manera uniforme num claves de array distintas del array de entrada.
+
+
+ Cada clave del array de entrada tiene la misma posibilidad de ser retornada.
+
+
+
+ La selección de las claves de array depende de la estructura interna del
+ array de entrada. Las claves de array retornadas pueden ser diferentes para
+ dos arrays de entrada iguales y dos Random\Engines con
+ un estado idéntico, en función de la manera en que los arrays de entrada hayan sido creados.
+
+
+
+
+
+ &reftitle.parameters;
+
+
+ array
+
+
+ El array cuyas claves de array son seleccionadas.
+
+
+
+
+ num
+
+
+ El número de claves de array a retornar; debe estar comprendido entre 1
+ y el número de elementos en array.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Un &array; que contiene num claves de array distintas de array.
+
+
+ El &array; retornado será una lista (array_is_list). Será un subconjunto
+ del &array; retornado por array_keys.
+
+
+
+
+ &reftitle.errors;
+
+
+
+ Si num es inferior a 1 o
+ superior al número de elementos en array, se
+ lanzará una ValueError.
+
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::pickArrayKeys</function>
+
+ '🍎', 'green' => '🥝', 'yellow' => '🍌', 'pink' => '🍑', 'purple' => '🍇' ];
+
+// Toma 2 claves de array aleatorias:
+echo "Keys: ", implode(', ', $r->pickArrayKeys($fruits, 2)), "\n";
+
+// Toma 3 otras claves:
+echo "Keys: ", implode(', ', $r->pickArrayKeys($fruits, 3)), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+ Tomar valores aleatorios
+
+ '🍎', 'green' => '🥝', 'yellow' => '🍌', 'pink' => '🍑', 'purple' => '🍇' ];
+
+$keys = $r->pickArrayKeys($fruits, 2);
+// Ver los valores para las claves seleccionadas.
+$selection = array_map(
+ static fn ($key) => $fruits[$key],
+ $keys
+);
+
+echo "Values: ", implode(', ', $selection), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+ &reftitle.seealso;
+
+ array_keys
+
+
+
+
+
diff --git a/reference/random/random/randomizer/serialize.xml b/reference/random/random/randomizer/serialize.xml
new file mode 100644
index 000000000..56b77e8c8
--- /dev/null
+++ b/reference/random/random/randomizer/serialize.xml
@@ -0,0 +1,78 @@
+
+
+
+
+
+ Random\Randomizer::__serialize
+ Serializa el objeto Randomizer
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Randomizer::__serialize
+
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+ &no.function.parameters;
+
+
+
+ &reftitle.returnvalues;
+
+
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::__serialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/randomizer/shufflearray.xml b/reference/random/random/randomizer/shufflearray.xml
new file mode 100644
index 000000000..441adacf6
--- /dev/null
+++ b/reference/random/random/randomizer/shufflearray.xml
@@ -0,0 +1,109 @@
+
+
+
+
+
+ Random\Randomizer::shuffleArray
+ Devuelve una permutación de un array
+
+
+
+ &reftitle.description;
+
+ publicarrayRandom\Randomizer::shuffleArray
+ arrayarray
+
+
+ Devuelve una permutación seleccionada uniformemente del array de entrada.
+
+
+
+ Cada permutación posible del array de entrada tiene la misma probabilidad de ser devuelta.
+
+
+
+
+ &reftitle.parameters;
+
+
+ array
+
+
+ El &array; cuyos valores se mezclan.
+
+
+ El &array; de entrada no será modificado.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Una permutación de los valores de array.
+
+
+ Las claves del array de entrada no serán preservadas;
+ el &array; devuelto será una lista (array_is_list).
+
+
+
+
+ &reftitle.errors;
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::shuffleArray</function>
+
+ '🍎', 'green' => '🥝', 'yellow' => '🍌', 'pink' => '🍑', 'purple' => '🍇' ];
+
+// Mezclar el array:
+echo "Ensalada: ", implode(', ', $r->shuffleArray($fruits)), "\n";
+
+// Mezclar nuevamente:
+echo "Otra Ensalada: ", implode(', ', $r->shuffleArray($fruits)), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/randomizer/shufflebytes.xml b/reference/random/random/randomizer/shufflebytes.xml
new file mode 100644
index 000000000..87f0f78a5
--- /dev/null
+++ b/reference/random/random/randomizer/shufflebytes.xml
@@ -0,0 +1,128 @@
+
+
+
+
+
+ Random\Randomizer::shuffleBytes
+ Devuelve una permutación por octeto de una cadena de caracteres
+
+
+
+ &reftitle.description;
+
+ publicstringRandom\Randomizer::shuffleBytes
+ stringbytes
+
+
+ Devuelve una permutación seleccionada uniformemente de los bytes de entrada.
+
+
+
+ Cada permutación posible de los bytes de entrada tiene la misma probabilidad de ser devuelta.
+
+
+
+
+ &reftitle.parameters;
+
+
+ bytes
+
+
+ La &string; cuyos octetos se mezclan.
+
+
+ La &string; de entrada no será modificada.
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ Una permutación de los octetos de bytes.
+
+
+
+
+ &reftitle.errors;
+
+ &random.engineErrors;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::shuffleBytes</function>
+
+shuffleBytes("PHP is great!"), "»\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+ Mezcla por octeto de caracteres Unicode
+
+shuffleBytes( $unicode );
+
+// La mezcla por octeto de caracteres no-ASCII los destruye,
+// lo que resulta en secuencias inválidas (indicadas por el carácter
+// de reemplazo Unicode) o incluso la aparición de caracteres
+// completamente diferentes en la salida.
+echo "Original: ", $unicode, "\n";
+echo "Shuffled: «", $shuffled, "»\n";
+echo "Shuffled Bytes: ", bin2hex($shuffled), "\n";
+?>
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/random/randomizer/unserialize.xml b/reference/random/random/randomizer/unserialize.xml
new file mode 100644
index 000000000..46ba58351
--- /dev/null
+++ b/reference/random/random/randomizer/unserialize.xml
@@ -0,0 +1,87 @@
+
+
+
+
+
+ Random\Randomizer::__unserialize
+ Deserializa el parámetro data en un objeto Randomizer
+
+
+
+ &reftitle.description;
+
+ publicvoidRandom\Randomizer::__unserialize
+ arraydata
+
+
+
+
+
+ &warn.undocumented.func;
+
+
+
+
+ &reftitle.parameters;
+
+
+ data
+
+
+
+
+
+
+
+
+
+
+ &reftitle.returnvalues;
+
+ &return.void;
+
+
+
+
+ &reftitle.examples;
+
+ Ejemplo de <function>Random\Randomizer::__unserialize</function>
+
+
+]]>
+
+ &example.outputs.similar;
+
+
+
+
+
+
+
+
diff --git a/reference/random/reference.xml b/reference/random/reference.xml
new file mode 100644
index 000000000..896510aa4
--- /dev/null
+++ b/reference/random/reference.xml
@@ -0,0 +1,29 @@
+
+
+
+
+ Funciones de números aleatorios
+
+ &reference.random.entities.functions;
+
+
+
diff --git a/reference/spl/arrayiterator/setflags.xml b/reference/spl/arrayiterator/setflags.xml
new file mode 100644
index 000000000..308375480
--- /dev/null
+++ b/reference/spl/arrayiterator/setflags.xml
@@ -0,0 +1,106 @@
+
+
+
+
+
+
+ ArrayIterator::setFlags
+ Define los flags de comportamientos
+
+
+
+ &reftitle.description;
+
+ publicvoidArrayIterator::setFlags
+ intflags
+
+
+ Define los flags que modifican el comportamiento de ArrayIterator.
+
+
+
+
+ &reftitle.parameters;
+
+
+
+ flags
+
+
+ El nuevo comportamiento de ArrayIterator.
+ Puede ser un bit-mask o constantes nombradas.
+ Se recomienda encarecidamente el uso de constantes nombradas para asegurar la compatibilidad con futuras versiones.
+
+
+ Los flags de comportamiento disponibles se enumeran a continuación.
+ El comportamiento real de estos flags se describe en las constantes predefinidas
+ predefined constants.
+