Quantos números duplos existem entre 0,0 e 1,0?

Isso é algo que está na minha mente há anos, mas nunca parei para perguntar antes.

Muitos geradores de números (pseudo) aleatórios geram um número aleatório entre 0,0 e 1,0. Matematicamente, existem números infinitos neste intervalo, mas doubleé um número de ponto flutuante e, portanto, tem uma precisão finita.

Então, as perguntas são:

1. Quantos doublenúmeros existem entre 0,0 e 1,0?
2. Existem tantos números entre 1 e 2? Entre 100 e 101? Entre 10 ^ 100 e 10 ^ 100 + 1?

Nota: se faz diferença, estou interessado na definição de Java doubleem particular.

Os Java doubles estão no formato IEEE-754 , portanto, eles têm uma fração de 52 bits; entre quaisquer duas potências adjacentes de dois (incluindo uma e exclusiva da próxima), haverá, portanto, 2 elevado à 52ª potência doubles diferentes (ou seja, 4503599627370496 deles). Por exemplo, esse é o número de doubles distintos entre 0,5 incluídos e 1,0 excluídos, e exatamente esse número também está entre 1,0 incluído e 2,0 excluídos e assim por diante.

Contar doublesentre 0,0 e 1,0 é mais difícil do que entre potências de dois, porque há muitas potências de dois incluídas nessa faixa e, também, entra-se nas questões espinhosas dos números desnormalizados. 10 dos 11 bits dos expoentes cobrem o intervalo em questão, então, incluindo números desnormalizados (e eu acho que alguns tipos NaN), você teria 1024 vezes o doubles entre potências de dois - não mais do que 2**62no total de qualquer maneira . Excluindo o desnormalizado etc., acredito que a contagem seria de 1.023 vezes 2**52.

Para um intervalo arbitrário como "100 a 100,1" é ainda mais difícil porque o limite superior não pode ser representado exatamente como a double(não sendo um múltiplo exato de qualquer potência de dois). Como uma aproximação útil, uma vez que a progressão entre as potências de dois é linear, você poderia dizer que o referido intervalo é o 0.1 / 64décimo do intervalo entre as potências circundantes de dois (64 e 128), então você esperaria cerca de

(0.1 / 64) * 2**52

distinto doubles - que vem para 7036874417766.4004... dar ou tirar um ou dois ;-).

Todo doublevalor cuja representação está entre 0x0000000000000000e 0x3ff0000000000000está no intervalo [0,0, 1,0]. São (2 ^ 62 - 2 ^ 52) valores distintos (mais ou menos um par, dependendo de você contar os pontos de extremidade).

O intervalo [1.0, 2.0] corresponde às representações entre 0x3ff0000000000000e 0x400000000000000; são 2 ^ 52 valores distintos.

O intervalo [100,0, 101,0] corresponde às representações entre 0x4059000000000000e 0x4059400000000000; são 2 ^ 46 valores distintos.

Não há duplos entre 10 ^ 100 e 10 ^ 100 + 1 . Nenhum desses números é representável em precisão dupla, e não há duplos que caiam entre eles. Os dois números de precisão dupla mais próximos são:

99999999999999982163600188718701095...

e

10000000000000000159028911097599180...

Outros já explicaram que existem cerca de 2 ^ 62 duplos no intervalo [0,0, 1,0].
(Não é realmente surpreendente: há quase 2 ^ 64 duplos finitos distintos; desses, metade são positivos, e cerca de metade deles são <1,0.)

Mas você menciona geradores de números aleatórios: observe que um gerador de números aleatórios gerando números entre 0,0 e 1,0 não pode em geral produzir todos esses números; normalmente, ele produzirá apenas números na forma n / 2 ^ 53 com n um inteiro (consulte, por exemplo, a documentação Java para nextDouble ). Portanto, geralmente há apenas cerca de 2 ^ 53 (+/- 1, dependendo de quais terminais estão incluídos) valores possíveis para a random()saída. Isso significa que a maioria dos duplos em [0,0, 1,0] nunca será gerado.

O artigo Nova matemática do Java, Parte 2: Números de ponto flutuante da IBM oferece o seguinte trecho de código para resolver isso (em flutuações, mas suspeito que funcione para duplos também):

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

Eles têm este comentário sobre isso:

Acontece que existem exatamente 8.388.609 flutuadores entre 1,0 e 2,0 inclusive; grande, mas dificilmente a infinidade incontável de números reais que existem nesta faixa. Os números sucessivos estão separados por cerca de 0,0000001. Essa distância é chamada de ULP para unidade de menor precisão ou unidade em último lugar.

1. 2 ^ 53 - o tamanho do significando / mantissa de um número de ponto flutuante de 64 bits incluindo o bit oculto.
2. Aproximadamente sim, pois o sifnificand é fixo, mas o expoente muda.

Veja o artigo da Wikipedia para mais informações.

O duplo Java é um número binário64 IEEE 754.

Isso significa que precisamos considerar:

1. Mantissa é de 52 bits
2. O expoente é um número de 11 bits com tendência de 1023 (ou seja, com 1023 adicionado a ele)
3. Se o expoente for todo 0 e a mantissa for diferente de zero então o número é dito não normalizado

Isso basicamente significa que há um total de 2 ^ 62-2 ^ 52 + 1 de possíveis representações duplas que, de acordo com o padrão, estão entre 0 e 1. Observe que 2 ^ 52 + 1 é para remover os casos do não normalizado números.

Lembre-se de que se a mantissa for positiva, mas o expoente for negativo, o número é positivo, mas menor que 1 :-)

Para outros números é um pouco mais difícil porque os números inteiros da borda podem não ser representados de maneira precisa na representação IEEE 754, e porque existem outros bits usados ​​no expoente para poder representar os números, portanto, quanto maior o número, menor os diferentes valores.