Сколько двойных чисел там между 0,0 и 1.0?

Каждое значение double, чье представление находится между 0x0000000000 и 0x3ff0000000000000, лежит в интервале [0.0, 1.0]. Это (2^62 - 2^52) различных значений (плюс или минус пара, в зависимости от того, считаете ли вы конечные точки).

Интервал [1.0, 2.0] соответствует представлениям между 0x3ff0000000000000 и 0x40000000000; это 2^52 различных значений.

Интервал [100.0, 101.0] соответствует представлениям между 0x40590000000000 и 0x405940000000000000; это 2^46 различных значений.

Между 10^100 и 10^100 + 1 нет двоек. Ни одно из этих чисел не может быть представлено с двойной точностью, и между ними нет двойных чисел. Ближайшие два числа двойной точности:

99999999999999982163600188718701095...

и

10000000000000000159028911097599180...

Другие уже объяснили, что в диапазоне [0.0, 1.0] имеется около 2 ^ 62 двойников.
(Неудивительно: существует почти 2 ^ 64 различных конечных двойников; из них половина положительны, а примерно половина из тех <1.0.)

Но вы упомянули генераторы случайных чисел: обратите внимание, что генератор случайных чисел, генерирующий числа от 0,0 до 1,0 , не может в целом произвести все эти числа; обычно он выдает только числа в форме n / 2 ^ 53, где n - целое число (см., например, документацию Java для nextDouble ). Таким образом, обычно существует только около 2 ^ 53 (+/- 1, в зависимости от того, какие конечные точки включены) возможных значений для вывода random () . Это означает, что большинство двойников в [0.0, 1.0] никогда не будут сгенерированы.

В статье Новая математика Java, Часть 2: Числа с плавающей запятой от IBM предлагается следующий фрагмент кода для решения этой проблемы (в числах с плавающей запятой, но я подозреваю, что он работает для чисел с двойной точностью). а также):

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);
    }
}

У них есть такой комментарий по этому поводу:

Оказывается, есть ровно 8 388 609 чисел с плавающей запятой между 1.0 и 2.0 включительно; большое, но вряд ли бесчисленное множество действительных чисел, существующих в этом диапазоне. Последовательные числа разнесены примерно на 0,0000001. Это расстояние называется ULP для единицы наименьшей точности или последней единицы.

1. 2 ^ 53 - размер мантиссы / мантиссы 64-битного числа с плавающей запятой, включая скрытый бит.
2. Примерно да, поскольку sifnificand фиксируется, но показатель степени изменяется.

Дополнительную информацию см. В статье в Википедии .

Java double - это двоичное число IEEE 754.

Это означает, что нам нужно рассмотреть:

1. Мантисса - 52 бита
2. Экспонента - 11-битное число со смещением 1023 (т.е. с прибавлением к нему 1023)
3. Если экспонента равна 0, а мантисса не равна нулю, то число считается ненормализованным

Это означает, что существует 2^62-2^52+1 возможных представлений двойки, которые согласно стандарту находятся между 0 и 1. Обратите внимание, что 2^52+1 - это исключение случаев ненормализованных чисел.

Помните, что если мантисса положительна, а экспонента отрицательна, то число положительно, но меньше 1 :-)

Для других чисел это немного сложнее, потому что крайние целые числа не могут быть точно представлены в представлении IEEE 754, и потому что в экспоненте используются другие биты для представления чисел, поэтому чем больше число, тем меньше различных значений.