Pcdwarf.net

pour modéliser la dispertion, on aura souvent besoin d’un generateur alléatoire gaussien qui concentre la majorité des valeurs sur la moyenne.

ci dessous une librairie de mon cru permettant d’obtennir ce resultat:

#include "pgl_random.hpp"

#include <stdlib.h>
#include <math.h>


static const int precision = 1000000000;  

double pgl_random(void)
{   return (double)(rand()%precision)/precision;
}

double pgl_random(const double max)
{   return max*pgl_random();
}

double pgl_random(const double min, const double max)
{   return min + pgl_random(max - min);
}

double pgl_random_gauss(void)
{   //cette fonction génère 2 nombres alléatoires
    //le second est stocké pour le prochain appel
        
    //les valeurs de retour sont centrées sur 0, equitablement réparties dessus dessous 
    //les valeurs sont essentiellement entre -3 et +3 

    double x1;
    double x2;
    double w;
    double y1;
    static double y2;
    static bool cache = false;

    if ( cache )
    {   cache=false;
        return y2;
    }

    do 
    {   x1 = pgl_random(-1, 1);
        x2 = pgl_random(-1, 1);
        w = x1 * x1 + x2 * x2;  //somme des carrés
    } while ( w >= 1.0 ); 

    w = sqrt( (-2.0 * log( w ) ) / w ); //attention log() est la fonction du log népérien ln. dans math.h le log classique est "log10"
    y1 = x1 * w;
    y2 = x2 * w;    //cette valeur est mise en cache pour le prochain appel
    cache = true;
    return y1;    
}



double pgl_random_gauss(const double centre, const double ecart)
{   return centre + ecart * pgl_random_gauss();
}

double pgl_random_gauss(const double ecart, const double min, const double max)
{   double centre = ( max - min ) /2 ;
    double r;
    do
    {
        r = centre + ecart * pgl_random_gauss();
    }   while ( r < min || r > max )
    return r;
}