Création d’un générateur aléatoire gaussien avec un écart moyen et standard

J’essaie de créer un tableau unidimensionnel et d’utiliser un générateur de nombres aléatoires (un générateur gaussien générant un nombre aléatoire de 70 et un écart type de 10) pour renseigner le tableau avec au moins 100 nombres compris entre 0 et 100 inclus.

Comment pourrais-je m’y prendre pour faire cela en C ++ ?

En C ++ 11, cela est relativement simple en utilisant l’en- tête aléatoire et std :: normal_dissortingbution ( exemple en direct ):

#include  #include  #include  #include  #include  int main() { std::random_device rd; std::mt19937 e2(rd()); std::normal_dissortingbution<> dist(70, 10); std::map hist; for (int n = 0; n < 100000; ++n) { ++hist[std::round(dist(e2))]; } for (auto p : hist) { std::cout << std::fixed << std::setprecision(1) << std::setw(2) << p.first << ' ' << std::string(p.second/200, '*') << '\n'; } } 

Si C ++ 11 n'est pas une option, boost fournit également une bibliothèque ( exemple réel ):

 #include  #include  #include  #include  #include  #include  #include  int main() { boost::mt19937 *rng = new boost::mt19937(); rng->seed(time(NULL)); boost::normal_dissortingbution<> distribution(70, 10); boost::variate_generator< boost::mt19937, boost::normal_distribution<> > dist(*rng, dissortingbution); std::map hist; for (int n = 0; n < 100000; ++n) { ++hist[std::round(dist())]; } for (auto p : hist) { std::cout << std::fixed << std::setprecision(1) << std::setw(2) << p.first << ' ' << std::string(p.second/200, '*') << '\n'; } } 

Si, pour une raison quelconque, aucune de ces options n'est possible, vous pouvez lancer votre propre transformation Box-Muller , le code fourni dans le lien semble raisonnable.

Utilisez la dissortingbution Box Muller (à partir d’ ici ):

 double rand_normal(double mean, double stddev) {//Box muller method static double n2 = 0.0; static int n2_cached = 0; if (!n2_cached) { double x, y, r; do { x = 2.0*rand()/RAND_MAX - 1; y = 2.0*rand()/RAND_MAX - 1; r = x*x + y*y; } while (r == 0.0 || r > 1.0); { double d = sqrt(-2.0*log(r)/r); double n1 = x*d; n2 = y*d; double result = n1*stddev + mean; n2_cached = 1; return result; } } else { n2_cached = 0; return n2*stddev + mean; } } 

vous pouvez en savoir plus sur: wolframe math world

En C ++ 11, vous utiliseriez les fonctionnalités fournies par l’en-tête ; créer un moteur aléatoire (par exemple std::default_random_engine ou std::mt19937 , initialisé avec std::random_device si nécessaire) et un object std::normal_dissortingbution initialisé avec vos parameters; vous pouvez ensuite les utiliser ensemble pour générer vos chiffres. Ici vous pouvez trouver un exemple complet.

Dans les versions précédentes de C ++, à la place, tout ce que vous avez est le C LCG “classique” ( srand / rand ), qui génère simplement une dissortingbution entière simple dans la plage [0, MAX_RAND]; avec elle, vous pouvez toujours générer des nombres aléatoires gaussiens en utilisant la transformation de Box-Muller . (Il peut être utile de noter que std::normal_dissortingbution C ++ 11 GNU GCC libstdc ++ utilise la méthode polaire Marsaglia, comme indiqué dans le présent document .).

Avec #include

 std::default_random_engine de(time(0)); //seed std::normal_dissortingbution nd(70, 10); //mean followed by stdiv int rarrary [101]; // [0, 100] for(int i = 0; i < 101; ++i){ rarray[i] = nd(de); //Generate numbers; }