这个页面上关于双打的每一个答案都是错误的,这有点搞笑,因为每个人都在引用文档。如果你使用 NextDouble() 生成一个双精度数,你将不会得到一个介于 0 和 1 之间(包括 1)的数字,你会得到一个从 0 到 1 不包括 1 的数字。
要获得双倍,你必须做一些这样的诡计:
public double NextRandomRange(double minimum, double maximum)
{
Random rand = new Random();
return rand.NextDouble() * (maximum - minimum) + minimum;
}
然后调用
NextRandomRange(0,1 + Double.Epsilon);
似乎这样会起作用,不是吗? 1 + Double.Epsilon 在使用双打时应该是 1 之后的下一个最大数,对吧?这就是解决整数问题的方法。
嗯嗯嗯嗯嗯嗯......
我怀疑这将无法正常工作,因为底层代码将生成几个字节的随机性,然后执行一些数学技巧以使其适应预期范围。简短的回答是,适用于整数的逻辑在使用浮点数时并不完全一样。
让我们看看,好吗? (https://referencesource.microsoft.com/#mscorlib/system/random.cs,e137873446fcef75)
/*=====================================Next=====================================
**Returns: A double [0..1)
**Arguments: None
**Exceptions: None
==============================================================================*/
public virtual double NextDouble() {
return Sample();
}
Sample() 到底是什么?
/*====================================Sample====================================
**Action: Return a new random number [0..1) and reSeed the Seed array.
**Returns: A double [0..1)
**Arguments: None
**Exceptions: None
==============================================================================*/
protected virtual double Sample() {
//Including this division at the end gives us significantly improved
//random number distribution.
return (InternalSample()*(1.0/MBIG));
}
好的,开始有所收获。 MBIG 顺便说一句,是 Int32.MaxValue(2147483647 或 2^31-1),使除法计算为:
InternalSample()*0.0000000004656612873077392578125;
好的,InternalSample() 到底是什么?
private int InternalSample() {
int retVal;
int locINext = inext;
int locINextp = inextp;
if (++locINext >=56) locINext=1;
if (++locINextp>= 56) locINextp = 1;
retVal = SeedArray[locINext]-SeedArray[locINextp];
if (retVal == MBIG) retVal--;
if (retVal<0) retVal+=MBIG;
SeedArray[locINext]=retVal;
inext = locINext;
inextp = locINextp;
return retVal;
}
嗯……就是这样。但是这个 SeedArray 和 inext 废话到底是怎么回事?
private int inext;
private int inextp;
private int[] SeedArray = new int[56];
所以事情开始一起下降。种子数组是一个整数数组,用于从中生成值。如果您查看 init 函数 def,您会发现有很多位添加和技巧正在执行以随机化具有初始准随机值的 55 个值的数组。
public Random(int Seed) {
int ii;
int mj, mk;
//Initialize our Seed array.
//This algorithm comes from Numerical Recipes in C (2nd Ed.)
int subtraction = (Seed == Int32.MinValue) ? Int32.MaxValue : Math.Abs(Seed);
mj = MSEED - subtraction;
SeedArray[55]=mj;
mk=1;
for (int i=1; i<55; i++) { //Apparently the range [1..55] is special (All hail Knuth!) and so we're skipping over the 0th position.
ii = (21*i)%55;
SeedArray[ii]=mk;
mk = mj - mk;
if (mk<0) mk+=MBIG;
mj=SeedArray[ii];
}
for (int k=1; k<5; k++) {
for (int i=1; i<56; i++) {
SeedArray[i] -= SeedArray[1+(i+30)%55];
if (SeedArray[i]<0) SeedArray[i]+=MBIG;
}
}
inext=0;
inextp = 21;
Seed = 1;
}
好的,回到 InternalSample(),我们现在可以看到随机双精度数是通过取两个加扰的 32 位整数的差值生成的,将结果钳制在 0 到 2147483647 - 1 的范围内,然后将结果相乘通过 1/2147483647。当它使用值时,会做更多的诡计来扰乱种子值列表,但本质上就是这样。
(有趣的是,得到范围内任何数字的机会大约是 1/r,除了 2^31-2,即 2 * (1/r)!所以如果你认为一些愚蠢的编码器是使用 RandNext() 在视频扑克机上生成数字,您应该始终下注 2^32-2!这就是我们不将 Random 用于任何重要事情的原因之一......)
所以,如果 InternalSample() 的输出为 0,我们将其乘以 0.0000000004656612873077392578125 并得到 0,即我们范围的底端。如果我们得到 2147483646,我们最终得到 0.9999999995343387126922607421875,所以 NextDouble 产生 [0,1) 结果的说法是......对吗?更准确地说,它在 [0,0.9999999995343387126922607421875] 的范围内。
我建议的上述解决方案将落空,因为 double.Epsilon = 4.94065645841247E-324,远小于 0.0000000004656612873077392578125(您将添加到我们上述结果中以获得 1 的数量)。
讽刺的是,如果不是在 InternalSample() 方法中减一:
if (retVal == MBIG) retVal--;
我们可以在返回的返回值中达到 1。因此,要么复制 Random 类中的所有代码并省略 retVal-- 行,要么将 NextDouble() 输出乘以 1.0000000004656612875245796924106 之类的值,以稍微拉伸输出以在范围内包含 1。实际上测试这个值让我们非常接近,但我不知道我运行的几亿次测试是否没有产生 2147483646(很可能)或者有一个浮点错误潜入等式。我怀疑是前者。数以百万计的测试不太可能产生 20 亿分之一的结果。
NextRandomRange(0,1.0000000004656612875245796924106); // try to explain where you got that number during the code review...
TLDR?包含随机双精度的范围很棘手......