blocks|key|1712473|text|Jarrett建议使用Box-Muller变换，这是一个快速而棘手的解决方案。一个简单的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1712474|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+%2B+stdDev+*+randStdNormal;+//random+normal(mean,stdDev%5E2)|code-block|syntax|javascript|1712475|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Jarrett's suggestion of using a Box-Muller transform is good for a quick-and-dirty solution. A simple implementation:

<pre><code>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)
</code></pre>

blocks|key|1497405|text|我不认为有。我真的希望不会有，因为框架已经足够臃肿了，没有这样的专业功能填充它更多。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1497406|不过，还是看看第三方.NET解决方案的http://www.extremeoptimization.com/Statistics/UsersGuide/ContinuousDistributions/NormalDistribution.aspx和http://www.vbforums.com/showthread.php?t=488959吧。|offset|length|1497407|entityMap|0|LINK|mutability|MUTABLE|url|http://www.extremeoptimization.com/Statistics/UsersGuide/ContinuousDistributions/NormalDistribution.aspx|1|http://www.vbforums.com/showthread.php?t=488959^0|0|J|2W|0|3G|1B|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]|$D|U|E|V|1|W]]|A|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]|N|$5|I|J|K|A|$L|O]]]]

I don't think there is. And I really hope there isn't, as the framework is already bloated enough, without such specialised functionality filling it even more.

Take a look at <a href="http://www.extremeoptimization.com/Statistics/UsersGuide/ContinuousDistributions/NormalDistribution.aspx" rel="nofollow noreferrer">http://www.extremeoptimization.com/Statistics/UsersGuide/ContinuousDistributions/NormalDistribution.aspx</a> and <a href="http://www.vbforums.com/showthread.php?t=488959" rel="nofollow noreferrer">http://www.vbforums.com/showthread.php?t=488959</a> for a third party .NET solutions though.

blocks|key|1497520|text|Math.NET+Iridium还声称实现了“非均匀随机生成器(normal，poisson，binomial，...)”。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1497521|entityMap|0|LINK|mutability|MUTABLE|url|http://iridium.mathdotnet.com/^0|0|G|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="http://iridium.mathdotnet.com" rel="nofollow noreferrer">Math.NET Iridium</a> also claims to implement "non-uniform random generators (normal, poisson, binomial, ...)".

blocks|key|1497578|text|你可以试试Infer.NET，但它还没有获得商业许可。这就是link|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1497579|这是我在微软的研究中为.NET开发的一个概率框架。他们有伯努利分布、贝塔分布、伽马分布、高斯分布、泊松分布的.NET类型，可能还有一些我没有提到的。|1497580|它可能会实现你想要的。谢谢。|1497581|entityMap|0|LINK|mutability|MUTABLE|url|http://research.microsoft.com/en-us/um/cambridge/projects/infernet/^0|U|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]]]

You could try Infer.NET. It's not commercial licensed yet though. Here is there <a href="http://research.microsoft.com/en-us/um/cambridge/projects/infernet/" rel="nofollow">link</a>

It is a probabilistic framework for .NET developed my Microsoft research. They have .NET types for distributions of Bernoulli, Beta, Gamma, Gaussian, Poisson, and probably some more I left out.

It may accomplish what you want. Thanks.

blocks|key|1497585|text|Math.NET提供了此功能。下面是操作步骤：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1497586|double+mean+=+100;
double+stdDev+=+10;

MathNet.Numerics.Distributions.Normal+normalDist+=+new+Normal(mean,+stdDev);
double+randomGaussianValue=+++normalDist.Sample();|code-block|syntax|javascript|1497587|您可以在此处找到文档：http://numerics.mathdotnet.com/api/MathNet.Numerics.Distributions/Normal.htm|1497588|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mathdotnet.com/|1|http://numerics.mathdotnet.com/api/MathNet.Numerics.Distributions/Normal.htm^0|0|8|0|0|0|B|24|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$A|10|B|11|1|12]]|C|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]|S|$5|N|O|P|C|$Q|T]]]]

