generar números dobles aleatorios en C++

Question

Cómo generar números aleatorios entre dos dobles en C++, estos números deben verse como xxxxx, yyyyy.

Answer 1

Así es como

double fRand(double fMin, double fMax) 
{ 
    double f = (double)rand()/RAND_MAX; 
    return fMin + f * (fMax - fMin); 
} 

recuerde llamar a srand() con una semilla adecuada cada vez que se inicia el programa.

Answer 2

algo como esto:

#include <iostream> 
#include <time.h> 

using namespace std; 

int main() 
{ 
    const long max_rand = 1000000L; 
    double x1 = 12.33, x2 = 34.123, x; 

    srandom(time(NULL)); 

    x = x1 + (x2 - x1) * (random() % max_rand)/max_rand; 

    cout << x1 << " <= " << x << " <= " << x2 << endl; 

    return 0; 
} 

Answer 3

Esta solución requiere 11 C++ (o TR1).

#include <random> 

int main() 
{ 
    double lower_bound = 0; 
    double upper_bound = 10000; 
    std::uniform_real_distribution<double> unif(lower_bound,upper_bound); 
    std::default_random_engine re; 
    double a_random_double = unif(re); 

    return 0; 
} 

Para obtener más información, consulte "Random number generation using C++ TR1" de John D. Cook.

Véase también Stroustrup's "Random number generation".

Answer 4

Si la precisión es un problema aquí puede crear números aleatorios con una graduación más fina aleatorizando los bits significativos. Supongamos que queremos tener un doble entre 0.0 y 1000.0.

En MSVC (12/Win32) RAND_MAX es 32767 por ejemplo.

Si utiliza el esquema común rand()/RAND_MAX sus vacíos serán tan grandes como

1.0/32767.0 * (1000.0 - 0.0) = 0.0305 ... 

En caso de IEE 754 Variables dobles (53 bits significativos) y 53 bits aleatorización la posible separación más pequeña de aleatoriedad del 0 al 1000 problema será

2^-53 * (1000.0 - 0.0) = 1.110e-13 

y por lo tanto significativamente menor.

El inconveniente es que se necesitarán 4 llamadas rand() para obtener el número integral aleatorizado (suponiendo un RNG de 15 bits).

double random_range (double const range_min, double const range_max) 
{ 
    static unsigned long long const mant_mask53(9007199254740991); 
    static double const i_to_d53(1.0/9007199254740992.0); 
    unsigned long long const r((unsigned long long(rand()) | (unsigned long long(rand()) << 15) | (unsigned long long(rand()) << 30) | (unsigned long long(rand()) << 45)) & mant_mask53); 
    return range_min + i_to_d53*double(r)*(range_max-range_min); 
} 

Si se desconoce el número de bits para la mantisa o el RNG los valores respectivos necesita ser obtenida dentro de la función.

#include <limits> 
using namespace std; 
double random_range_p (double const range_min, double const range_max) 
{ 
    static unsigned long long const num_mant_bits(numeric_limits<double>::digits), ll_one(1), 
    mant_limit(ll_one << num_mant_bits); 
    static double const i_to_d(1.0/double(mant_limit)); 
    static size_t num_rand_calls, rng_bits; 
    if (num_rand_calls == 0 || rng_bits == 0) 
    { 
    size_t const rand_max(RAND_MAX), one(1); 
    while (rand_max > (one << rng_bits)) 
    { 
     ++rng_bits; 
    } 
    num_rand_calls = size_t(ceil(double(num_mant_bits)/double(rng_bits))); 
    } 
    unsigned long long r(0); 
    for (size_t i=0; i<num_rand_calls; ++i) 
    { 
    r |= (unsigned long long(rand()) << (i*rng_bits)); 
    } 
    r = r & (mant_limit-ll_one); 
    return range_min + i_to_d*double(r)*(range_max-range_min); 
} 

Nota: No sé si el número de bits para unsigned long long (64 bits) es mayor que el número de bits de mantisa dobles (53 bits para la EEI 754) en todas las plataformas o no. Probablemente sea "inteligente" incluir un cheque como if (sizeof(unsigned long long)*8 > num_mant_bits) ... si este no es el caso.

Answer 5

Este fragmento es directamente del The C++ Programming Language (4th Edition) de Stroustrup, §40.7; requiere C++ 11:

#include <functional> 
#include <random> 

class Rand_double 
{ 
public: 
    Rand_double(double low, double high) 
    :r(std::bind(std::uniform_real_distribution<>(low,high),std::default_random_engine())){} 

    double operator()(){ return r(); } 

private: 
    std::function<double()> r; 
}; 

#include <iostream>  
int main() { 
    // create the random number generator: 
    Rand_double rd{0,0.5}; 

    // print 10 random number between 0 and 0.5 
    for (int i=0;i<10;++i){ 
     std::cout << rd() << ' '; 
    } 
    return 0; 
} 

Answer 6

Esto debería ser performant, hilo-seguro y lo suficientemente flexible para muchos usos:

#include <random> 
#include <iostream> 

template<typename Numeric, typename Generator = std::mt19937> 
Numeric random(Numeric from, Numeric to) 
{ 
    thread_local static Generator gen(std::random_device{}()); 

    using dist_type = typename std::conditional 
    < 
     std::is_integral<Numeric>::value 
     , std::uniform_int_distribution<Numeric> 
     , std::uniform_real_distribution<Numeric> 
    >::type; 

    thread_local static dist_type dist; 

    return dist(gen, typename dist_type::param_type{from, to}); 
} 

int main(int, char*[]) 
{ 
    for(auto i = 0U; i < 20; ++i) 
     std::cout << random<double>(0.0, 0.3) << '\n'; 
} 

Answer 7

• Esto es para C++

#include "stdafx.h" 
#include "iostream" 
#include "ctime" 

using namespace std; 

double getRandom(double min, double max) 
{ 
    double before = rand() % (int)max + (int)min; 
    double after = (double)rand()/RAND_MAX; 
    double result = before + after; 
    if (result < min || result > max) { 
     result = getRandom(min, max); 
    } 
    return result; 
} 

int main() 
{ 
    srand (time(NULL)); 
    for (int i = 0; i < 100; i++) { 
     double number = getRandom(-1.57079632679, 1.57079632679); 
     cout << number << endl; 
    } 
    system("pause"); 
}