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

Je suis en train de créer un tableau multidimensionnel et l'utilisation d'un générateur de nombre aléatoire(Gaussien générateur qui génère un nombre aléatoire avec des moyens de 70 et un écart-type de 10) pour remplir le tableau avec au moins 100 nombres entre 0 et 100 inclus.

Comment pourrais-je aller sur le faire dans C++?

source d'informationauteur coder_For_Life22

  1. 22

    Dans C++11 c'est relativement simple à l'aide de la aléatoire d'en-tête et std::normal_distribution (live exemple):

    #include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>

int main()
{
    std::random_device rd;

    std::mt19937 e2(rd());

    std::normal_distribution<> dist(70, 10);

    std::map<int, int> 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 que boost fournit également une bibliothèque(live exemple):

    #include <iostream>
#include <iomanip>
#include <string>
#include <map>
#include <random>
#include <boost/random.hpp>
#include <boost/random/normal_distribution.hpp>

int main()
{

  boost::mt19937 *rng = new boost::mt19937();
  rng->seed(time(NULL));

  boost::normal_distribution<> distribution(70, 10);
  boost::variate_generator< boost::mt19937, boost::normal_distribution<> > dist(*rng, distribution);

  std::map<int, int> 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';
  }
}

    et si, pour une raison aucune de ces options n'est possible, alors vous pouvez rouler vos propres De Box-Muller transformerle code fourni dans le lien semble raisonnable.

  2. 5

    Utiliser la Boîte de Muller de distribution (à partir de 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 lire plus à: wolframe mathématiques monde

  3. 2

    En C++11, vous utilisez les équipements fournis par l' <random> l'en-tête; créer un hasard moteur (par exemple std::default_random_engine ou std::mt19937initialisé avec std::random_device si nécessaire) et un std::normal_distribution objet initialisé avec vos paramètres, puis vous pouvez les utiliser ensemble pour générer vos numéros. Ici vous pouvez trouver un exemple complet.

    Dans les précédentes versions de C++, au lieu de cela, tout ce que vous avez est le "classique" C LCG (srand/rand), ce qui génère une plaine entier de distribution dans l'intervalle [0, MAX_RAND]; avec elle, vous pouvez toujours générer des nombres aléatoires gaussiennes à l'aide de la De Box-Muller transformer. (Il peut être utile de noter que le C++11 GNU GCC libstdc++ std::normal_distribution utilise le Marsaglia polaire méthode comme le montre ici.).

  4. 1

    Avec #include <random>

    std::default_random_engine de(time(0)); //seed
std::normal_distribution<int> 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;
}