【问题标题】:How do I generate random number between 0 and 1 in C#?如何在 C# 中生成 0 到 1 之间的随机数?
【发布时间】:2017-01-29 19:12:58
【问题描述】:

我想得到 1 和 0 之间的随机数。但是,我每次都得到 0。有人可以解释为什么我总是得到 0 的原因吗? 这是我试过的代码。

Random random = new Random();
int test = random.Next(0, 1);
Console.WriteLine(test);
Console.ReadKey();

【问题讨论】:

  • 只有一个整数,即>= 0和< 1。因此,你得到了你想要的。
  • 请阅读Random.Next 的文档并查看您提供的值。如果你想要一个非整数,那么你使用了错误的调用。如果你想得到 0 或 1,你应该传递 2 作为唯一的上界。
  • 双重测试 =random.NextDouble();

标签: c# .net random


【解决方案1】:

根据documentation,Next 返回一个介于(含)最小值和(不含)最大值之间的整数随机数:

返回值

大于或等于 minValue 且小于 maxValue 的 32 位有符号整数;即返回值的范围包括minValue,但不包括maxValue。如果 minValue 等于 maxValue,则返回 minValue。

唯一满足的整数

0 <= x < 1

是0,因此你总是得到0的值。换句话说,0 是唯一在半闭区间[0, 1) 内的整数。

所以,如果您真的对整数值 0 或 1 感兴趣,那么请使用 2 作为上限:

var n = random.Next(0, 2);

如果您想获得 0 和 1 之间的小数,请尝试:

var n = random.NextDouble();

希望这会有所帮助:-)

【讨论】:

    【解决方案2】:

    你可以,但你应该这样做:

    double test = random.NextDouble();
    

    如果你想得到随机整数(0或1),你应该设置上限为2,因为它是排他的

    int test = random.Next(0, 2);
    

    【讨论】:

      【解决方案3】:

      这个页面上关于双打的每一个答案都是错误的,这有点搞笑,因为每个人都在引用文档。如果你使用 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?包含随机双精度的范围很棘手......

      【讨论】:

        【解决方案4】:

        你得到零是因为Random.Next(a,b) 返回范围 [a, b) 中的数字,该数字大于或等于 a 且小于 b。

        如果你想得到 {0, 1} 之一,你应该使用:

        var random = new Random();
        var test = random.Next(0, 2);
        

        【讨论】:

          【解决方案5】:

          因为您要求的数字小于1。

          documentation 说:

          返回值
          大于或等于 minValue 且小于 maxValue 的 32 位有符号整数;也就是返回值的范围 包括 minValue 但不包括 maxValue。如果 minValue 等于 maxValue, 返回 minValue。

          【讨论】:

            【解决方案6】:

            如果您的目标是 0.0 到 1.0,请像这样重写代码

            Random random = new Random();
            
            double test = random.NextDouble();
            
            Console.WriteLine(test);
            
            Console.ReadKey();
            

            【讨论】:

              猜你喜欢
              • 1970-01-01
              • 2014-04-11
              • 1970-01-01
              • 2011-07-07
              • 1970-01-01
              • 2012-09-27
              • 2010-12-06
              • 1970-01-01
              • 1970-01-01
              相关资源
              最近更新 更多