generar aleatoria de 64 bits número entero

Question

necesito su ayuda y por favor, dame un consejo. De la programación de las perlas que conozco que para generar entero aleatorio de 30 bits debemos escribir así:

RAND_MAX*rand()+rand() 

Pero lo que podríamos hacer yo para generar no 30, pero entero de 64 bits aleatorios en su lugar? Creo que es un método muy ineficiente si multiplico dos enteros de 30 bits y luego multiplico nuevamente el entero de 4 bits, entonces, ¿qué tipo de método debo usar? Estoy usando ahora popcount_1 método diferente para 64 bit uno y me gustaría probarlo en enteros aleatorios (también estoy midiendo el tiempo que cada uno lleva para realizar la tarea)

Answer 1

Esto podría ser una solución, sin multiplicación:

r30 = RAND_MAX*rand()+rand() 
s30 = RAND_MAX*rand()+rand() 
t4 = rand() & 0xf 

res = (r30 << 34) + (s30 << 4) + t4 

Answer 2

Un 64 bits aleatorio es esencialmente 64 bits aleatorios interpretados como un int.

Rellene un conjunto de bytes de longitud 8 con bytes aleatorios (see here for how) e interprete estos como un int (see here for how).

Answer 3

Si boost es una opción, usted podría utilizar boost random.

Answer 4

En primer lugar, tengo mis dudas acerca de la solución de publicar un número entero 30 bits. RAND_MAX sí mismo podría ser un valor 31 bits, y RAND_MAX * rand() + rand() es probable que desbordarse, produciendo un comportamiento indefinido (y en la práctica, los valores negativos).

Si necesita un valor mayor que el mínimo garantizado de RAND_MAX o para el caso, cualquier cosa que no es significativamente más pequeño que RAND_MAX, la única solución será utilizar las llamadas sucesivas a rand(), y combinar la valores, pero debe hacerlo con cuidado, y validar los resultados. (. La mayoría de las implementaciones de rand() uso generadores congruentes lineales, que aunque adecuado para algunas tareas, no son particularmente bueno en este caso) de todos modos, algo así como:

unsigned 
rand256() 
{ 
    static unsigned const limit = RAND_MAX - RAND_MAX % 256; 
    unsigned result = rand(); 
    while (result >= limit) { 
     result = rand(); 
    } 
    return result % 256; 
} 

unsigned long long 
rand64bits() 
{ 
    unsigned long long results = 0ULL; 
    for (int count = 8; count > 0; -- count) { 
     results = 256U * results + rand256(); 
    } 
    return results; 
} 

(El código en rand256 está diseñado para eliminar el sesgo de otro modo inevitable se obtiene cuando el mapeo de los valores RAND_MAX a 256 valores)

Answer 5

Una solución genérica:.

template <unsigned long long I> struct log2 { 
    static const int result = 1 + log2<I/2>::result; 
}; 
template <> struct log2<1> { 
    static const int result = 0; 
}; 

template <typename UINT> UINT genrand() { 
    UINT result = 0; 
    int bits = std::numeric_limits<UINT>::digits; 
    int rand_bits = log2<RAND_MAX>::result; 
    while (bits > 0) { 
    int r = rand(); 
    while (r >= (1<<rand_bits)) r = rand(); // Retry if too big. 
    result <<= rand_bits; 
    result += r; 
    bits -= rand_bits; 
    } 
    return result; 
} 

Uso: unsigned long long R = genrand<unsigned long long>();.

El contador bits rastrea el número de bits necesarios todavía.

Answer 6

'devuelve un valor integral pseudo-aleatorio entre 0 y RAND_MAX (0 y RAND_MAX incluido).' - http://en.cppreference.com/w/cpp/numeric/random/rand

Debes usar RAND_MAX + 1 (es como generar un número dígito por dígito y luego convertirlo a base 10) en lugar de RAND_MAX. esta manera se puede generar números con uno, dos, tres, etc. dígitos en la base RAND_MAX + 1 (posiblemente con ceros a la izquierda) y convertirlos a la base 10 y obtener arbitrariamente grandes números.

Todo lo que obtenga más grande que su MAX_VALUE deseado puede descartarse y usted todavía obtiene 1/(MAX_VALOR + 1) probabilidad de obtener cada número.

Tenga en cuenta que este método puede tardar un tiempo, especialmente si su MAX_VALUE deseado es mucho menor que el valor máximo que se puede obtener antes de descartar los números que no se desean, como el número esperado de pasos para obtener un número en [0, MAX_VALUE] con este algoritmo es: (MAX_OBTAINABLE_VALUE + 1)/(MAX_VALUE + 1)