<a href="http://www.mathdotnet.com/">Math.NET</a> provides this functionality. Here's how:

<pre><code>double mean = 100;
double stdDev = 10;

MathNet.Numerics.Distributions.Normal normalDist = new Normal(mean, stdDev);
double randomGaussianValue= normalDist.Sample();
</code></pre>

You can find documentation here:
<a href="http://numerics.mathdotnet.com/api/MathNet.Numerics.Distributions/Normal.htm">http://numerics.mathdotnet.com/api/MathNet.Numerics.Distributions/Normal.htm</a>

blocks|key|1712683|text|这个问题似乎已经移到了谷歌的.NET高斯世代的顶部，所以我想我应该发布一个答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1712684|我做了一些extension+methods+for+the+.NET+Random+class，包括一个Box-Muller转换的实现。因为它们是扩展，所以只要包含项目(或者引用已编译的DLL)，您仍然可以这样做|offset|length|1712685|var+r+=+new+Random();
var+x+=+r.NextGaussian();|code-block|syntax|javascript|1712686|希望没人会介意这个无耻的插头。|1712687|结果直方图示例(包括一个绘制此结果的演示应用程序)：|1712688|​|1712689|📷|atomic|1712690|1712691|entityMap|0|LINK|mutability|MUTABLE|url|https://bitbucket.org/Superbest/superbest-random|1|IMAGE|IMMUTABLE|imageUrl|https://ask.qcloudimg.com/http-save/yehe-900000/062adaacc76e095e73c9db63715c7c92.png|imageAlt^0|0|5|17|0|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@$D|1A|E|1B|1|1C]]|A|$]]|$1|F|3|G|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1E|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1F|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1H|8|@]|9|@$D|1I|E|1J|1|1K]]|A|$]]|$1|T|3|P|5|6|7|1L|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]|12|$5|13|Y|14|A|$15|16|17|-4]]]]

This question appears to have moved on top of Google for .NET Gaussian generation, so I figured I'd post an answer.

I've made some <a href="https://bitbucket.org/Superbest/superbest-random" rel="noreferrer">extension methods for the .NET Random class</a>, including an implementation of the Box-Muller transform. Since they're extensions, so long as the project is included (or you reference the compiled DLL), you can still do

<pre><code>var r = new Random();
var x = r.NextGaussian();
</code></pre>

Hope nobody minds the shameless plug.

Sample histogram of results (a demo app for drawing this is included):

<img src="https://i.stack.imgur.com/Np1ed.png" alt="enter image description here">

blocks|key|1712733|text|这是我受Box+Muller启发的简单实现。您可以增加分辨率以满足您的需要。虽然这对我来说很有效，但这是一个有限范围的近似，所以请记住尾部是封闭的和有限的，但当然你可以根据需要扩展它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1712734|++++//
++++//+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())+%2B+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;
+++}
}+|code-block|syntax|javascript|1712735|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This is my simple Box Muller inspired implementation. You can increase the resolution to fit your needs. Although this works great for me, this is a limited range approximation, so keep in mind the tails are closed and finite, but certainly you can expand them as needed.

<pre><code> //
 // 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&lt;Random&gt; randomWrapper = new ThreadLocal&lt;Random&gt;(() =&gt;
 new Random(Interlocked.Increment(ref seed))
 );

 public static Random GetThreadRandom()
 {
 return randomWrapper.Value;
 }
} 
</code></pre>

blocks|key|1497743|text|扩展德鲁·诺克斯的答案，如果你需要比Box-Muller更好的性能(大约快50-75%25+)，Colin+Green分享了一个用C#实现的Ziggurat算法，你可以在这里找到：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1497744|http://heliosphan.org/zigguratalgorithm/zigguratalgorithm.html|offset|length|1497745|Ziggurat使用查找表来处理距离曲线足够远的值，它会很快接受或拒绝这些值。在大约2.5%25的时间里，它必须做进一步的计算来确定一个数字在曲线的哪一边。|1497746|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1Q|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@$D|Q|E|R|1|S]]|A|$]]|$1|F|3|G|5|6|7|T|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|C]]]]

