浮点 RNG 是否应该在 0 附近更精确？

Question

System.Random 的浮点 RNG 看起来很简单，但对我来说并不准确：

instance Random Double where
  randomR = randomRFloating
  random rng     = 
    case random rng of 
      (x,rng') -> 
          -- We use 53 bits of randomness corresponding to the 53 bit significand:
          ((fromIntegral (mask53 .&. (x::Int64)) :: Double)  
       /  fromIntegral twoto53, rng')
   where 
    twoto53 = (2::Int64) ^ (53::Int64)
    mask53 = twoto53 - 1

虽然这个RNG确实能统一产生FP数，但有一点我是怀疑的：有一些数字在RNG不能产生的范围内。

具体来说，“太”精确的数字。例如，这个 RNG 可以产生（表示为二进制 IEEE 双精度 FP；符号、指数，然后是尾数）：

0 01111111101 0000000000000000000000000000000000000000000000000000

正好是 ¼，但不能产生：

0 01111111101 0000000000000000000000000000000000000000000000000001

因为最后一个1（勉强）精度太高。

我怀疑这是否会发生，所以我编写了自己的统一 FP RNG：

{-# LANGUAGE ScopedTypeVariables #-}

import Data.Bifunctor
import System.Random

randomFloat1to2 :: (RandomGen g, Random a, RealFloat a) => g -> (a, g) -- Uniformly generates random Float among [1,2)
randomFloat1to2 g = first (1+) (random g)

randomFloatExp :: forall a g. (RandomGen g, Random a, RealFloat a) => Int -> g -> (a, g) -- Uniformly generates random Float among [0, 2^(exp+1))
randomFloatExp exp g = let
    (minexp, _) = floatRange (0 :: a)
    (upperHalf, g') = random g
    in if exp == minexp
        then (0, g') -- Denormal numbers treated as 0
        else if upperHalf
            then first (2^^exp *) (randomFloat1to2 g')
            else randomFloatExp (exp-1) g'

randomFloat :: (RandomGen g, Random a, RealFloat a) => g -> (a, g) -- Uniformly generates random Float among [0,1)
randomFloat = randomFloatExp (-1)

解释：

在 [0,1) 范围内的 Double 数字中，[½,1) 中的所有数字都具有 IEEE 指数 01111111110，而其他数字具有较小的指数。所以 RNG 掷硬币：

如果出现正面，RNG 通过将 ½ 与 [1,2) 中的随机数相乘，在 [½,1) 中选择一个随机数。由于默认的random 有效地选择了一个随机尾数，我们可以将其加 1 以生成范围 [1,2) 的统一 RNG。

如果不是，则 RNG 通过 [¼,½)、[⅛,¼) 等进行递归，直到范围非正规。

我的版本可以被认为是更好的版本吗？

Answer 1

浮点RNG应该在0附近更精确吗？

取决于功能目标以及@Eric Postpischil 的评论。

这就像问tan(x) 是否比sin(x) 更好：这取决于目标。两者都对小的x 给出了相同的答案，但在范围的另一部分不同。

---

我的版本可以被认为是更好的版本吗？

它不是更好的一个原因：在最坏的情况下完成时间可能会非常长 - 即使它可能很少见。

RNG 通过 [¼,½)、[⅛,¼) 等进行递归，直到范围非正规。

通过 [¼,½), [⅛,¼) 递归到非正规可能需要 数千次递归。

为了帮助一点，代码可以生成一个随机指数，仍然是递归的，但速度更快（n 位 random 的 MSBit 变为指数，除非随机数为 0，然后需要递归调用。）

这将递归减少了 N 的一个因子（位宽为random 数字）。

然而，一个不会递归 scores 次的解决方案需要不同的 random 来计算指数。