générer des nombres doubles aléatoires en c ++

Comment générer des nombres aléatoires entre deux doubles en c ++, ces nombres devraient ressembler à xxxxx, yyyyy.

Voici comment

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

N’oubliez pas d’appeler srand () avec une graine appropriée à chaque démarrage de votre programme.

[Edit] Cette réponse est obsolète depuis que C ++ a sa bibliothèque aléatoire native non basée sur C (voir la réponse d’Alessandro Jacopsons).

Cette solution nécessite C ++ 11 (ou TR1).

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

Pour plus de détails, voir “Génération de nombres aléatoires à l’aide de C ++ TR1” de John D. Cook.

Voir aussi “Génération de nombres aléatoires” de Stroustrup.

Si la précision est un problème, vous pouvez créer des nombres aléatoires avec une graduation plus fine en randomisant les bits significatifs. Supposons que nous voulons avoir un double entre 0.0 et 1000.0.

Sur MSVC (12 / Win32), RAND_MAX est 32767 par exemple.

Si vous utilisez le schéma commun rand()/RAND_MAX , vos écarts seront aussi importants que

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

Dans le cas des variables doubles IEE 754 (53 bits significatifs) et de la randomisation 53 bits, le plus petit écart de randomisation possible pour le problème 0 à 1000 sera

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

et donc nettement inférieur.

L’inconvénient est que 4 appels rand () seront nécessaires pour obtenir le nombre intégral aléatoire (en supposant 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 le nombre de bits de la mantisse ou du RNG est inconnu, les valeurs respectives doivent être obtenues dans la fonction.

 #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 

Note: Je ne sais pas si le nombre de bits pour les non signés long long (64 bits) est supérieur au nombre de bits de la double mantisse (53 bits pour IEE 754) sur toutes les plates-formes ou non. Ce serait probablement "intelligent" d'inclure une vérification comme if (sizeof(unsigned long long)*8 > num_mant_bits) ... si ce n'est pas le cas.

Cet extrait provient directement du langage de programmation C ++ de Stroustrup (4e édition) , §40.7; il nécessite C ++ 11:

 #include  #include  class Rand_double { public: Rand_double(double low, double high) :r(std::bind(std::uniform_real_dissortingbution<>(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; } 

Cela doit être performant, sûr pour les threads et suffisamment flexible pour de nombreuses utilisations:

 #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_dissortingbution , std::uniform_real_dissortingbution >::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'; } 

quelque chose comme ça:

 #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; } 
  • Ceci est pour 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"); }