Lycée et prépa · Informatique
Les nombres de la machine
Un ordinateur range chaque nombre dans un nombre fixe de bits. Alors les entiers débordent, et les nombres à virgule sont arrondis : 0,1 + 0,2 ne fait pas tout à fait 0,3. Fais déborder un registre, décortique un nombre à virgule bit par bit, trouve les lois, puis refais le calcul d’une horloge qui a dérivé d’un tiers de seconde.
Les bits du registre (touche un bit pour le changer) :
L’opposé en complément à deux : inverser tous les bits, puis ajouter 1.
En Python, un int ne déborde jamais : il grandit autant que la mémoire le permet. Ce registre imite les entiers de taille fixe du processeur, du langage C ou de la carte Arduino (un int y fait 16 bits).
Valeur exactement stockée :
La machine (double, le float de Python)
Valeur exacte du résultat stocké :
Le calcul exact
L’horloge compte des dixièmes de seconde dans un entier. Pour avoir des secondes, on multiplie par 0,1, écrit en binaire avec un nombre fixe de chiffres après la virgule.
0,1 en binaire (en couleur, les chiffres gardés) :
Palier 1 · DécouvrirDes nombres de taille fixe
Un compteur qui fait le tour 2de
Un processeur range un entier dans un registre d’un nombre fixe de bits : 8, 16, 32 ou 64. Chaque bit vaut 0 ou 1, et chaque rang vaut le double de celui de sa droite. Avec 8 bits, il n’existe que 2⁸ = 256 combinaisons : pas une de plus.
Ton pronostic : sur 8 bits signés, que donne 127 + 1 ?
C’est noté. Vérifie sur le banc : Entiers, 8 bits, signé ; clique sur « max », puis sur « + 1 ».
- Sur le banc, choisis Entiers, 8 bits, signé. Clique sur « max » : le registre affiche 127, un 0 suivi de sept 1.
- Clique sur « + 1 ». Regarde les bits, puis la valeur.
- Passe en « non signé » : « max » vaut maintenant 255. Que donne 255 + 1 ?
- Touche les bits un par un pour composer d’autres nombres, et essaie 16 et 32 bits.
Sur 8 bits non signés, 255 + 1 donne…
256 s’écrit 100000000 : il faut un 9e bit. Le registre n’en a que 8. Que reste-t-il quand ce 9e bit tombe ?
Oui : 11111111 + 1 = 100000000, et le 9e bit tombe. En SNT, chaque couleur d’un pixel est codée ainsi sur 8 bits, de 0 à 255.
Le registre ne s’arrête pas au maximum : l’addition se fait en binaire, avec des retenues. Essaie sur le banc.
En signé, 11111111 vaut bien −1. Mais ici le registre est non signé : que valent alors 11111111, puis 11111111 + 1 ?
Et en Python ? Les entiers int de Python ne débordent jamais : 2**100 donne 1267650600228229401496703205376, exactement. Les entiers de taille fixe sont ceux du processeur et de langages comme le C ; sur la carte Arduino Uno, un int fait 16 bits.
0,1 + 0,2 2de
Les nombres à virgule sont rangés en « virgule flottante » : c’est le type float de Python, exactement le même que le type Number de JavaScript. Tous deux suivent la norme IEEE 754 sur 64 bits, qu’on appelle « double ». Un calcul très simple va te surprendre.
Ton pronostic : en Python, que renvoie le test 0.1 + 0.2 == 0.3 ?
C’est noté. Vérifie avec la calculette du banc : bouton « 0,1 + 0,2 ».
- Ouvre la Calculette du banc et choisis « 0,1 + 0,2 ». À gauche, ce que calcule la machine ; à droite, le calcul exact.
- Choisis « 0,1 dix fois » : la machine part de 0 et ajoute dix fois 0,1.
- Essaie « 0,5 + 0,25 » : cette fois, tout tombe juste. Pourquoi ? Le palier 2 répond.
Le flottant décortiqué 1re NSI
Ouvre Flottants et stocke 0,1. Le banc montre les 64 bits du double : 1 bit de signe, 11 bits d’exposant, 52 bits de mantisse. Juste dessous, la valeur vraiment stockée, écrite en entier.
D’après le banc, 0,1 est-il stocké exactement ?
Lis la ligne « Valeur exactement stockée » : après le 1, n’y a-t-il que des 0 ?
Exact : la machine garde 0,100 000 000 000 000 005 55…, le double le plus proche de 0,1. Stocke 0,5 : cette fois, c’est exact.
Palier 2 · ComprendreLes lois de la machine
Les badges comme 1re NSI disent où chaque notion se trouve dans les programmes. Ce n’est pas une limite : si tu as compris, continue.
0,1 en binaire : une écriture sans fin 1re NSI
En binaire, les chiffres après la virgule valent 1/2, 1/4, 1/8, 1/16… Ainsi 0,011 en binaire vaut 1/4 + 1/8 = 0,375. Pour écrire un nombre entre 0 et 1 en binaire, on le double : sa partie entière (0 ou 1) est le chiffre suivant, et on recommence avec ce qui reste après la virgule.
C’est comme 1/3 = 0,333… en décimal. Une fraction irréductible p/q s’écrit avec un nombre fini de chiffres binaires seulement si q est une puissance de 2 ; en décimal, il faut que q n’ait pas d’autres facteurs premiers que 2 et 5. Voilà pourquoi 0,1 = 1/10 est fini en décimal mais infini en binaire : la machine doit couper, donc arrondir.
Complète la règle.
Une fraction irréductible p/q a une écriture binaire finie si et seulement si q est . Donc 1/10 a une écriture binaire .
Il reste un trou à remplir.
6 est pair : 1/6 a-t-il une écriture binaire finie ? Le facteur 3 fait tourner le reste en rond, comme le 5 de 0,1.
1/10 a pour dénominateur 10, une puissance de 10. Convertis 0,1 ci-dessus : son écriture binaire s’arrête-t-elle ?
1/5 = 0,2 : son écriture binaire est 0,001100110011… et ne s’arrête jamais. Quels dénominateurs donnent une écriture finie ? Essaie 0,625 = 5/8.
Convertis 0,1 ci-dessus : le motif 0011 revient sans cesse.
C’est la règle : seuls les nombres de la forme entier/2ᵏ tombent juste en binaire.
Comparer avec la règle
p/q irréductible a une écriture binaire finie si et seulement si q est une puissance de 2. 0,1 = 1/10, et 10 = 2 × 5 : le facteur 5 rend l’écriture infinie. Toute fraction binaire finie est aussi un décimal fini (car 2 divise 10), mais pas l’inverse.
Le format double (IEEE 754, 64 bits) 1re NSI +
x = (−1)s × 1,m × 2e − 1023
- s
- le bit de signe : 0 pour +, 1 pour −.
- e
- l’exposant, un entier stocké sur 11 bits, de 1 à 2046 pour les nombres ordinaires. On lui retire 1023 : les puissances de 2 vont de 2⁻¹⁰²² à 2¹⁰²³. Les valeurs 0 et 2047 sont réservées (zéro, tout petits nombres, infinis).
- m
- la mantisse : les 52 bits après la virgule. Le 1 avant la virgule n’est pas stocké, puisqu’il est toujours là : cela fait 53 bits de précision.
Précision. 53 bits, c’est 53 × log₁₀ 2 ≈ 15,95 chiffres décimaux : un double retient 15 à 17 chiffres significatifs. Entre 1 et le double suivant, l’écart vaut 2⁻⁵² ≈ 2,2 × 10⁻¹⁶ ; entre deux doubles voisins, l’écart relatif est toujours entre 2⁻⁵³ et 2⁻⁵². Un entier est stocké exactement s’il s’écrit avec au plus 53 bits significatifs (les zéros de droite vont dans l’exposant).
Arrondi. Chaque opération (+, −, ×, ÷) calcule le résultat exact des deux nombres stockés, puis l’arrondit au double le plus proche. En cas d’égalité parfaite, elle choisit le double dont la mantisse finit par 0 : c’est l’arrondi « au pair ».
Simple précision (32 bits : 1 + 8 + 23) : 24 bits de précision, environ 7 chiffres, et l’exposant e − 127. Sur le banc, Flottants, choisis « simple ».
Combien de bits de précision a un double, en comptant le 1 qui n’est pas stocké ?
11 bits, c’est l’exposant : il dit où est la virgule, pas combien de chiffres on garde.
52 bits sont stockés, mais un 1 se trouve toujours devant la virgule sans être écrit : compte-le.
Oui : 1 + 52. C’est pour cela qu’un double garde environ 16 chiffres décimaux.
64 bits en tout, mais 12 servent au signe et à l’exposant.
Pourquoi 0,1 + 0,2 ne fait pas 0,3 1re NSI
La machine ne se trompe pas dans l’addition : elle ajoute exactement les deux nombres stockés, puis arrondit. Le souci vient d’avant : les trois nombres 0,1, 0,2 et 0,3 sont déjà arrondis quand on les tape.
La somme exacte tombe pile au milieu de deux doubles voisins, écartés de 2⁻⁵⁴ ≈ 5,6 × 10⁻¹⁷. L’arrondi au pair choisit celui du dessus. Or le double stocké pour 0,3 est celui du dessous : le test == répond False.
En simple précision (32 bits), le même test 0,1 + 0,2 == 0,3 donne…
Oui, et c’est un hasard : en 32 bits, la somme arrondie et 0,3 arrondi tombent sur le même flottant, 0,300 000 011 920 928 955 078 125. On ne peut donc pas prévoir si deux calculs arrondis seront égaux : on les compare avec une tolérance (palier 3).
Vérifie : Calculette, « 0,1 + 0,2 », et lis la dernière ligne, en simple précision.
Les entiers négatifs : le complément à deux 1re NSI
Sur n bits, le bit de gauche (le bit de poids fort) ne vaut pas +2ⁿ⁻¹ mais −2ⁿ⁻¹. Sur 8 bits, 10000000 vaut −128 et 11111111 vaut −128 + 127 = −1. Les valeurs vont de −2ⁿ⁻¹ à 2ⁿ⁻¹ − 1 : de −128 à 127 sur 8 bits, de −32 768 à 32 767 sur 16 bits.
Pour obtenir −x, on inverse tous les bits, puis on ajoute 1. Pourquoi ? x et x inversé, ajoutés, donnent 11…1, qui vaut −1 ; donc x inversé = −1 − x, et x inversé + 1 = −x. Sur le banc (Entiers), le bouton « Remplacer x par son opposé » montre les deux étapes.
L’intérêt : l’addition se fait de la même façon pour les entiers signés et non signés, avec le même circuit. Et le débordement s’explique : 32 767 s’écrit 0 suivi de quinze 1 ; en ajoutant 1, on obtient 1 suivi de quinze 0, qui vaut −32 768.
Complète.
Sur 8 bits en complément à deux, le bit de poids fort vaut , et on obtient −x en .
Il reste un trou à remplir.
Si le bit de gauche valait +128, 11111111 vaudrait 255 : c’est le codage non signé. En signé, ce bit compte en négatif.
C’est le codage « signe et valeur absolue », qui a deux zéros (00000000 et 10000000). En complément à deux, le bit de gauche a un vrai poids, négatif.
1, c’est le poids du bit de droite, le plus léger. Celui de gauche est le plus lourd.
Inverser seulement donne −x − 1 : 00000011 (3) devient 11111100, qui vaut −4. Il manque une étape.
10000011 vaut −128 + 3 = −125, pas −3 : c’est l’autre codage, pas le complément à deux.
C’est le complément à deux, utilisé par les processeurs actuels.
Comparer avec la règle
Sur n bits, le poids fort vaut −2ⁿ⁻¹, et −x = (x inversé) + 1. Exemple sur 8 bits : 3 = 00000011 → inversé 11111100 → + 1 → 11111101 = −3.
Palier 3 · Aller plus loinQuand les arrondis comptent
L’horloge du Patriot (Dhahran, 25 février 1991) cas réel
Le 25 février 1991, pendant la guerre du Golfe, une batterie de missiles Patriot chargée de défendre la base aérienne de Dhahran, en Arabie saoudite, n’a pas intercepté un missile Scud irakien. Le Scud a frappé un baraquement de l’armée américaine : 28 soldats ont été tués. Le rapport du GAO, l’organisme de contrôle rattaché au Congrès américain, publié le 4 février 1992, établit la cause : un problème logiciel dans le calcul du temps.
Ce que dit le rapport : l’horloge interne comptait le temps en dixièmes de seconde, dans un entier. Pour prévoir où chercher la cible, le calculateur convertissait ce temps en secondes avec des registres de 24 bits, et perdait de la précision ; l’erreur grandissait avec la durée de fonctionnement. La batterie tournait sans interruption depuis plus de 100 heures. Des données israéliennes avaient montré un décalage de 20 % de la « fenêtre de poursuite » (la zone où le radar cherche la cible) après 8 heures ; à 50 %, le système ne suit plus la cible.
Le détail du calcul a été publié par le mathématicien Robert Skeel en 1992 : 0,1 était écrit avec 23 chiffres binaires après la virgule, et les chiffres suivants étaient coupés. Sur le banc, ouvre Horloge, règle 23 chiffres et la troncature, et lis l’erreur commise à chaque dixième de seconde.
Le tableau du rapport (annexe II), et le banc
Le rapport précise qu’au-delà d’environ 20 heures, la cible sort de la fenêtre de poursuite. Le banc (23 chiffres, troncature) retrouve les quatre décimales du rapport, heure par heure. Un Scud vole à environ Mach 5, 3 750 miles par heure selon le rapport, soit environ 1 676 m/s : en un tiers de seconde, il parcourt plus de 500 m.
Pourquoi l’erreur ne s’est-elle pas annulée ? Pour suivre une cible, seule compte la durée entre deux échos radar : si les deux temps avaient la même erreur relative, elle aurait presque disparu dans la soustraction. Mais une routine de conversion plus précise avait été ajoutée à certains endroits du programme et pas à tous : un temps précis était soustrait d’un temps tronqué (Skeel, 1992). Le logiciel corrigé est arrivé à Dhahran le 26 février 1991, le lendemain ; redémarrer le système, ce qui remet l’horloge à zéro, effaçait aussi le décalage accumulé (rapport GAO).
Avec 23 chiffres arrondis au plus proche au lieu d’être coupés, le décalage après 100 heures aurait été…
Arrondir ne rend pas l’écriture de 0,1 finie : il reste une erreur. Essaie « arrondis au plus proche » sur le banc.
Oui : 0,1 × 2²³ = 838 860,8. Couper donne 838 860 (erreur 0,8 unité), arrondir donne 838 861 (erreur 0,2 unité, dans l’autre sens) : 4 fois moins, environ 0,086 s en 100 heures. Moins d’erreur, mais toujours pas zéro.
Compare sur le banc l’erreur par dixième dans les deux modes, avec 23 chiffres.
Des compteurs qui débordent cas réel
Un compteur de taille fixe finit toujours par déborder ; la vraie question est : quand ? Sur une carte Arduino, millis() compte les millisecondes depuis le démarrage dans un unsigned long, un entier non signé de 32 bits. Sa documentation prévient qu’il revient à zéro « après environ 50 jours ».
En 2015, l’autorité américaine de l’aviation civile (FAA) a imposé de couper régulièrement l’alimentation électrique des Boeing 787 : un compteur logiciel de leurs unités de contrôle des générateurs « déborde après 248 jours d’alimentation continue », ce qui pouvait couper toute l’alimentation en courant alternatif. Le texte ne précise pas le type du compteur ; on peut remarquer que 2³¹ centièmes de seconde font 248,55 jours.
Beaucoup de systèmes comptent le temps en secondes depuis le 1er janvier 1970 (le « temps Unix »). Dans un entier signé de 32 bits, ce compteur atteint son maximum, 2³¹ − 1, le 19 janvier 2038 à 3 h 14 min 7 s UTC ; une seconde plus tard, il vaudrait −2³¹, c’est-à-dire le 13 décembre 1901. Sur 64 bits, la limite recule d’environ 292 milliards d’années.
Un int de 16 bits signé compte les millisecondes. Il déborde au bout de…
2¹⁶ ms = 65,5 s : ce serait un entier non signé. Signé, il ne monte que jusqu’à 2¹⁵ − 1.
Oui : 32 767 ms, puis −32 768. C’est pourquoi millis() renvoie un entier de 32 bits : le laboratoire du microcontrôleur fait le même calcul.
16, c’est le nombre de bits, pas de secondes. Le plus grand int de 16 bits signé est 32 767.
Comparer deux flottants 1re NSI
Le programme de NSI de première le dit : « 0.2 + 0.1 n’est pas égal à 0.3. Il faut éviter de tester l’égalité de deux flottants. » On compare plutôt avec une tolérance, abs(x − y) < 1e-9, ou avec math.isclose(x, y) en Python. Et pour compter des tours, on prend un entier : for i in range(10).
Quel test dit le mieux si le flottant x « vaut » 0,3 ?
C’est justement le test qui échoue avec x = 0.1 + 0.2.
Oui : l’erreur d’arrondi est de l’ordre de 10⁻¹⁷, très loin sous 10⁻⁹. La tolérance se choisit selon le problème : très grande devant les arrondis, très petite devant les écarts qui comptent.
Il marche pour 0.1 + 0.2, mais il déclare aussi 0,26 égal à 0,3 : round(0.26, 1) == 0.3 donne True. Arrondir à une décimale, c’est une tolérance de 0,05 : bien trop grossière ici.
Une boucle qui avance par pas de 0,1 et doit s’arrêter « à 1 » cache un piège : une mission ★★★ te le fait trouver.
Tes missions
Voici les missions du palier choisi. Réponds, puis clique sur « Valider ma réponse ». Si ce n’est pas encore ça, un indice t’aide. Après trois essais, tu peux voir la solution.
Le savais-tu ?
Des faits vrais, avec les nombres qui les prouvent.
Les mots du module
Chaque mot, en une ou deux phrases.
- Bit, octet
- Un bit vaut 0 ou 1. Un octet est un groupe de 8 bits : 256 combinaisons.
- Registre
- Une petite mémoire du processeur, d’un nombre fixe de bits, où se font les calculs.
- Entier de taille fixe
- Un entier codé sur n bits : 2ⁿ valeurs possibles, pas une de plus. Les int de Python, eux, n’ont pas de taille fixe.
- Débordement
- Quand un résultat ne tient pas dans le registre : la machine garde les n bits de poids faible, et 32 767 + 1 devient −32 768 sur 16 bits.
- Complément à deux
- Le codage des entiers signés : le bit de poids fort vaut −2ⁿ⁻¹. On obtient −x en inversant les bits de x puis en ajoutant 1.
- Virgule flottante
- Un nombre écrit comme signe × mantisse × 2^exposant : la virgule « flotte » selon l’exposant, ce qui permet de ranger aussi bien 10⁻³⁰⁰ que 10³⁰⁰.
- Double, simple
- Les deux formats les plus courants de la norme IEEE 754 : 64 bits (53 bits de précision, le float de Python) et 32 bits (24 bits de précision).
- Mantisse, exposant
- La mantisse porte les chiffres significatifs (1,m) ; l’exposant dit par quelle puissance de 2 les multiplier. Il est stocké avec un décalage (1023 en double).
- Arrondi au plus proche
- La règle de la norme : chaque résultat est remplacé par le flottant le plus proche ; en cas d’égalité, par celui dont la mantisse finit par 0 (« au pair »).
- Troncature
- Couper les chiffres en trop au lieu d’arrondir. L’erreur est alors toujours du même côté, et s’accumule.
- Écart entre flottants voisins
- La distance d’un flottant au suivant (en anglais ulp, « unit in the last place »). En double, 2⁻⁵² à partir de 1, et 2 à partir de 2⁵³.
- Représentable
- Un nombre est représentable dans un format s’il y est stocké exactement. 0,5 l’est en double, 0,1 ne l’est pas.
- Virgule fixe
- Un nombre à virgule stocké comme un entier N avec un nombre fixe k de chiffres binaires après la virgule : il vaut N/2ᵏ. C’était le cas de l’horloge du Patriot.
- Tolérance
- L’écart en dessous duquel on considère deux flottants comme égaux : abs(x − y) < tolérance.
Pour les parents et les enseignantsouvrir
Objectifs
- Comprendre qu’un entier de taille fixe a 2ⁿ valeurs, et prévoir un débordement (8, 16, 32 bits, signé ou non).
- Coder un entier négatif en complément à deux et justifier la règle « inverser puis ajouter 1 ».
- Savoir quels nombres ont une écriture binaire finie (p/q avec q puissance de 2), et en déduire que 0,1 est arrondi.
- Lire un double : signe, exposant, mantisse, formule (−1)ˢ × 1,m × 2^(e − 1023) ; relier 53 bits de précision aux 15 à 17 chiffres significatifs et à 2⁵³.
- Expliquer 0,1 + 0,2 ≠ 0,3 par des données arrondies et un calcul correctement arrondi ; comparer des flottants avec une tolérance ; compter avec des entiers.
- Refaire un calcul d’ordre de grandeur sur un cas réel (l’horloge du Patriot) et sur des compteurs qui débordent.
Notions
Bit, octet, base 2, entier non signé et signé, complément à deux, débordement, type int et float de Python, virgule flottante, norme IEEE 754 (binary64 et binary32), signe, exposant biaisé, mantisse, précision, écart entre flottants voisins, arrondi au plus proche (au pair), troncature, virgule fixe, erreur relative, accumulation d’erreurs, tolérance.
Déroulé (20 à 30 minutes)
Palier 1 : faire déborder un registre, prédire puis tester 0,1 + 0,2 == 0,3, lire la valeur vraiment stockée. Palier 2 : les fractions binaires, le format double et sa précision, l’arrondi, le complément à deux. Palier 3 : l’horloge du Patriot, des compteurs qui débordent (Arduino, Boeing 787, temps Unix), les comparaisons de flottants.
Les pièges visés
Confondre 2¹⁵ et 2¹⁶ (ou 2³¹ et 2³²) ; oublier le bit de signe ; croire qu’un registre plein reste bloqué au maximum ; oublier le « + 1 » du complément à deux ou le confondre avec le codage signe et valeur absolue ; croire que l’addition de la machine est fausse, ou que seul l’affichage arrondit ; compter 52 bits de précision au lieu de 53 ; confondre les limites des entiers de 32 ou 64 bits avec celle des doubles ; confondre arrondi et troncature ; se tromper d’un facteur 10 entre secondes et dixièmes ; tester l’égalité de deux flottants. Les indices des missions repèrent ces erreurs.
Liens avec les programmes
- Mathématiques, seconde, programme de 2026 (arrêté du 26 février 2026, Bulletin officiel n° 14 du 2 avril 2026, p. 336-337), partie « Algorithmique et programmation », en Python : « Variables informatiques de type entier, booléen, flottant, chaine de caractères » ; « Choisir ou déterminer le type d’une variable (entier, flottant ou chaine de caractères) ». Texte relu dans le BO.
- SNT, seconde (arrêté du 17 janvier 2019, Bulletin officiel spécial n° 1 du 22 janvier 2019) : programmation en Python 3 ; thème « La photographie numérique » : « La profondeur de couleur est en général de 8 bits par pixel et par couleur » (des entiers de 0 à 255). Texte relu.
- NSI, première (arrêté du 17 janvier 2019, même BO) : « Représentation binaire d’un entier relatif » : « Utiliser le complément à 2 », « décrire les tailles courantes des entiers (8, 16, 32 ou 64 bits) », « évoquer la représentation des entiers de taille arbitraire de Python » ; « Représentation approximative des nombres réels : notion de nombre flottant » : « 0.2 + 0.1 n’est pas égal à 0.3. Il faut éviter de tester l’égalité de deux flottants. Aucune connaissance précise de la norme IEEE-754 n’est exigible. » Texte relu.
- Un cran au-dessus : le détail du format double (exposant biaisé, 53 bits, arrondi au pair, écart entre flottants voisins) dépasse la NSI, qui n’exige pas la norme ; il est au programme d’informatique commune des classes préparatoires scientifiques (arrêté du 5 janvier 2021, 1re année, second semestre : complément à deux, flottants), d’après le dossier de programmes du site, texte non relu ici. Les badges le signalent : ce n’est pas une limite.
À faire en vrai
Dans une console Python : tapez 0.1 + 0.2, puis 0.1 + 0.2 == 0.3, puis from decimal import Decimal et Decimal(0.1) pour voir la valeur stockée. Écrivez une boucle while x != 1.0: x = x + 0.1 en ajoutant un compteur de sécurité, et observez qu’elle ne s’arrête pas d’elle-même. Comparez avec 2**100 (int, exact) et 2.0**100 (float, arrondi).
Ce que le module simplifie
Le banc calcule avec les vrais types de JavaScript, qui sont exactement ceux de la norme IEEE 754 et des processeurs : les résultats de la machine ne sont pas simulés. La calculette exacte travaille en décimal exact (entiers de taille arbitraire). Le registre entier montre 8, 16 et 32 bits ; 64 bits suivent les mêmes règles. Les tout petits nombres (dénormalisés), les infinis et « NaN » sont à peine évoqués. Pour le Patriot, le banc reproduit l’erreur de conversion de 0,1 décrite par Skeel (1992) et retrouve les chiffres du rapport GAO ; il ne simule ni le radar ni la fenêtre de poursuite, dont le rapport donne seulement les déplacements.
Sources
Tous les nombres du module sont calculés par son modèle (modele.js), vérifié dans node, avec les types de JavaScript ; les affichages de Python ont été comparés à python3.
- IEEE (2019). IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2019. doi:10.1109/IEEESTD.2019.8766229.
- Ecma International (2025). ECMAScript 2025 Language Specification (ECMA-262, 16e édition), § 6.1.6.1 « The Number Type » : les valeurs binary64 de la norme IEEE 754-2019.
- Python Software Foundation. The Python Tutorial, chapitre « Floating-Point Arithmetic: Issues and Limitations » : « almost all platforms map Python floats to IEEE 754 binary64 “double precision” values ».
- Goldberg D. (1991). What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys 23(1) : 5–48. doi:10.1145/103162.103163.
- United States General Accounting Office (1992). Patriot Missile Defense: Software Problem Led to System Failure at Dhahran, Saudi Arabia, GAO/IMTEC-92-26, 4 février 1992 (dont l’annexe II). Lu dans la copie du PDF conservée par l’Internet Archive, le site du GAO refusant le téléchargement direct.
- Skeel R. (1992). Roundoff error and the Patriot missile. SIAM News 25(4) : 11, juillet 1992.
- Lions J.-L. et al. (1996). ARIANE 5 Flight 501 Failure, rapport de la commission d’enquête, Paris, 19 juillet 1996.
- Federal Aviation Administration (2015). Airworthiness Directive 2015-09-07, Boeing 787 (Federal Register 80 FR 24789, 1er mai 2015).
- Arduino. Language Reference, millis() : « This number will overflow (go back to zero), after approximately 50 days » ; type renvoyé unsigned long.
- Ministère de l’Éducation nationale. Programme de mathématiques de seconde, arrêté du 26 février 2026 (Bulletin officiel n° 14 du 2 avril 2026) ; programmes de SNT (seconde) et de NSI (première), arrêtés du 17 janvier 2019 (Bulletin officiel spécial n° 1 du 22 janvier 2019).