QRandomGenerator Class

Documentación de funciones miembro

QRandomGenerator::QRandomGenerator(quint32 seedValue = 1)

Inicializa este objeto QRandomGenerator con el valor seedValue como semilla. Dos objetos construidos o resembrados con el mismo valor de semilla producirán la misma secuencia de números.

Véase también seed() y securelySeeded().

template <qsizetype N> QRandomGenerator::QRandomGenerator(const quint32 (&)[N] seedBuffer)

Inicializa este objeto QRandomGenerator con los valores encontrados en el array seedBuffer como semilla. Dos objetos construidos o resembrados con el mismo valor de semilla producirán la misma secuencia de números.

Ver también seed() y securelySeeded().

[noexcept] QRandomGenerator::QRandomGenerator(std::seed_seq &sseq)

Inicializa este objeto QRandomGenerator con la secuencia sseq como semilla. Dos objetos construidos o resembrados con el mismo valor de semilla producirán la misma secuencia numérica.

Ver también seed() y securelySeeded().

QRandomGenerator::QRandomGenerator(const quint32 *begin, const quint32 *end)

Inicializa este objeto QRandomGenerator con los valores encontrados en el rango de begin a end como semilla. Dos objetos construidos o resembrados con el mismo valor de semilla producirán la misma secuencia de números.

Este constructor es equivalente a:

    std::seed_seq sseq(begin, end);
    QRandomGenerator generator(sseq);

Véase también seed() y securelySeeded().

QRandomGenerator::QRandomGenerator(const quint32 *seedBuffer, qsizetype len)

Inicializa este objeto QRandomGenerator con los valores len encontrados en el array seedBuffer como semilla. Dos objetos construidos o resembrados con el mismo valor de semilla producirán la misma secuencia de números.

Este constructor es equivalente a:

    std::seed_seq sseq(seedBuffer, seedBuffer + len);
    QRandomGenerator generator(sseq);

Véase también seed() y securelySeeded().

QRandomGenerator::QRandomGenerator(const QRandomGenerator &other)

Crea una copia del estado del generador en el objeto other. Si other es QRandomGenerator::system() o una copia de éste, este objeto también leerá de las instalaciones de generación aleatoria del sistema operativo. En ese caso, las secuencias generadas por los dos objetos serán diferentes.

En todos los demás casos, el nuevo objeto QRandomGenerator empezará en la misma posición en la secuencia determinista en la que estaba el objeto other. Ambos objetos generarán la misma secuencia a partir de este punto.

Por esta razón, no es aconsejable crear una copia de QRandomGenerator::global(). Si se necesita un generador determinista exclusivo, considere en su lugar utilizar securelySeeded() para obtener un nuevo objeto que no comparta ninguna relación con el QRandomGenerator::global().

double QRandomGenerator::bounded(double highest)

Genera un doble aleatorio en el rango entre 0 (inclusive) y highest (exclusive). Esta función es equivalente a y se implementa como:

    return generateDouble() * highest;

Si el parámetro highest es negativo, el resultado también lo será; si es infinito o NaN, el resultado también será infinito o NaN (es decir, no aleatorio).

Véase también generateDouble() y bounded(quint64).

int QRandomGenerator::bounded(int highest)

Genera una cantidad aleatoria de 32 bits en el rango entre 0 (inclusive) y highest (exclusive). highest debe ser positivo.

Tenga en cuenta que esta función no puede utilizarse para obtener valores en el rango completo de 32 bits de int. En su lugar, utilice generate() y haga un cast a int.

Véase también generate(), generate64(), y generateDouble().

qint64 QRandomGenerator::bounded(qint64 highest)

Genera una cantidad aleatoria de 64 bits en el rango entre 0 (inclusive) y highest (exclusive). highest debe ser positivo.

Tenga en cuenta que esta función no se puede utilizar para obtener valores en el rango completo de 64 bits de qint64. En su lugar, utilice generate64() y cast to qint64 o, en su lugar, utilice la versión sin signo de esta función.

Véase también generate(), generate64(), y generateDouble().

quint32 QRandomGenerator::bounded(quint32 highest)

Genera una cantidad aleatoria de 32 bits en el rango comprendido entre 0 (inclusive) y highest (exclusive). También puede obtenerse el mismo resultado utilizando std::uniform_int_distribution con los parámetros 0 y highest - 1. Esta clase también puede utilizarse para obtener cantidades superiores a 32 bits; para 64 bits, también puede utilizarse la sobrecarga bounded() de 64 bits.

Por ejemplo, para obtener un valor entre 0 y 255 (ambos inclusive), se escribiría:

    quint32 v = QRandomGenerator::global()->bounded(256);

Naturalmente, también se podría obtener lo mismo enmascarando el resultado de generate() a sólo los 8 bits inferiores. Cualquiera de las dos soluciones es igual de eficiente.

Tenga en cuenta que esta función no se puede utilizar para obtener valores en el rango completo de 32 bits de quint32. En su lugar, utilice generate().

Véase también generate(), generate64(), y generateDouble().

