Biến Gaussian ngẫu nhiên

Có lớp nào trong thư viện chuẩn của .NET cung cấp cho tôi chức năng tạo các biến ngẫu nhiên tuân theo phân phối Gaussian không?

Đề xuất của Jarrett về việc sử dụng phép biến hình Box-Muller là một giải pháp tốt và nhanh chóng. Cách thực hiện đơn giản:

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)

Câu hỏi này dường như đã chuyển lên đầu Google cho thế hệ .NET Gaussian, vì vậy tôi nghĩ rằng tôi sẽ đăng một câu trả lời.

Tôi đã tạo một số phương thức mở rộng cho lớp .NET Random , bao gồm cả việc triển khai biến đổi Box-Muller. Vì chúng là phần mở rộng, nên miễn là dự án được bao gồm (hoặc bạn tham chiếu đến DLL đã biên dịch), bạn vẫn có thể

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

Hy vọng không ai bận tâm đến cái phích cắm vô liêm sỉ.

Biểu đồ kết quả mẫu (bao gồm một ứng dụng demo để vẽ cái này):

Math.NET cung cấp chức năng này. Đây là cách thực hiện:

double mean = 100;
double stdDev = 10;

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

Bạn có thể tìm tài liệu tại đây: http://numerics.mathdotnet.com/api/MathNet.Numerics.Distributions/Normal.htm

Tôi đã tạo một yêu cầu cho một tính năng như vậy trên Microsoft Connect. Nếu đây là thứ bạn đang tìm kiếm, vui lòng bỏ phiếu cho nó và tăng khả năng hiển thị của nó.

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

Tính năng này được bao gồm trong Java SDK. Việc triển khai nó có sẵn như một phần của tài liệu và dễ dàng chuyển sang C # hoặc các ngôn ngữ .NET khác.

Nếu bạn đang tìm kiếm tốc độ thuần túy, thì Thuật toán Zigorat thường được công nhận là cách tiếp cận nhanh nhất.

Mặc dù vậy, tôi không phải là chuyên gia về chủ đề này - tôi đã bắt gặp nhu cầu này khi triển khai bộ lọc hạt cho thư viện bóng đá mô phỏng RoboCup 3D và rất ngạc nhiên khi điều này không được đưa vào khuôn khổ.

Trong khi đó, đây là một trình bao bọc để Randomcung cấp triển khai hiệu quả phương pháp phân cực 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 cũng tuyên bố thực hiện "bộ tạo ngẫu nhiên không đồng nhất (bình thường, poisson, nhị thức, ...)".

Đây là một giải pháp nhanh chóng và hiệu quả khác để tạo ra các biến ngẫu nhiên có phân phối chuẩn . Nó vẽ một số điểm ngẫu nhiên (x, y) và kiểm tra xem điểm này có nằm dưới đường cong của hàm mật độ xác suất của bạn hay không, nếu không thì lặp lại.

Phần thưởng: Bạn có thể tạo các biến ngẫu nhiên cho bất kỳ phân phối nào khác (ví dụ: phân phối hàm mũ hoặc phân phối poisson ) chỉ bằng cách thay thế hàm mật độ.

    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 * σ * σ));
    }

Quan trọng: Chọn khoảng của y và các tham số σ và μ để đường cong của hàm không bị cắt tại các điểm cực đại / cực tiểu của nó (ví dụ: tại x = mean). Hãy coi các khoảng của x và y như một hộp giới hạn, trong đó đường cong phải vừa với.

Tôi muốn mở rộng câu trả lời của @ yoyoyoyosef bằng cách làm cho nó nhanh hơn và viết một lớp trình bao bọc. Chi phí phát sinh có thể không nhanh gấp đôi, nhưng tôi nghĩ nó phải nhanh hơn gần gấp đôi. Tuy nhiên, nó không an toàn cho chuỗi.

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();
    }
}

Mở rộng các câu trả lời của @Noakes và @ Hameer, tôi cũng đã triển khai lớp 'Gaussian', nhưng để đơn giản hóa không gian bộ nhớ, tôi đã đặt nó trở thành con của lớp Ngẫu nhiên để bạn cũng có thể gọi cơ bản Next (), NextDouble () , v.v. từ lớp Gaussian mà không cần phải tạo thêm một đối tượng Ngẫu nhiên để xử lý nó. Tôi cũng đã loại bỏ các thuộc tính lớp toàn cục _available và _nextgauss, vì tôi không thấy chúng là cần thiết vì lớp này dựa trên cá thể, nó sẽ an toàn cho luồng, nếu bạn cung cấp cho mỗi luồng đối tượng Gaussian của riêng nó. Tôi cũng đã di chuyển tất cả các biến được cấp phát thời gian chạy ra khỏi hàm và đặt chúng thành thuộc tính lớp, điều này sẽ làm giảm số lượng lệnh gọi tới trình quản lý bộ nhớ vì 4 biến đôi về mặt lý thuyết sẽ không bao giờ được hủy cấp phát cho đến khi đối tượng bị phá hủy.

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));
    }
}

Mở rộng câu trả lời của Drew Noakes, nếu bạn cần hiệu suất tốt hơn Box-Muller (nhanh hơn khoảng 50-75%), Colin Green đã chia sẻ cách triển khai thuật toán Ziggurat trong C #, bạn có thể tìm thấy ở đây:

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

Ziggurat sử dụng một bảng tra cứu để xử lý các giá trị nằm đủ xa so với đường cong mà nó sẽ nhanh chóng chấp nhận hoặc từ chối. Khoảng 2,5% thời gian, nó phải tính toán thêm để xác định một số nằm ở phía nào của đường cong.

Bạn có thể thử Infer.NET. Tuy nhiên, nó chưa được cấp phép thương mại. Đây là liên kết

Nó là một khuôn khổ xác suất cho .NET đã phát triển nghiên cứu Microsoft của tôi. Họ có các loại .NET cho các bản phân phối Bernoulli, Beta, Gamma, Gaussian, Poisson, và có lẽ tôi đã bỏ qua một số loại khác.

Nó có thể đạt được những gì bạn muốn. Cảm ơn.

Đây là cách triển khai lấy cảm hứng từ Box Muller đơn giản của tôi. Bạn có thể tăng độ phân giải để phù hợp với nhu cầu của mình. Mặc dù điều này rất hiệu quả đối với tôi, nhưng đây là một khoảng gần đúng trong phạm vi giới hạn, vì vậy hãy nhớ rằng các phần đuôi là đóng và hữu hạn, nhưng chắc chắn bạn có thể mở rộng chúng khi cần thiết.

    //
    // 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;
   }
} 

Tôi không nghĩ là có. Và tôi thực sự hy vọng là không có, vì khung công tác đã đủ cồng kềnh, mà không có chức năng chuyên biệt như vậy sẽ lấp đầy nó hơn nữa.

Tuy nhiên, hãy xem http://www.extremeoptimization.com/Statistics/UsersGuide/ContinuousDistributions/NormalDistribution.aspx và http://www.vbforums.com/showthread.php?t=488959 để biết các giải pháp .NET của bên thứ ba.