Expanding on Drew Noakes's answer, if you need better performance than Box-Muller (around 50-75% faster), Colin Green has shared an implementation of the Ziggurat algorithm in C#, which you can find here:

<a href="http://heliosphan.org/zigguratalgorithm/zigguratalgorithm.html" rel="nofollow noreferrer">http://heliosphan.org/zigguratalgorithm/zigguratalgorithm.html</a>

Ziggurat uses a lookup table to handle values that fall sufficiently far from the curve, which it will quickly accept or reject. Around 2.5% of the time, it has to do further calculations to determine which side of the curve a number is on.

blocks|key|1712870|text|在@Noake和@Hameer的回答的基础上，我还实现了一个“高斯”类，但为了简化内存空间，我将它设为Random类的子类，这样您也可以从高斯类中调用基本的Next()、NextDouble()等，而不必创建额外的Random对象来处理它。我还删除了_available和_nextgauss全局类属性，因为我不认为它们是必要的，因为这个类是基于实例的，如果你给每个线程提供自己的高斯对象，它应该是线程安全的。我还将所有运行时分配的变量移出了函数，并使其成为类属性，这将减少对内存管理器的调用次数，因为理论上，在对象被销毁之前，这4个双精度数永远不应该被释放。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1712871|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+%2B+sigma*(temp1+*+Math.Cos(temp2));
++++}
}|code-block|syntax|javascript|1712872|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Expanding off of @Noakes and @Hameer's answers, I have also implemented a 'Gaussian' class, but to simplify memory space, I made it a child of the Random class so that you can also call the basic Next(), NextDouble(), etc from the Gaussian class as well without having to create an additional Random object to handle it. I also eliminated the _available, and _nextgauss global class properties, as I didn't see them as necessary since this class is instance based, it should be thread-safe, if you give each thread its own Gaussian object. I also moved all of the run-time allocated variables out of the function and made them class properties, this will reduce the number of calls to the memory manager since the 4 doubles should theoretically never be de-allocated until the object is destroyed.

<pre><code>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()
 {
 }

 /// &lt;summary&gt;
 /// 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.
 /// &lt;/summary&gt;
 /// &lt;param name="mu"&gt;The mean of the distribution. Default is zero&lt;/param&gt;
 /// &lt;param name="sigma"&gt;The standard deviation of the distribution. Default is one.&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;

 public double RandomGauss(double mu = 0, double sigma = 1)
 {
 if (sigma &lt;= 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));
 }
}
</code></pre>

blocks|key|1712920|text|对我来说，其他的实现有点让人头晕。我的实现依赖于这样一个事实:抛出三个六面骰子(D6)并记录骰子的总和将创建一个正态分布。只需将这三个D6替换为对您的语言的"rand()“函数的三个调用，就差不多了。在下面的实现中，我减去2除以“骰子”的数量，所以在本例中是1.5。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1712921|using+System;

public+class+CustomMath
{
++++private+static+readonly+Random+_random+=+new+Random();
++++public+static+double+GaussianRandom()+=>
++++++++_random.NextDouble()+%2B+_random.NextDouble()+%2B+_random.NextDouble()+-+1.5;
}|code-block|syntax|javascript|1712922|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The other implementations are a little too heady for me. My implementation relies on the fact that throwing three six sided dice (D6) and recording the sum of the dice will creates a normal distribution. Just replace the three D6 with three calls to your your language's &quot;rand()&quot; function and you're just about there. In the implementation below, I subtract by two divided by the number of &quot;dice,&quot; so 1.5 in this case.
<pre><code>using System;

public class CustomMath
{
 private static readonly Random _random = new Random();
 public static double GaussianRandom() =&gt;
 _random.NextDouble() + _random.NextDouble() + _random.NextDouble() - 1.5;
}
</code></pre>

Is there a class in the standard library of .NET that gives me the functionality to create random variables that follow Gaussian distribution?

Random Gaussian Variables

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在.NET的标准库中有没有一个类可以让我创建服从高斯分布的随机变量？

问随机高斯变量
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问随机高斯变量EN