quint64 QRandomGenerator::bounded(quint64 highest)

Genera una cantidad aleatoria de 64 bits en el rango comprendido entre 0 (inclusive) y highest (exclusive). También puede obtenerse el mismo resultado utilizando std::uniform_int_distribution<quint64> con los parámetros 0 y highest - 1.

Tenga en cuenta que esta función no puede utilizarse para obtener valores en el rango completo de 64 bits de quint64. En su lugar, utilice generate64().

Véase también generate(), generate64(), y generateDouble().

int QRandomGenerator::bounded(int lowest, int highest)

Genera una cantidad aleatoria de 32 bits en el rango comprendido entre lowest (inclusive) y highest (exclusive), ambos pueden ser negativos, pero highest debe ser mayor que lowest.

Tenga en cuenta que esta función no puede utilizarse para obtener valores en el rango completo de 32 bits de int. En su lugar, utilice generate() y conviértalo a int.

Véase también generate(), generate64(), y generateDouble().

Esta función existe para ayudar con la resolución de sobrecargas cuando los tipos de los parámetros no coinciden exactamente. Promoverán el tipo menor al tipo del mayor y llamarán a la sobrecarga correcta.

qint64 QRandomGenerator::bounded(qint64 lowest, qint64 highest)

Genera una cantidad aleatoria de 64 bits en el rango entre lowest (inclusive) y highest (exclusive), ambos pueden ser negativos, pero highest debe ser mayor que lowest.

Tenga en cuenta que esta función no puede utilizarse para obtener valores en el rango completo de 64 bits de qint64. En su lugar, utilice generate64() y conviértalo a qint64.

Véase también generate(), generate64(), y generateDouble().

quint32 QRandomGenerator::bounded(quint32 lowest, quint32 highest)

Genera una cantidad aleatoria de 32 bits en el rango comprendido entre lowest (inclusive) y highest (exclusive). El parámetro highest debe ser mayor que lowest.

También puede obtenerse el mismo resultado utilizando std::uniform_int_distribution con los parámetros lowest y \a highest - 1. Esta clase también puede utilizarse para obtener cantidades superiores a 32 bits.

Por ejemplo, para obtener un valor comprendido entre 1000 (incl.) y 2000 (excl.), se escribiría:

    quint32 v = QRandomGenerator::global()->bounded(1000, 2000);

Tenga en cuenta que esta función no puede utilizarse para obtener valores en el rango completo de 32 bits de quint32. En su lugar, utilice generate().

Véase también generate(), generate64(), y generateDouble().

quint64 QRandomGenerator::bounded(quint64 lowest, quint64 highest)

Genera una cantidad aleatoria de 64 bits en el rango comprendido entre lowest (inclusive) y highest (exclusive). El parámetro highest debe ser mayor que lowest.

También puede obtenerse el mismo resultado utilizando std::uniform_int_distribution<quint64> con los parámetros lowest y \a highest - 1.

Tenga en cuenta que esta función no puede utilizarse para obtener valores en el rango completo de 64 bits de quint64. En su lugar, utilice generate64().

Véase también generate(), generate64(), y generateDouble().

void QRandomGenerator::discard(unsigned long long z)

Descarta las siguientes entradas z de la secuencia. Este método es equivalente a llamar generate() z veces y descartar el resultado, como en:

    while (z--)
        generator.generate();

template < typename UInt, size_t N, QRandomGenerator::IfValidUInt<UInt> = true > void QRandomGenerator::fillRange(UInt (&)[N] buffer)

Genera N cantidades de 32 o 64 bits (dependiendo del tipo UInt) y las almacena en la matriz buffer. Esta es la forma más eficiente de obtener más de una cantidad a la vez, ya que reduce el número de llamadas a la fuente del Generador de Números Aleatorios.

Por ejemplo, para llenar generar dos cantidades de 32 bits, se puede escribir:

    quint32 array[2];
    QRandomGenerator::global()->fillRange(array);

También habría sido posible hacer una llamada a generate64() y luego dividir las dos mitades del valor de 64 bits.

Véase también generate().

template <typename UInt, QRandomGenerator::IfValidUInt<UInt> = true> void QRandomGenerator::fillRange(UInt *buffer, qsizetype count)

Genera count cantidades de 32 o 64 bits (dependiendo del tipo UInt) y las almacena en el buffer apuntado por buffer. Esta es la forma más eficiente de obtener más de una cantidad a la vez, ya que reduce el número de llamadas a la fuente del Generador de Números Aleatorios.

Por ejemplo, para llenar una lista de 16 entradas con valores aleatorios, se puede escribir:

    QList<quint32> list;
    list.resize(16);
    QRandomGenerator::global()->fillRange(list.data(), list.size());

Véase también generate().

quint64 QRandomGenerator::generate64()

Genera una cantidad aleatoria de 64 bits y la devuelve.

Véase también operator()() y generate().

quint32 QRandomGenerator::generate()

Genera una cantidad aleatoria de 32 bits y la devuelve.

Véase también operator()() y generate64().

