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

Question

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

Answer 1

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 fois que votre programme démarre.

[Edit] Cette réponse est obsolète depuis que le C++ a sa bibliothèque aléatoire native non basée sur le C (voir la réponse d'Alessandro Jacopson). Mais, ceci s'applique toujours au C

Answer 2

Cette solution nécessite C++11 (ou 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;
}

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

Voir également l'article de Stroustrup "Génération de nombres aléatoires" .

Answer 3

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

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

Si vous utilisez la méthode commune rand()/RAND_MAX schéma vos écarts seront aussi grands 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 sur 53 bits, le plus petit écart de randomisation possible pour le problème 0 à 1000 sera de

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

et donc nettement plus faible.

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

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

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

Answer 4

Cet extrait est tiré directement de l'article de Stroustrup. Le langage de programmation C++ (4e édition) , §40.7 ; il nécessite 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 5

Quelque chose comme ça :

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