If I understand it correctly, that code in fact chooses uniformly among some number (252 for Double, 223 for Float) of evenly-spaced values that span the range. Thus in general there will be many representable values in the range which are impossible to produce. For example, the range 0..<1 contains approximately 262 Double and 230 Float values.
The suggested alternative, namely to operate as though a real number were chosen uniformly from the range and then rounded to a representable value, is more subtle. It would make every representable value in the range possible to produce, with probability proportional to the gap between it and the next.
I have made an attempt at implementing such a function, and it works almost-correctly. There are some thorny rounding issues that I haven’t quite sorted out, though I’m sure @scanon knows how to do it right.
A sketch of one possible implementation:
extension BinaryFloatingPoint {
static func random<T: RandomNumberGenerator>(in range: Range<Self>, using generator: T) -> Self {
// Handle the easy cases
precondition(!range.isEmpty)
guard range.lowerBound.isFinite && range.upperBound.isFinite else {
return .nan
}
if (range.lowerBound.nextUp == range.upperBound) {
return range.lowerBound
}
// Subdivide the interval into 2^64 sections, choose one at random,
// and repeat recursively until the subinterval has only one value.
func randomHelper(_ subrange: Range<Self>) -> Self {
let n: UInt64 = generator.next()
// FIXME - This will underflow if Self.exponentBitCount is small
let scale: Self = 0x1p-64
// To avoid overflow here, we multiply before subtracting.
// FIXME - Need to handle underflow
let stepSize = (subrange.upperBound * scale) - (subrange.lowerBound * scale)
// FIXME - Need this to be rounded down, not rounded to nearest
let a = subrange.lowerBound + Self(n) * stepSize
let b = a + stepSize
if (a == b) || (a.nextUp == b) {
return a
}
return randomHelper(a ..< b)
}
// Do the subdividing thing, and if any weird rounding issues make the
// value fall outside the target range, then try again until it works.
var result = randomHelper(range)
while !range.contains(result) {
result = randomHelper(range)
}
return result
}
}
Note that the vast majority of the time the randomHelper() function returns a value on its first pass, with no recursion necessary. For Double it will need a second pass approximately 1 in 1024 times, and for Float only 1 in 240.