在0.0和1.0之间有多少个双数？

这是我多年来一直在思考的问题，但我以前从来没有花时间去问过。

许多(伪)随机数生成器生成介于0.0和1.0之间的随机数。从数学上讲，在这个范围内有无限个数字，但是 double是一个浮点数，因此具有有限的精度。

所以问题是:

  1. 0.0到1.0之间有多少 double数字？
  2. 在1和2之间，在100和101之间，在10 ^ 100和10 ^ 100 + 1之间，有同样多的数字吗？

注意: 如果这有什么不同的话，我特别感兴趣的是 Java 对 double的定义。

11774 次浏览
小开
  1. 2^53 - the size of the significand/mantissa of a 64bit floating point number including the hidden bit.
  2. Roughly yes, as the significand is fixed but the exponent changes.

See the wikipedia article for more information.

小开

The article Java's new math, Part 2: Floating-point numbers from IBM offers the following code snippet to solve this (in floats, but I suspect it works for doubles as well):

public class FloatCounter {


public static void main(String[] args) {
float x = 1.0F;
int numFloats = 0;
while (x <= 2.0) {
numFloats++;
System.out.println(x);
x = Math.nextUp(x);
}
System.out.println(numFloats);
}
}

They have this comment about it:

It turns out there are exactly 8,388,609 floats between 1.0 and 2.0 inclusive; large but hardly the uncountable infinity of real numbers that exist in this range. Successive numbers are about 0.0000001 apart. This distance is called an ULP for unit of least precision or unit in the last place.

小开
最佳答案

Java doubles are in IEEE-754 format, therefore they have a 52-bit fraction; between any two adjacent powers of two (inclusive of one and exclusive of the next one), there will therefore be 2 to the 52th power different doubles (i.e., 4503599627370496 of them). For example, that's the number of distinct doubles between 0.5 included and 1.0 excluded, and exactly that many also lie between 1.0 included and 2.0 excluded, and so forth.

Counting the doubles between 0.0 and 1.0 is harder than doing so between powers of two, because there are many powers of two included in that range, and, also, one gets into the thorny issues of denormalized numbers. 10 of the 11 bits of the exponents cover the range in question, so, including denormalized numbers (and I think a few kinds of NaN) you'd have 1024 times the doubles as lay between powers of two -- no more than 2**62 in total anyway. Excluding denormalized &c, I believe the count would be 1023 times 2**52.

For an arbitrary range like "100 to 100.1" it's even harder because the upper bound cannot be exactly represented as a double (not being an exact multiple of any power of two). As a handy approximation, since the progression between powers of two is linear, you could say that said range is 0.1 / 64th of the span between the surrounding powers of two (64 and 128), so you'd expect about

(0.1 / 64) * 2**52

distinct doubles -- which comes to 7036874417766.4004... give or take one or two;-).

小开

The Java double is a IEEE 754 binary64 number.

This means that we need to consider:

  1. Mantissa is 52 bit
  2. Exponent is 11 bit number with 1023 bias (ie with 1023 added to it)
  3. If the exponent is all 0 and the mantissa is non zero then the number is said to be non-normalized

This basically means there is a total of 2^62-2^52+1 of possible double representations that according to the standard are between 0 and 1. Note that 2^52+1 is to the remove the cases of the non-normalized numbers.

Remember that if mantissa is positive but exponent is negative number is positive but less than 1 :-)

For other numbers it is a bit harder because the edge integer numbers may not representable in a precise manner in the IEEE 754 representation, and because there are other bits used in the exponent to be able represent the numbers, so the larger the number the lower the different values.

小开

Every double value whose representation is between 0x0000000000000000 and 0x3ff0000000000000 lies in the interval [0.0, 1.0]. That's (2^62 - 2^52) distinct values (plus or minus a couple depending on whether you count the endpoints).

The interval [1.0, 2.0] corresponds to representations between 0x3ff0000000000000 and 0x400000000000000; that's 2^52 distinct values.

The interval [100.0, 101.0] corresponds to representations between 0x4059000000000000 and 0x4059400000000000; that's 2^46 distinct values.

There are no doubles between 10^100 and 10^100 + 1. Neither one of those numbers is representable in double precision, and there are no doubles that fall between them. The closest two double precision numbers are:

99999999999999982163600188718701095...

and 

10000000000000000159028911097599180...
小开

Others have already explained that there are around 2^62 doubles in the range [0.0, 1.0].
(Not really surprising: there are almost 2^64 distinct finite doubles; of those, half are positive, and roughly half of those are < 1.0.)

But you mention random number generators: note that a random number generator generating numbers between 0.0 and 1.0 cannot in general produce all these numbers; typically it'll only produce numbers of the form n/2^53 with n an integer (see e.g. the Java documentation for nextDouble). So there are usually only around 2^53 (+/-1, depending on which endpoints are included) possible values for the random() output. This means that most doubles in [0.0, 1.0] will never be generated.


提交答案