template <typename ForwardIterator> void QRandomGenerator::generate(ForwardIterator begin, ForwardIterator end)

Genera cantidades de 32 bits y las almacena en el rango comprendido entre begin y end. Esta función es equivalente a (y se implementa como):

    std::generate(begin, end, [this]() { return generate(); });

Esta función cumple los requisitos de la función std::seed_seq::generateque requiere valores enteros de 32 bits sin signo.

Tenga en cuenta que si el rango [begin, end) se refiere a un área que puede almacenar más de 32 bits por elemento, los elementos se inicializarán con sólo 32 bits de datos. Los demás bits serán cero. Para llenar el rango con cantidades de 64 bits, se puede escribir:

    std::generate(begin, end, []() { return QRandomGenerator::global()->generate64(); });

Si el rango se refiere a memoria contigua (como un array o los datos de un QList), también se puede utilizar la función fillRange().

Véase también fillRange().

double QRandomGenerator::generateDouble()

Genera un qreal aleatorio en el rango canónico [0, 1) (es decir, incluyendo cero y excluyendo 1).

Esta función es equivalente a:

    QRandomGenerator64 rd;
    return std::generate_canonical<qreal, std::numeric_limits<qreal>::digits>(rd);

También se puede obtener lo mismo utilizando std::uniform_real_distribution con los parámetros 0 y 1.

Véase también generate(), generate64(), y bounded().

[static] QRandomGenerator *QRandomGenerator::global()

Devuelve un puntero a un QRandomGenerator compartido que fue sembrado usando securelySeeded(). Esta función debería usarse para crear datos aleatorios sin la costosa creación de un QRandomGenerator sembrado de forma segura para un uso específico o almacenar el objeto QRandomGenerator bastante grande.

Por ejemplo, lo siguiente crea un color RGB aleatorio:

    return QColor::fromRgb(QRandomGenerator::global()->generate());

Los accesos a este objeto son seguros para los hilos y, por tanto, puede utilizarse en cualquier hilo sin bloqueos. El objeto también puede copiarse y la secuencia producida por la copia será la misma que producirá el objeto compartido. Tenga en cuenta, sin embargo, que si hay otros hilos accediendo al objeto global, esos hilos pueden obtener muestras a intervalos impredecibles.

Nota: Esta función es segura para hilos.

Véase también securelySeeded() y system().

[static constexpr] QRandomGenerator::result_type QRandomGenerator::max()

Devuelve el valor máximo que puede generar QRandomGenerator. Es decir, std::numeric_limits<result_type>::max().

Véase también min().

[static constexpr] QRandomGenerator::result_type QRandomGenerator::min()

Devuelve el valor mínimo que puede generar QRandomGenerator. Es decir, 0.

Véase también max().

[static] QRandomGenerator QRandomGenerator::securelySeeded()

Devuelve un nuevo objeto QRandomGenerator que fue sembrado de forma segura con QRandomGenerator::system(). Esta función obtendrá el tamaño de semilla ideal para el algoritmo que utiliza QRandomGenerator y, por lo tanto, es la forma recomendada para crear un nuevo objeto QRandomGenerator que se conservará durante algún tiempo.

Dada la cantidad de datos necesarios para sembrar de forma segura el motor determinista, esta función es algo cara y no debería utilizarse para usos a corto plazo de QRandomGenerator (utilizarla para generar menos de 2600 bytes de datos aleatorios es efectivamente un desperdicio de recursos). Si el uso no requiere tantos datos, considere usar QRandomGenerator::global() y no almacenar un objeto QRandomGenerator en su lugar.

Véase también global() y system().

void QRandomGenerator::seed(quint32 seed = 1)

Vuelve a sembrar este objeto utilizando el valor seed como semilla.

[noexcept] void QRandomGenerator::seed(std::seed_seq &seed)

Vuelve a sembrar este objeto utilizando la secuencia de semillas seed como semilla.

[static] QRandomGenerator *QRandomGenerator::system()

Devuelve un puntero a un QRandomGenerator compartido que siempre utiliza las facilidades proporcionadas por el sistema operativo para generar números aleatorios. Las facilidades del sistema se consideran criptográficamente seguras al menos en los siguientes sistemas operativos: Apple OSes (Darwin), BSDs, Linux, Windows. También puede ser el caso en otros sistemas operativos.

También es posible que estén respaldados por un verdadero generador de números aleatorios por hardware. Por esa razón, el QRandomGenerator devuelto por esta función no debe utilizarse para la generación de datos masivos. En su lugar, utilícelo para sembrar QRandomGenerator o un motor aleatorio de la cabecera <random>.

El objeto devuelto por esta función es seguro para hilos y puede utilizarse en cualquier hilo sin bloqueos. También puede copiarse y el QRandomGenerator resultante también accederá a las facilidades del sistema operativo, pero no generarán la misma secuencia.

Nota: Esta función es thread-safe.

Véase también securelySeeded() y global().

QRandomGenerator::result_type QRandomGenerator::operator()()

Genera una cantidad aleatoria de 32 bits y la devuelve.

Véase también generate() y generate64().