ตัวแปร Gaussian แบบสุ่ม

มีคลาสในไลบรารีมาตรฐานของ. NET ที่ให้ฟังก์ชันการสร้างตัวแปรสุ่มตามการแจกแจงแบบเกาส์หรือไม่

คำแนะนำของ Jarrett ในการใช้การแปลงร่าง Box-Muller นั้นดีสำหรับการแก้ปัญหาที่รวดเร็วและสกปรก การใช้งานง่ายๆ:

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)

คำถามนี้ดูเหมือนจะย้ายไปอยู่ด้านบนของ Google สำหรับรุ่น. NET Gaussian ดังนั้นฉันคิดว่าฉันจะโพสต์คำตอบ

ฉันได้สร้างวิธีการขยายบางอย่างสำหรับคลาส. NET Randomรวมถึงการใช้งานการแปลง Box-Muller เนื่องจากเป็นส่วนขยายตราบใดที่รวมโปรเจ็กต์ไว้ (หรือคุณอ้างอิง DLL ที่คอมไพล์แล้ว) คุณก็ยังสามารถทำได้

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

หวังว่าไม่มีใครสนใจปลั๊กไร้ยางอาย

ตัวอย่างฮิสโตแกรมของผลลัพธ์ (รวมแอปสาธิตสำหรับการวาดภาพ):

Math.NETมีฟังก์ชันนี้ วิธีการมีดังนี้

double mean = 100;
double stdDev = 10;

MathNet.Numerics.Distributions.Normal normalDist = new Normal(mean, stdDev);
double randomGaussianValue=   normalDist.Sample();

คุณสามารถค้นหาเอกสารได้ที่นี่: http://numerics.mathdotnet.com/api/MathNet.Numerics.Distributions/Normal.htm

ฉันสร้างคำขอสำหรับคุณลักษณะดังกล่าวบน Microsoft Connect หากนี่คือสิ่งที่คุณกำลังมองหาโปรดลงคะแนนให้และเพิ่มการแสดงผล

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

คุณลักษณะนี้รวมอยู่ใน Java SDK การใช้งานมีให้เป็นส่วนหนึ่งของเอกสารและสามารถย้ายไปยัง C # หรือภาษา. NET อื่น ๆ ได้อย่างง่ายดาย

หากคุณกำลังมองหาความเร็วที่แท้จริงอัลกอริทึม Zigoratมักได้รับการยอมรับว่าเป็นแนวทางที่เร็วที่สุด

ฉันไม่ใช่ผู้เชี่ยวชาญในหัวข้อนี้ - ฉันพบความต้องการนี้ในขณะที่ใช้ตัวกรองอนุภาคสำหรับไลบรารีฟุตบอลหุ่นยนต์จำลอง RoboCup 3Dของฉันและรู้สึกประหลาดใจเมื่อสิ่งนี้ไม่รวมอยู่ในเฟรมเวิร์ก

ในขณะเดียวกันนี่คือเสื้อคลุมสำหรับRandomการใช้งานวิธีการขั้วโลกของ 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;
    }
}

Math.NET Iridiumยังอ้างว่าใช้ "เครื่องกำเนิดไฟฟ้าแบบสุ่มที่ไม่สม่ำเสมอ (ปกติ, ปัวซอง, ทวินาม, ... )"

นี่เป็นอีกวิธีที่รวดเร็วและสกปรกสำหรับการสร้างตัวแปรสุ่มที่มีปกติกระจาย มันดึงจุดสุ่ม (x, y) และตรวจสอบว่าจุดนี้อยู่ใต้เส้นโค้งของฟังก์ชันความหนาแน่นของความน่าจะเป็นของคุณหรือไม่หรือทำซ้ำ

