Combien de nombres doubles y a-t-il entre 0,0 et 1,0?

C'est quelque chose qui me préoccupe depuis des années, mais je n'ai jamais pris le temps de le demander auparavant.

De nombreux (pseudo) générateurs de nombres aléatoires génèrent un nombre aléatoire compris entre 0,0 et 1,0. Mathématiquement, il y a des nombres infinis dans cette plage, mais doublec'est un nombre à virgule flottante, et a donc une précision finie.

Les questions sont donc:

1. Combien de doublenombres y a-t-il entre 0,0 et 1,0?
2. Y a-t-il autant de nombres entre 1 et 2? Entre 100 et 101? Entre 10 ^ 100 et 10 ^ 100 + 1?

Remarque: si cela fait une différence, je suis particulièrement intéressé par la définition de Java double.

Les Java doublesont au format IEEE-754 , ils ont donc une fraction de 52 bits; entre deux puissances adjacentes quelconques de deux (dont une incluse et excluant la suivante), il y aura donc 2 à la 52e puissance doubles différentes (c'est-à-dire 4503599627370496 d'entre elles). Par exemple, c'est le nombre de doubles distincts entre 0,5 inclus et 1,0 exclus, et exactement ce nombre se situe également entre 1,0 inclus et 2,0 exclus, et ainsi de suite.

Compter doublesentre 0,0 et 1,0 est plus difficile que de le faire entre des puissances de deux, car il y a de nombreuses puissances de deux comprises dans cette gamme, et, aussi, on entre dans les questions épineuses des nombres dénormalisés. 10 des 11 bits des exposants couvrent la plage en question, donc, y compris les nombres dénormalisés (et je pense que quelques types de NaN), vous auriez 1024 fois le doubles entre les puissances de deux - pas plus que le 2**62total de toute façon . Hors dénormalisé & c, je crois que le décompte serait de 1023 fois 2**52.

Pour une plage arbitraire comme "100 à 100,1", c'est encore plus difficile car la limite supérieure ne peut pas être représentée exactement comme un double(n'étant pas un multiple exact d'une puissance de deux). En guise d'approximation pratique, puisque la progression entre les puissances de deux est linéaire, vous pourriez dire que ladite plage est 0.1 / 64la plage entre les puissances environnantes de deux (64 et 128), donc vous vous attendez à environ

(0.1 / 64) * 2**52

doubles distincts - ce qui revient à 7036874417766.4004... donner ou prendre un ou deux ;-).

Toute doublevaleur dont la représentation est comprise entre 0x0000000000000000et 0x3ff0000000000000se situe dans l'intervalle [0.0, 1.0]. C'est (2 ^ 62 - 2 ^ 52) valeurs distinctes (plus ou moins un couple selon que vous comptez les points finaux).

L'intervalle [1.0, 2.0] correspond aux représentations entre 0x3ff0000000000000et 0x400000000000000; c'est 2 ^ 52 valeurs distinctes.

L'intervalle [100,0, 101,0] correspond aux représentations entre 0x4059000000000000et 0x4059400000000000; c'est 2 ^ 46 valeurs distinctes.

Il n'y a pas de doubles entre 10 ^ 100 et 10 ^ 100 + 1 . Aucun de ces nombres n'est représentable en double précision, et il n'y a pas de doubles entre eux. Les deux nombres à double précision les plus proches sont:

99999999999999982163600188718701095...

et

10000000000000000159028911097599180...

D'autres ont déjà expliqué qu'il y a environ 2 ^ 62 doubles dans l'intervalle [0,0, 1,0].
(Pas vraiment surprenant: il y a près de 2 ^ 64 doubles finis distincts, de ceux -ci , la moitié sont positifs, et à peu près la moitié de ceux qui sont <1,0.)

Mais vous évoquez des générateurs de nombres aléatoires: notez qu'un générateur de nombres aléatoires générant des nombres compris entre 0,0 et 1,0 ne peut en général pas produire tous ces nombres; typiquement, il ne produira que des nombres de la forme n / 2 ^ 53 avec n un entier (voir par exemple la documentation Java pour nextDouble ). Il n'y a donc généralement qu'environ 2 ^ 53 (+/- 1, selon les points de terminaison inclus) des valeurs possibles pour la random()sortie. Cela signifie que la plupart des doubles dans [0.0, 1.0] ne seront jamais générés.

L'article Les nouvelles mathématiques de Java, Partie 2: Nombres à virgule flottante d'IBM propose l'extrait de code suivant pour résoudre ce problème (en flottants, mais je suppose que cela fonctionne également pour les doubles):

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

Ils ont ce commentaire à ce sujet:

Il s'avère qu'il y a exactement 8 388 609 flottants entre 1,0 et 2,0 inclus; grande mais à peine l'infini innombrable de nombres réels qui existent dans cette gamme. Les nombres successifs sont distants d'environ 0,0000001. Cette distance est appelée ULP pour l'unité de moindre précision ou unité en dernier lieu.

1. 2 ^ 53 - la taille de la significande / mantisse d'un nombre à virgule flottante de 64 bits, y compris le bit caché.
2. À peu près oui, car le sifnificand est fixe mais l'exposant change.

Voir l' article wikipedia pour plus d'informations.

Le double Java est un nombre binaire64 IEEE 754.

Cela signifie que nous devons considérer:

1. Mantissa est 52 bits
2. L'exposant est un nombre de 11 bits avec un biais de 1023 (c'est-à-dire avec 1023 ajouté)
3. Si l'exposant est tout 0 et que la mantisse est non nulle, alors le nombre est dit non normalisé

Cela signifie essentiellement qu'il y a un total de 2 ^ 62-2 ^ 52 + 1 de doubles représentations possibles qui, selon la norme, sont comprises entre 0 et 1. Notez que 2 ^ 52 + 1 consiste à supprimer les cas des non normalisés Nombres.

Rappelez-vous que si la mantisse est positive mais que l'exposant est négatif, le nombre est positif mais inférieur à 1 :-)

Pour les autres nombres, c'est un peu plus difficile car les nombres entiers de bord peuvent ne pas être représentables de manière précise dans la représentation IEEE 754, et parce qu'il y a d'autres bits utilisés dans l'exposant pour pouvoir représenter les nombres, donc plus le nombre est grand, plus le nombre est bas. les différentes valeurs.