generar números dobles al azar en c ++

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

Así es cómo

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

Recuerde llamar a srand () con una semilla apropiada cada vez que comience su progtwig.

[Editar] Esta respuesta es obsoleta ya que C ++ obtuvo su biblioteca aleatoria no basada en C nativa (ver la respuesta de Alessandro Jacopson) Pero, esto todavía se aplica a C

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

 #include  int main() { double lower_bound = 0; double upper_bound = 10000; std::uniform_real_distribution unif(lower_bound,upper_bound); std::default_random_engine re; double a_random_double = unif(re); return 0; } 

Para obtener más detalles, consulte “Generación de números aleatorios con C ++ TR1” de John D. Cook.

Ver también “Generación de números aleatorios” de Stroustrup.

Si la precisión es un problema, 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 usa el esquema común de rand()/RAND_MAX , sus diferencias serán tan grandes como

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

En el caso de las variables dobles IEE 754 (53 bits significativos) y la aleatorización de 53 bits, la brecha de aleatorización más pequeña posible para el problema de 0 a 1000 será

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

y por lo tanto significativamente más bajo.

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, es necesario obtener los valores respectivos dentro de la función.

 #include  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::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 

Nota: No sé si el número de bits para unsigned long long (64 bit) es mayor que el número de bits de mantisa doble (53 bit para IEE 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.

Este fragmento es directamente del lenguaje de progtwigción C ++ de Stroustrup (4ª edición) , §40.7; requiere C ++ 11:

 #include  #include  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 r; }; #include  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; } 

Esto debería ser eficiente, seguro para subprocesos y lo suficientemente flexible para muchos usos:

 #include  #include  template Numeric random(Numeric from, Numeric to) { thread_local static Generator gen(std::random_device{}()); using dist_type = typename std::conditional < std::is_integral::value , std::uniform_int_distribution , std::uniform_real_distribution >::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(0.0, 0.3) << '\n'; } 

algo como esto:

 #include  #include  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; } 
  • 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"); }