Variables gaussiennes aléatoires

Question

Existe-t-il une classe dans la bibliothèque standard de .NET qui me donne la possibilité de créer des variables aléatoires qui suivent la distribution gaussienne ?

Answer 1

La suggestion de Jarrett d'utiliser une transformation de Box-Muller est bonne pour une solution rapide et simple. Une mise en œuvre simple :

Random rand = new Random(); //reuse this if you are generating many
double u1 = 1.0-rand.NextDouble(); //uniform(0,1] random doubles
double u2 = 1.0-rand.NextDouble();
double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) *
             Math.Sin(2.0 * Math.PI * u2); //random normal(0,1)
double randNormal =
             mean + stdDev * randStdNormal; //random normal(mean,stdDev^2)

Answer 2

Cette question semble s'être déplacée en tête de Google pour la génération gaussienne .NET, alors je me suis dit que j'allais poster une réponse.

J'ai fait quelques méthodes d'extension pour la classe .NET Random y compris une implémentation de la transformation de Box-Muller. Puisqu'il s'agit d'extensions, tant que le projet est inclus (ou que vous faites référence à la DLL compilée), vous pouvez toujours effectuer les opérations suivantes

var r = new Random();
var x = r.NextGaussian();

J'espère que personne ne s'offusque de cette publicité éhontée.

Exemple d'histogramme de résultats (une application de démonstration pour le dessiner est incluse) :

Answer 3

http://mathworld.wolfram.com/Box-MullerTransformation.html

En utilisant deux variables aléatoires, vous pouvez générer des valeurs aléatoires selon une distribution gaussienne. Ce n'est pas du tout une tâche difficile.

Answer 4

J'ai créé une demande pour une telle fonctionnalité sur Microsoft Connect. Si c'est quelque chose que vous recherchez, veuillez voter pour cette demande et augmenter sa visibilité.

https://connect.microsoft.com/VisualStudio/feedback/details/634346/guassian-normal-distribution-random-numbers

Cette fonctionnalité est incluse dans le SDK Java. Son implémentation est disponible [dans le cadre de la documentation](http://download.oracle.com/javase/1.4.2/docs/api/java/util/Random.html#nextGaussian()) et est facilement portable vers C# ou d'autres langages .NET.

Si vous recherchez la vitesse pure, alors le Algorithme de Zigorat est généralement reconnue comme l'approche la plus rapide.

Je ne suis pas un expert en la matière, mais j'en ai eu besoin lors de la mise en œuvre d'un système de gestion de l'information. filtre à particules pour mon Bibliothèque de football robotisé simulé RoboCup 3D et j'ai été surpris que cela ne soit pas inclus dans le cadre.

---

En attendant, voici un wrapper pour Random qui fournit une mise en œuvre efficace de la méthode polaire de Box Muller :

public sealed class GaussianRandom
{
    private bool _hasDeviate;
    private double _storedDeviate;
    private readonly Random _random;

    public GaussianRandom(Random random = null)
    {
        _random = random ?? new Random();
    }

    /// <summary>
    /// Obtains normally (Gaussian) distributed random numbers, using the Box-Muller
    /// transformation.  This transformation takes two uniformly distributed deviates
    /// within the unit circle, and transforms them into two independently
    /// distributed normal deviates.
    /// </summary>
    /// <param name="mu">The mean of the distribution.  Default is zero.</param>
    /// <param name="sigma">The standard deviation of the distribution.  Default is one.</param>
    /// <returns></returns>
    public double NextGaussian(double mu = 0, double sigma = 1)
    {
        if (sigma <= 0)
            throw new ArgumentOutOfRangeException("sigma", "Must be greater than zero.");

        if (_hasDeviate)
        {
            _hasDeviate = false;
            return _storedDeviate*sigma + mu;
        }

        double v1, v2, rSquared;
        do
        {
            // two random values between -1.0 and 1.0
            v1 = 2*_random.NextDouble() - 1;
            v2 = 2*_random.NextDouble() - 1;
            rSquared = v1*v1 + v2*v2;
            // ensure within the unit circle
        } while (rSquared >= 1 || rSquared == 0);

        // calculate polar tranformation for each deviate
        var polar = Math.Sqrt(-2*Math.Log(rSquared)/rSquared);
        // store first deviate
        _storedDeviate = v2*polar;
        _hasDeviate = true;
        // return second deviate
        return v1*polar*sigma + mu;
    }
}

Answer 5

Math.NET Iridium prétend également mettre en œuvre des "générateurs aléatoires non uniformes (normal, poisson, binomial, ...)".