โบนัส: คุณสามารถสร้างตัวแปรสุ่มสำหรับการแจกแจงอื่น ๆ (เช่นการแจกแจงเลขชี้กำลังหรือการแจกแจงแบบปัวซอง ) เพียงแค่แทนที่ฟังก์ชันความหนาแน่น

    static Random _rand = new Random();

    public static double Draw()
    {
        while (true)
        {
            // Get random values from interval [0,1]
            var x = _rand.NextDouble(); 
            var y = _rand.NextDouble(); 

            // Is the point (x,y) under the curve of the density function?
            if (y < f(x)) 
                return x;
        }
    }

    // Normal (or gauss) distribution function
    public static double f(double x, double μ = 0.5, double σ = 0.5)
    {
        return 1d / Math.Sqrt(2 * σ * σ * Math.PI) * Math.Exp(-((x - μ) * (x - μ)) / (2 * σ * σ));
    }

สำคัญ: เลือกช่วงเวลาของyและพารามิเตอร์σและμเพื่อไม่ให้เส้นโค้งของฟังก์ชันตัดที่จุดสูงสุด / ต่ำสุด (เช่นที่ x = ค่าเฉลี่ย) ให้คิดว่าช่วงเวลาของxและyเป็นกรอบล้อมรอบซึ่งเส้นโค้งต้องพอดี

ฉันต้องการขยายคำตอบของ @ yoyoyoyosef โดยทำให้เร็วขึ้นและเขียนคลาสกระดาษห่อ ค่าใช้จ่ายที่เกิดขึ้นอาจไม่ได้หมายความว่าเร็วขึ้นสองเท่า แต่ฉันคิดว่ามันน่าจะเร็วขึ้นเกือบสองเท่า แม้ว่าจะไม่ปลอดภัยต่อเธรด

public class Gaussian
{
     private bool _available;
     private double _nextGauss;
     private Random _rng;

     public Gaussian()
     {
         _rng = new Random();
     }

     public double RandomGauss()
     {
        if (_available)
        {
            _available = false;
            return _nextGauss;
        }

        double u1 = _rng.NextDouble();
        double u2 = _rng.NextDouble();
        double temp1 = Math.Sqrt(-2.0*Math.Log(u1));
        double temp2 = 2.0*Math.PI*u2;

        _nextGauss = temp1 * Math.Sin(temp2);
        _available = true;
        return temp1*Math.Cos(temp2);
     }

    public double RandomGauss(double mu, double sigma)
    {
        return mu + sigma*RandomGauss();
    }

    public double RandomGauss(double sigma)
    {
        return sigma*RandomGauss();
    }
}

การขยายคำตอบของ @Noakes และ @ Hameer ออกไปฉันได้ใช้คลาส 'Gaussian' ด้วย แต่เพื่อลดความซับซ้อนของพื้นที่หน่วยความจำฉันจึงทำให้มันเป็นลูกของคลาส Random เพื่อให้คุณสามารถเรียก Basic Next (), NextDouble () ฯลฯ จากคลาส Gaussian ด้วยโดยไม่ต้องสร้างวัตถุ Random เพิ่มเติมเพื่อจัดการกับมัน ฉันยังตัดคุณสมบัติคลาสส่วนกลาง _available และ _nextgauss เนื่องจากฉันไม่เห็นว่าจำเป็นเนื่องจากคลาสนี้อิงตามอินสแตนซ์จึงควรเป็นเธรดที่ปลอดภัยหากคุณให้แต่ละเธรดเป็นอ็อบเจกต์เกาส์ของตัวเอง ฉันยังย้ายตัวแปรที่จัดสรรรันไทม์ทั้งหมดออกจากฟังก์ชันและทำให้เป็นคุณสมบัติคลาสซึ่งจะลดจำนวนการเรียกไปยังตัวจัดการหน่วยความจำเนื่องจากในทางทฤษฎีแล้ว 4 คู่ไม่ควรถูกยกเลิกการจัดสรรจนกว่าอ็อบเจ็กต์จะถูกทำลาย

public class Gaussian : Random
{

    private double u1;
    private double u2;
    private double temp1;
    private double temp2;

    public Gaussian(int seed):base(seed)
    {
    }

