De nombreuses réponses d'époques antérieures ont montré le résultat true
de 9007199254740992 === 9007199254740992 + 1
vérifier que 9 007 199 254 740 991 est l'entier maximum et sûr.
Et si nous continuons à faire de l'accumulation:
input: 9007199254740992 + 1 output: 9007199254740992 // expected: 9007199254740993
input: 9007199254740992 + 2 output: 9007199254740994 // expected: 9007199254740994
input: 9007199254740992 + 3 output: 9007199254740996 // expected: 9007199254740995
input: 9007199254740992 + 4 output: 9007199254740996 // expected: 9007199254740996
Nous avons pu découvrir que parmi les nombres supérieurs à 9 007 199 254 740 992 , seuls les nombres pairs sont représentables .
C'est une entrée pour expliquer comment fonctionne le format binaire 64 bits double précision . Voyons comment 9 007 199 254 740 992 peuvent être conservés (représentés) en utilisant ce format binaire.
Utiliser une version brève pour le démontrer à partir de 4 503 599 627 370 496 :
1 . 0000 ---- 0000 * 2^52 => 1 0000 ---- 0000.
|-- 52 bits --| |exponent part| |-- 52 bits --|
Sur le côté gauche de la flèche, nous avons la valeur de bit 1 , et un point de radix adjacent , puis en multipliant 2^52
, nous déplaçons à droite le point de radix de 52 pas, et il va jusqu'à la fin. Nous obtenons maintenant 4503599627370496 en binaire.
Maintenant, nous commençons à accumuler 1 à cette valeur jusqu'à ce que tous les bits soient mis à 1, ce qui équivaut à 9 007 199 254 740 991 en décimal.
1 . 0000 ---- 0000 * 2^52 => 1 0000 ---- 0000.
(+1)
1 . 0000 ---- 0001 * 2^52 => 1 0000 ---- 0001.
(+1)
1 . 0000 ---- 0010 * 2^52 => 1 0000 ---- 0010.
(+1)
.
.
.
1 . 1111 ---- 1111 * 2^52 => 1 1111 ---- 1111.
Maintenant, parce que dans le format binaire 64 bits à double précision , il alloue strictement 52 bits pour la fraction, il n'y a plus de bit à transporter pour ajouter un 1 de plus, donc ce que nous pouvons faire est de remettre tous les bits à 0, et manipuler la partie exposant:
|--> This bit is implicit and persistent.
|
1 . 1111 ---- 1111 * 2^52 => 1 1111 ---- 1111.
|-- 52 bits --| |-- 52 bits --|
(+1)
(radix point has no way to go)
1 . 0000 ---- 0000 * 2^52 * 2 => 1 0000 ---- 0000. * 2
|-- 52 bits --| |-- 52 bits --|
=> 1 . 0000 ---- 0000 * 2^53
|-- 52 bits --|
Maintenant, nous obtenons le 9 007 199 254 740 992 , et avec un nombre supérieur à celui-ci, ce que le format pourrait contenir est 2 fois la fraction , cela signifie maintenant que chaque 1 ajout sur la partie de la fraction est en fait égal à 2 addition, c'est pourquoi le double -le format binaire de précision 64 bits ne peut pas contenir de nombres impairs lorsque le nombre est supérieur à 9 007 199 254 740 992 :
(consume 2^52 to move radix point to the end)
1 . 0000 ---- 0001 * 2^53 => 1 0000 ---- 0001. * 2
|-- 52 bits --| |-- 52 bits --|
Ainsi, lorsque le nombre atteint plus de 9 007 199 254 740 992 * 2 = 18 014 398 509 481 984, seulement 4 fois la fraction pourrait être tenue:
input: 18014398509481984 + 1 output: 18014398509481984 // expected: 18014398509481985
input: 18014398509481984 + 2 output: 18014398509481984 // expected: 18014398509481986
input: 18014398509481984 + 3 output: 18014398509481984 // expected: 18014398509481987
input: 18014398509481984 + 4 output: 18014398509481988 // expected: 18014398509481988
Que diriez-vous du nombre entre [ 2 251 799 813 685 248 , 4 503 599 627 370 496 )?
1 . 0000 ---- 0001 * 2^51 => 1 0000 ---- 000.1
|-- 52 bits --| |-- 52 bits --|
La valeur de bit 1 après le point de radix est exactement 2 ^ -1. (= 1/2, = 0,5) Ainsi, lorsque le nombre est inférieur à 4 503 599 627 370 496 (2 ^ 52), il y a un bit disponible pour représenter les 1/2 fois l'entier :
input: 4503599627370495.5 output: 4503599627370495.5
input: 4503599627370495.75 output: 4503599627370495.5
Moins de 2 251 799 813 685 248 (2 ^ 51)
input: 2251799813685246.75 output: 2251799813685246.8 // expected: 2251799813685246.75
input: 2251799813685246.25 output: 2251799813685246.2 // expected: 2251799813685246.25
input: 2251799813685246.5 output: 2251799813685246.5
// If the digits exceed 17, JavaScript round it to print it.
//, but the value is held correctly:
input: 2251799813685246.25.toString(2)
output: "111111111111111111111111111111111111111111111111110.01"
input: 2251799813685246.75.toString(2)
output: "111111111111111111111111111111111111111111111111110.11"
input: 2251799813685246.78.toString(2)
output: "111111111111111111111111111111111111111111111111110.11"
Et quelle est la gamme disponible de partie exposant ? le format lui attribue 11 bits. Format complet de Wiki : (Pour plus de détails, veuillez y aller)
Donc, pour que la partie exposant soit 2 ^ 52, nous devons exactement définir e = 1075.