    public Gaussian() : base()
    {
    }

    /// <summary>
    /// Obtains normally (Gaussian) distrubuted 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 RandomGauss(double mu = 0, double sigma = 1)
    {
        if (sigma <= 0)
            throw new ArgumentOutOfRangeException("sigma", "Must be greater than zero.");

        u1 = base.NextDouble();
        u2 = base.NextDouble();
        temp1 = Math.Sqrt(-2 * Math.Log(u1));
        temp2 = 2 * Math.PI * u2;

        return mu + sigma*(temp1 * Math.Cos(temp2));
    }
}

การขยายคำตอบของ Drew Noakes หากคุณต้องการประสิทธิภาพที่ดีกว่า Box-Muller (เร็วขึ้นประมาณ 50-75%) Colin Green ได้แบ่งปันการใช้งานอัลกอริทึม Ziggurat ใน C # ซึ่งคุณสามารถพบได้ที่นี่:

http://heliosphan.org/zigguratalgorithm/zigguratalgorithm.html

Ziggurat ใช้ตารางการค้นหาเพื่อจัดการกับค่าที่อยู่ห่างจากเส้นโค้งมากพอสมควรซึ่งจะยอมรับหรือปฏิเสธอย่างรวดเร็ว ประมาณ 2.5% ของเวลาจะต้องทำการคำนวณเพิ่มเติมเพื่อพิจารณาว่าตัวเลขอยู่ด้านใดของเส้นโค้ง

คุณสามารถลองใช้ Infer.NET ยังไม่ได้รับอนุญาตทางการค้า นี่คือลิงค์

เป็นกรอบความน่าจะเป็นสำหรับ. NET ที่พัฒนางานวิจัย Microsoft ของฉัน พวกเขามีประเภท. NET สำหรับการแจกแจงของ Bernoulli, Beta, Gamma, Gaussian, Poisson และอาจมีบางอย่างที่ฉันทิ้งไว้

มันอาจจะสำเร็จในสิ่งที่คุณต้องการ ขอบคุณ

นี่คือการนำ Box Muller มาใช้อย่างง่าย ๆ ของฉัน คุณสามารถเพิ่มความละเอียดให้เหมาะกับความต้องการของคุณ แม้ว่าจะใช้งานได้ดีสำหรับฉัน แต่นี่เป็นการประมาณแบบ จำกัด ดังนั้นโปรดจำไว้ว่าหางจะปิดและ จำกัด แต่แน่นอนว่าคุณสามารถขยายได้ตามต้องการ

    //
    // by Dan
    // islandTraderFX
    // copyright 2015
    // Siesta Key, FL
    //    
// 0.0  3231 ********************************
// 0.1  1981 *******************
// 0.2  1411 **************
// 0.3  1048 **********
// 0.4  810 ********
// 0.5  573 *****
// 0.6  464 ****
// 0.7  262 **
// 0.8  161 *
// 0.9  59 
//Total: 10000

double g()
{
   double res = 1000000;
   return random.Next(0, (int)(res * random.NextDouble()) + 1) / res;
}

public static class RandomProvider
{
   public static int seed = Environment.TickCount;

   private static ThreadLocal<Random> randomWrapper = new ThreadLocal<Random>(() =>
       new Random(Interlocked.Increment(ref seed))
   );

   public static Random GetThreadRandom()
   {
       return randomWrapper.Value;
   }
} 

ฉันไม่คิดว่าจะมี และฉันหวังเป็นอย่างยิ่งว่าจะไม่มีเนื่องจากเฟรมเวิร์กมีการขยายตัวเพียงพอแล้วหากไม่มีฟังก์ชันพิเศษดังกล่าวเติมเต็มให้มากขึ้น

ลองดูที่http://www.extremeoptimization.com/Statistics/UsersGuide/ContinuousDistributions/NormalDistribution.aspxและhttp://www.vbforums.com/showthread.php?t=488959สำหรับโซลูชัน. NET ของบุคคลที่สาม