$course$/QCM de NSI/Première/Représentation des réelsReprésentation des nombres réels en machine, virgule fixe et
virgule flottante, norme IEEE 754, précision et erreurs
d'arrondi, conséquences pratiques sur les calculs.]]>Représentation des réels — Q01 : Type des réels en PythonQuel est le type Python utilisé pour représenter les
nombres à virgule ?]]>Les nombres flottants sont approchés. Pour des
calculs en précision arbitraire, Python propose le
module decimal (calculs en base 10 exacts) ou
fractions (rationnels exacts).]]>1.00.00truetrueabcnumber]]>Erreur : number n'est pas un type Python standard.]]>float]]>Bonne réponse : float (« nombre à virgule
flottante ») est le type Python pour les nombres
réels approchés. Par défaut, ils sont codés sur 64
bits selon la norme IEEE 754.]]>int]]>Erreur : int est le type des entiers en Python.]]>real]]>Erreur : real n'existe pas en Python (mais existe
dans certains autres langages comme Pascal).]]>Représentation des réels — Q02 : Notation scientifiqueL'écriture scientifique d'un nombre réel sépare un
réel en :]]>En base 2 (binaire), la notation scientifique s'écrit
m × 2ᵉ, avec une mantisse m entre 1 et 2
et un exposant e entier. C'est exactement ce que fait
la norme IEEE 754.]]>1.00.00truetrueabcUne fraction irréductible]]>Une fraction irréductible
(comme 3/7) est
une autre façon d'écrire
un rationnel, mais ce n'est
pas la notation scientifique
en base deux utilisée par
les flottants.]]>Une partie entière et une partie décimale]]>Erreur : c'est plutôt l'écriture habituelle en base
10. La notation scientifique factorise en mantisse
et exposant.]]>Un signe et une valeur absolue]]>Erreur : c'est une décomposition différente, qui
n'est pas spécifiquement scientifique.]]>Une mantisse (entre 1 et 10) et un exposant entier de 10]]>Bonne réponse : par exemple, 345{,}67 = 3{,}4567 \times 10^2.
La mantisse est 3{,}4567, l'exposant est 2.
C'est l'idée de base de la représentation à virgule
flottante (en base 2 pour les ordinateurs).]]>Représentation des réels — Q03 : Norme IEEE 754Que définit la norme IEEE 754 ?]]>Avant IEEE 754, chaque constructeur avait son propre
format flottant, un même calcul pouvait donner des
résultats différents selon la machine. La norme a
uniformisé tout cela.]]>1.00.00truetrueabcLa représentation binaire des nombres à virgule flottante (signe, exposant, mantisse)]]>Bonne réponse : la norme IEEE 754 (1985, révisée
en 2008 et 2019) standardise les formats de
flottants : simple précision (float, 32 bits),
double précision (double, 64 bits) et plus.
Pratiquement tous les processeurs respectent cette
norme.]]>La connectique des câbles réseau]]>Erreur : aucun rapport. Les normes IEEE de connectique
sont différentes (par exemple IEEE 802.3 pour
Ethernet).]]>Le format des adresses IP]]>Erreur : c'est plutôt la RFC 791 (et autres) qui
définit les adresses IP. IEEE 754 concerne les
réels.]]>Le format des fichiers PDF]]>Le format PDF est défini
par la spécification ISO
32000. Il n'a aucun lien
avec la norme IEEE 754,
qui concerne uniquement
les nombres flottants.]]>Représentation des réels — Q04 : Approximation des réelsPourquoi les réels stockés en machine sont-ils en général
des approximations plutôt que des valeurs exactes ?]]>C'est une limite fondamentale : aucun ordinateur,
quelle que soit sa puissance, ne peut représenter
exactement tous les réels. Il faut donc choisir un
compromis sur la précision et l'étendue.]]>1.00.00truetrueabcParce qu'il y a une infinité de nombres réels mais une mémoire finie]]>Bonne réponse : on ne peut représenter qu'un nombre
fini de valeurs en mémoire finie. La plupart des
réels (par exemple π, √2) doivent être
approchés. Même certains nombres « simples » comme
0{,}1 n'ont pas de représentation binaire finie.]]>Parce que les ordinateurs sont mal conçus]]>Erreur : ce n'est pas un défaut de conception, c'est
une nécessité mathématique.]]>Parce qu'il faut moins de mémoire]]>Erreur : c'est pour des raisons mathématiques
fondamentales, pas seulement d'optimisation.]]>Parce que les flottants sont plus rapides que les entiers]]>Erreur : les flottants sont en réalité plus lents
que les entiers sur la plupart des processeurs.]]>Représentation des réels — Q05 : Calcul flottant en PythonQue renvoie l'expression Python 0.1 + 0.2 ?]]>0{,}1 en binaire vaut
0{,}0001100110011\ldots (motif périodique infini).
L'arrondi à un nombre fini de bits crée une petite
erreur, qui se propage dans les calculs.]]>1.00.00truetrueabcUne erreur Python]]>Erreur : aucune erreur, le calcul est valide. Mais
son résultat n'est pas exactement 0{,}3.]]>Exactement 0{,}3]]>Erreur : 0{,}1 et 0{,}2 n'ont pas de
représentation binaire finie (comme 1/3 en
base 10). Leur somme contient donc une erreur
d'arrondi.]]>0{,}29999\ldots (sans aucune erreur)]]>Erreur : la valeur exacte stockée est légèrement supérieure à 0{,}3, pas inférieure.]]>Une valeur très proche de 0{,}3, mais avec une petite erreur d'arrondi (par exemple 0{,}30000000000000004)]]>Bonne réponse : c'est l'exemple emblématique des
pièges du calcul flottant. Pour comparer des
flottants, on utilise typiquement
abs(a - b) < epsilon.]]>Représentation des réels — Q06 : Comparer deux flottantsPour tester si deux flottants a et b sont « égaux »
en Python, la bonne pratique est :]]>Cette précaution est essentielle dans tous les calculs
scientifiques. Les comparaisons strictes de flottants
sont une source classique de bugs subtils.]]>1.00.00truetrueabca == b]]>Erreur : à cause des erreurs d'arrondi, deux
flottants qui devraient être égaux peuvent
légèrement différer. == est trop strict.]]>int(a) == int(b)]]>Erreur : on perd la partie décimale. Et de plus, le
test est trop large (deux flottants très différents
peuvent donner le même entier après troncature).]]>abs(a - b) < epsilon avec epsilon petit (par exemple 10⁻⁹)]]>Bonne réponse : on compare à une tolérance
arbitraire. Le choix d'epsilon dépend du contexte.
Python propose aussi math.isclose(a, b) avec des
tolérances par défaut sensées.]]>a is b]]>Erreur : is teste l'identité (même objet en
mémoire), pas l'égalité numérique. Ne fonctionnera
presque jamais avec des flottants.]]>Représentation des réels — Q07 : Virgule fixeQuelle est la différence entre une représentation à virgule fixe et une représentation à virgule
flottante ?]]>Cas typique de virgule fixe : la finance, où on
manipule des montants à deux décimales, et on veut
éviter les erreurs d'arrondi sur l'argent. On stocke
alors les montants en centimes (entiers).]]>1.00.00truetrueabcLa virgule fixe a un nombre de chiffres fractionnaires constant ; la virgule flottante a une précision relative]]>Bonne réponse : avec virgule fixe, par exemple
deux décimales, on peut représenter 0{,}01 à
9999{,}99. Avec virgule flottante, l'exposant
permet d'aller de très petit (10⁻³⁰⁰) à très
grand (10³⁰⁰), au prix d'une précision relative.]]>La virgule fixe n'existe que sur les vieux ordinateurs]]>Erreur : la virgule fixe est encore utilisée
aujourd'hui (par exemple en finance pour des
montants en centimes).]]>Aucune différence en pratique]]>Erreur : les différences sont importantes,
notamment pour des applications spécifiques.]]>La virgule fixe est plus précise pour les très grands nombres]]>Erreur : c'est plutôt la virgule flottante qui gère
mieux les très grands ou très petits nombres
(grâce à l'exposant variable).]]>Représentation des réels — Q08 : Taille d'un float PythonEn Python, sur combien de bits est stocké un float ?]]>Pour des besoins de précision supérieure, Python
propose le module decimal (précision arbitraire en
base 10) et fractions (rationnels exacts).]]>1.00.00truetrueabc128 bits]]>Erreur : la quadruple précision (128 bits) existe
mais n'est pas le standard de Python.]]>64 bits]]>Bonne réponse : Python utilise par défaut la double
précision IEEE 754, soit 64 bits (1 pour le
signe, 11 pour l'exposant, 52 pour la mantisse).
Cela donne environ 15 à 17 chiffres décimaux
significatifs.]]>8 bits]]>Erreur : trop peu pour représenter une plage utile
de réels.]]>32 bits]]>Erreur : c'est la simple précision (le type
float du langage C). Python utilise par défaut la
double précision.]]>Représentation des réels — Q09 : Valeurs spéciales IEEE 754La norme IEEE 754 définit quelques valeurs spéciales
en plus des nombres réguliers. Lesquelles ?]]>En Python : float('inf'), float('-inf'),
float('nan'). Le test nan == nan renvoie False
(selon la norme), ce qui peut surprendre.]]>1.00.00truetrueabcAucune valeur spéciale]]>Erreur : les valeurs spéciales sont une partie
essentielle de la norme.]]>+∞, -∞, et NaN (« Not a Number »)]]>Bonne réponse : ces valeurs gèrent les opérations
extrêmes. 1/0 donne +∞, √-1 ou
0/0 donnent NaN. Cela évite les plantages et
permet des calculs plus robustes.]]>π, e, √2]]>Erreur : ces nombres sont représentés comme tout
autre flottant, par approximation. Ils n'ont pas de
valeur spéciale dédiée.]]>Vrai et Faux]]>Erreur : ce sont des valeurs booléennes, pas
flottantes.]]>Représentation des réels — Q10 : Composantes d'un flottant IEEE 754Quels sont les trois champs qui composent la
représentation IEEE 754 d'un nombre flottant ?]]>Pour un flottant 64 bits (double précision) :
1 bit de signe + 11 bits d'exposant +
52 bits de mantisse = 64 bits.]]>1.00.00truetrueabcPartie entière, partie décimale, partie complexe]]>Erreur : ce serait une décomposition mathématique,
pas la représentation IEEE 754.]]>Numérateur, dénominateur, exposant]]>Erreur : aucun rapport avec une fraction. La
mantisse n'est pas un dénominateur.]]>Octets supérieurs, médians, inférieurs]]>Erreur : c'est une découpe physique, pas la
décomposition logique.]]>Bit de signe, exposant biaisé, mantisse (fraction)]]>Bonne réponse : le bit de signe (0 pour positif,
1 pour négatif), l'exposant codé avec un biais
(pour permettre des exposants négatifs sans bit de
signe séparé), et la mantisse normalisée.]]>Représentation des réels — Q11 : Erreur d'arrondi cumulativeQue peut-il se passer si on additionne plusieurs millions
de petits flottants entre eux ?]]>Un exemple frappant : sum([0.1] * 10) en Python ne
donne pas exactement 1{,}0, à cause des erreurs
cumulées. Pour des calculs financiers, on utilise
decimal ; pour des sommes scientifiques, des
algorithmes spécialisés.]]>1.00.00truetrueabcLe résultat est exact, comme une somme d'entiers]]>Erreur : chaque addition introduit une petite erreur
d'arrondi. Sur des millions d'opérations, ces
erreurs s'accumulent.]]>Le calcul devient infiniment lent]]>Erreur : la vitesse n'est pas l'enjeu. C'est la
précision qui se dégrade.]]>Python lève une erreur de précision]]>Erreur : aucune erreur n'est levée. Les calculs
flottants sont silencieusement approximatifs.]]>Les erreurs d'arrondi peuvent s'accumuler et donner un résultat sensiblement différent du résultat mathématique exact]]>Bonne réponse : c'est un piège classique en calcul
scientifique. Pour minimiser les erreurs, on peut
additionner par ordre croissant (somme de Kahan)
ou utiliser une précision étendue.]]>Représentation des réels — Q12 : DépassementQue renvoie en Python l'opération 1e308 * 10 (où
1e308 désigne 10³⁰⁸) ?]]>Le fait que les calculs flottants ne plantent pas, mais
donnent des valeurs spéciales (inf, nan), permet de
poursuivre les calculs sans interruption. Mais
attention à ne pas oublier de vérifier ces valeurs si
elles peuvent affecter le résultat.]]>1.00.00truetrueabc10³⁰⁹]]>Erreur : 10³⁰⁹ dépasse la plage des doubles
précision (limite vers 1{,}8 \times 10^{308}).
Le résultat est donc une valeur spéciale.]]>inf]]>Bonne réponse : on dépasse le maximum représentable
en double précision. La norme IEEE 754 traduit
cela par +inf (infini positif). C'est un
dépassement (overflow) flottant.]]>Une erreur de Python]]>Erreur : aucune erreur, c'est un comportement
défini par la norme.]]>0]]>Erreur : ce serait un underflow (sous-dépassement
vers zéro), pas un dépassement par le haut.]]>Représentation des réels — Q13 : Précision en double précisionCombien de chiffres décimaux significatifs un flottant
en double précision (64 bits) peut-il représenter
de manière fiable ?]]>Pour des besoins supérieurs (cosmologie, cryptographie,
mathématiques précises), on utilise des bibliothèques
de précision arbitraire (mpfr, decimal, etc.) qui
acceptent un coût de performance.]]>1.00.00truetrueabcUne infinité]]>Erreur : aucune représentation finie ne peut donner
une infinité de chiffres exacts.]]>Environ 50]]>Erreur : très excessif. La double précision ne
dépasse pas 17 chiffres décimaux fiables.]]>Environ 15 à 17]]>Bonne réponse : avec 52 bits de mantisse, on a
\log_{10}(2^{52}) \approx 15{,}65 chiffres
significatifs. Au-delà, on n'a plus aucune garantie
de précision.]]>Environ 7]]>Erreur : c'est la précision de la simple précision
(32 bits, mantisse 23 bits). En double précision,
on a plus.]]>Représentation des réels — Q14 : math.iscloseEn Python, la fonction math.isclose(a, b) :]]>Cette fonction (introduite en Python 3{,}5) est la
bonne pratique recommandée pour comparer des flottants.
Elle est plus robuste que abs(a - b) < epsilon car
elle prend en compte l'ordre de grandeur des
nombres comparés.]]>1.00.00truetrueabcConvertit a et b en chaînes de caractères]]>Erreur : aucune conversion en chaîne.]]>Compare deux flottants en tolérant une petite différence relative et/ou absolue]]>Bonne réponse : math.isclose(a, b) utilise par
défaut une tolérance relative de 10⁻⁹ et une
tolérance absolue de 0. On peut les ajuster avec
rel_tol et abs_tol.]]>Renvoie toujours True]]>Erreur : elle teste vraiment l'égalité approximative.]]>Lève une erreur si les nombres ne sont pas exactement égaux]]>Erreur : c'est plutôt une fonction tolérante.]]>Représentation des réels — Q15 : Calcul financierPour un calcul financier (additionner des centimes),
quel choix est le plus prudent en Python ?]]>Les régulations financières interdisent souvent
l'usage de float pour des montants. La précision
doit être garantie au centième. Les bibliothèques
financières sérieuses utilisent toujours decimal ou
l'équivalent.]]>1.00.00truetrueabcUtiliser des float]]>Erreur : les flottants accumulent des erreurs
d'arrondi qui peuvent fausser des montants en
centimes. Mauvaise pratique financière.]]>Utiliser des nombres complexes]]>Erreur : aucun rapport avec les nombres complexes.]]>Utiliser le module decimal ou des entiers représentant des centimes]]>Bonne réponse : le module decimal calcule en
base 10 exactement (pas d'erreur d'arrondi pour
0{,}1). Alternative : stocker les montants en
centimes (entiers), sans virgule.]]>Utiliser des chaînes de caractères]]>Erreur : on ne peut pas faire d'arithmétique
directement sur des chaînes en Python.]]>Représentation des réels — Q16 : Conversion entier vers flottantEn Python, l'instruction float(7) renvoie :]]>Inversement, int(7.9) renvoie 7 (troncature, pas
arrondi). Pour arrondir, on utilise round(7.9) qui
renvoie 8.]]>1.00.00truetrueabc7 (entier inchangé)]]>Erreur : la fonction float change le type. Le
résultat est 7.0, qui est un flottant.]]>7.0 (flottant)]]>Bonne réponse : la conversion d'un entier en
flottant ajoute « .0 ». Le type passe de int à
float.]]>Une erreur]]>Erreur : aucune erreur, c'est une conversion
standard.]]>'7' (chaîne de caractères)]]>Erreur : float() convertit en flottant, pas en
chaîne. Pour une chaîne, on utiliserait str(7).]]>Représentation des réels — Q17 : Perte de significationPourquoi (1e16 + 1) - 1e16 donne-t-il 0 en Python
au lieu de 1 ?]]>Pour éviter ce piège : reformuler les calculs pour
éviter de soustraire des nombres très proches, ou
passer en précision étendue. C'est un problème
classique du calcul numérique scientifique.]]>1.00.00truetrueabcParce que 1 est négligeable face à 10¹⁶, la mantisse ne peut pas représenter cette différence avec sa précision limitée]]>Bonne réponse : la double précision a environ 16
chiffres significatifs. Quand on ajoute 1 à
10¹⁶, le 1 est « écrasé » par les erreurs
d'arrondi. C'est la perte de signification
(loss of significance).]]>Parce que Python ne sait pas additionner]]>Erreur : Python sait additionner. La limitation
vient du format de représentation des flottants.]]>Parce que les nombres trop grands sont arrondis à zéro]]>Erreur : ce n'est pas l'arrondi à zéro, c'est plus
subtil : c'est la précision relative limitée.]]>C'est un bug de Python]]>Erreur : ce n'est pas un bug, c'est un comportement
attendu et défini par IEEE 754.]]>Représentation des réels — Q18 : Forme normaliséeEn IEEE 754, un flottant normalisé s'écrit dans la
forme :]]>Cette astuce du « bit implicite » offre un bit gratuit
dans la mantisse. Pour les très petits nombres (proches
de zéro), on a aussi des nombres dénormalisés où
cette convention ne s'applique pas, permettant une
précision graduelle vers zéro.]]>1.00.00truetrueabc0{,}m \times 2^e avec m quelconque]]>Erreur : la forme normalisée a une mantisse
comprise entre 1 et 2, pas entre 0 et 1.]]>1{,}m \times 2^e avec un bit implicite à 1 devant la mantisse]]>Bonne réponse : la mantisse est toujours au format
1{,}\text{xxx} en binaire (puisque le premier bit
d'un nombre non nul vaut 1). On stocke seulement
la partie après la virgule, gagnant ainsi un bit
de précision « gratuit ».]]>m × 10ᵉ avec m et e entiers]]>Erreur : la base est 2, pas 10. Et la mantisse
n'est pas toujours entière.]]>m + e (somme)]]>Erreur : la mantisse et l'exposant ne s'additionnent
pas, ils se combinent par produit (m × 2ᵉ).]]>Représentation des réels — Q19 : Non-associativité de l'addition flottanteEn arithmétique flottante, l'addition est-elle toujours associative (c'est-à-dire (a + b) + c = a + (b + c)) ?]]>Cette non-associativité a des implications concrètes :
en parallélisme, des sommes massives peuvent donner
des résultats légèrement différents selon l'ordre de
réduction. En science du calcul, on cherche des
algorithmes qui minimisent cette dépendance.]]>1.00.00truetrueabcCela dépend du système d'exploitation]]>Erreur : pas de lien avec le système.]]>Cela dépend du langage de programmation]]>Erreur : c'est une propriété de la norme IEEE 754,
indépendante du langage.]]>Non, l'ordre des additions peut changer le résultat à cause des arrondis]]>Bonne réponse : par exemple,
(1e16 + 1) - 1e16 = 0 mais (1e16 - 1e16) + 1 = 1.
Ce détail est crucial en programmation parallèle :
additionner dans un ordre différent peut donner un
résultat différent.]]>Oui, comme pour les entiers]]>Erreur : c'est une croyance répandue mais fausse !
À cause des arrondis, l'ordre des additions peut
changer le résultat.]]>Représentation des réels — Q20 : Décimal vs binairePourquoi 0{,}5 a une représentation binaire exacte,
mais pas 0{,}1 ?]]>C'est l'analogue de 1/3 = 0{,}333\ldots en base 10.
Toute base privilégie certaines fractions et en
désavantage d'autres. Le calcul en base 10 (decimal)
résout ce problème pour les nombres décimaux humains.]]>1.00.00truetrueabcParce que 0{,}5 est plus grand que 0{,}1]]>Erreur : aucune raison liée à la taille relative.]]>Parce que 0{,}5 est utilisé plus souvent]]>Erreur : la fréquence d'usage n'a rien à voir avec
la représentabilité.]]>Parce que 0{,}5 a un seul chiffre, 0{,}1 aussi]]>Erreur : c'est en base 10. En binaire, la
longueur des deux écritures est très différente.]]>Parce que 0{,}5 = 1/2 = 2^{-1} est une puissance de 2, alors que 0{,}1 = 1/10 ne l'est pas et donne un développement périodique en binaire]]>Bonne réponse : en base 2, seules les fractions
dont le dénominateur est une puissance de 2
(ou des sommes de telles fractions) ont une
représentation finie. Pour 1/10, on obtient
0{,}0001100110011\ldots_2, périodique infini.]]>Représentation des réels — Q21 : Exposant biaiséPourquoi l'exposant en IEEE 754 est-il stocké avec un biais (par exemple, +1023 pour la double précision) ?]]>Le biais 1023 pour la double précision est choisi
pour avoir des exposants codés de 0 à 2046
(l'exposant réel va de -1022 à +1023). Les
valeurs 0 et 2047 sont réservées aux dénormalisés
et aux infinis/NaN.]]>1.00.00truetrueabcPour simplifier la comparaison entre deux flottants en utilisant la comparaison entière standard]]>Bonne réponse : avec un biais, l'exposant est
stocké comme un entier non signé. Cela permet de
comparer deux flottants positifs comme s'ils
étaient des entiers, ce qui simplifie le matériel
de comparaison.]]>Pour respecter une convention historique sans intérêt technique]]>Erreur : il y a une raison technique précise : la
comparaison rapide.]]>Parce que les processeurs ne savent pas gérer les nombres négatifs]]>Erreur : les processeurs gèrent très bien les
nombres signés. Le biais est un choix de design
pour optimiser les comparaisons.]]>Pour économiser de la mémoire]]>Erreur : le biais ne change pas la quantité de
mémoire utilisée (toujours 11 bits pour
l'exposant en double précision).]]>Représentation des réels — Q22 : Nombres dénormalisésQuand utilise-t-on des nombres dénormalisés en
IEEE 754 ?]]>Les dénormalisés peuvent ralentir les processeurs
(parfois beaucoup), au point que certaines applications
les désactivent (option « flush to zero »). C'est un
compromis subtil entre précision et performance.]]>1.00.00truetrueabcPour les très grands nombres]]>Erreur : c'est l'inverse. Les très grands nombres
utilisent l'exposant maximal, pas le minimal.]]>Pour les valeurs spéciales comme NaN]]>Erreur : NaN et infinis utilisent une combinaison
d'exposant maximal et de mantisse particulière, pas
les dénormalisés.]]>Pour les calculs en simple précision]]>Erreur : les dénormalisés existent dans toutes les
précisions IEEE 754.]]>Pour les nombres très proches de zéro, plus petits que le plus petit nombre normalisé représentable]]>Bonne réponse : les dénormalisés permettent une
transition graduelle vers zéro (au lieu d'un saut
brutal). Cela améliore la précision pour les
calculs sur de très petites valeurs, au prix d'une
précision dégradée.]]>Représentation des réels — Q23 : Propagation des erreursQuel calcul est numériquement instable parmi les
suivants ?]]>Exemple classique : la formule du discriminant pour
les racines de l'équation du second degré donne des
résultats catastrophiques quand le discriminant est
petit. On utilise alors une forme reformulée
mathématiquement équivalente mais numériquement
stable.]]>1.00.00truetrueabca - b quand a et b sont très proches (annulation catastrophique)]]>Bonne réponse : si a et b sont très proches,
leur différence a beaucoup moins de chiffres
significatifs que a ou b. Les erreurs d'arrondi
deviennent dominantes par rapport au résultat.]]>a + b pour a et b de même signe]]>Erreur : l'addition de mêmes signes ne pose pas
de problème de soustraction catastrophique.]]>a × b pour a et b proches de 1]]>Erreur : la multiplication n'a pas ce type
d'instabilité, sauf cas extrêmes (overflow).]]>a / b quand b est grand]]>Erreur : ce serait plutôt un problème quand b
est très petit (proche de 0).]]>Représentation des réels — Q24 : decimal vs floatEn Python, quelle est la principale différence entre les
modules decimal et le type float ?]]>Cette dualité reflète un compromis universel : float
offre la rapidité (calcul en hardware), decimal
offre la précision exacte (calcul logiciel). Le bon
choix dépend du contexte applicatif.]]>1.00.00truetrueabcdecimal calcule en base 10 avec une précision configurable, donc sans erreur d'arrondi pour les nombres décimaux humains]]>Bonne réponse : Decimal('0.1') + Decimal('0.2')
donne exactement Decimal('0.3'). C'est essentiel
pour la finance, mais le coût en performance est
significatif (typiquement 10 à 100 fois plus
lent).]]>decimal utilise moins de mémoire]]>Erreur : c'est plutôt l'inverse. La précision
configurable consomme plus de mémoire.]]>decimal est plus rapide]]>Erreur : decimal est en réalité plus lent que
float. Le bénéfice est ailleurs.]]>decimal ne fonctionne qu'avec des entiers]]>Erreur : decimal est précisément destiné aux
nombres décimaux non entiers.]]>Représentation des réels — Q25 : Synthèse sur les flottantsParmi les énoncés suivants, lequel est vrai sur les
nombres flottants en machine ?]]>Connaître les flottants permet d'éviter des bugs
subtils mais critiques dans les calculs scientifiques,
financiers, et même dans des programmes ordinaires
qui manipulent des nombres réels.]]>1.00.00truetrueabcLa précision des flottants augmente avec la taille du nombre]]>Erreur : la précision relative est constante,
mais l'erreur absolue augmente avec la taille
du nombre. Plus un nombre est grand, plus l'écart
entre deux flottants consécutifs est grand.]]>Les calculs flottants sont aussi précis que les calculs sur papier]]>Erreur : on a vu de nombreux contre-exemples
(associativité, perte de signification, etc.). Les
calculs flottants sont approchés.]]>Le test d'égalité == entre flottants est souvent piégeur, et il vaut mieux comparer avec une tolérance]]>Bonne réponse : c'est l'enseignement le plus
pratique de tout ce chapitre. À cause des erreurs
d'arrondi, deux flottants qui devraient être égaux
peuvent légèrement différer. Toujours préférer
math.isclose ou une comparaison à epsilon.]]>Les flottants peuvent représenter exactement tous les nombres rationnels]]>Erreur : la plupart des rationnels (par exemple
1/3, 1/10) n'ont pas de représentation finie
en binaire. Seul un sous-ensemble fini est
exactement représenté.]]>Représentation des réels — Q26 : Conversion décimal vers binaire avec virguleQuelle est l'écriture binaire de 6{,}625 ?]]>Méthode pour la partie fractionnaire : on multiplie par 2
et on note la partie entière du résultat (bit 0 ou 1),
puis on continue avec la partie fractionnaire restante,
jusqu'à obtenir 0 ou repérer un cycle. Pour 0{,}625, on
obtient 0{,}101_2 exactement, car 0{,}625 = 0{,}5 + 0{,}125
= 2^{-1} + 2^{-3}.]]>1.00.00truetrueabc1010{,}11]]>Erreur : 1010₂ = 10, pas 6. Confusion sur la partie
entière : 6 = 4 + 2 = 110₂.]]>110{,}625]]>Erreur : on a juxtaposé l'écriture décimale de la partie
fractionnaire à la partie entière en binaire. La partie
décimale doit elle aussi être convertie en base 2.]]>110{,}11]]>Erreur : la partie décimale 0{,}625 ne se code pas sur
deux bits. On a 0{,}11_2 = 0{,}5 + 0{,}25 = 0{,}75, ce
qui ne correspond pas à 0{,}625.]]>110{,}101]]>Bonne réponse : la partie entière donne 6 = 110₂. La
partie fractionnaire se calcule par multiplications
successives par 2 : 0{,}625 \times 2 = 1{,}25 (bit
1), puis 0{,}25 \times 2 = 0{,}5 (bit 0), puis
0{,}5 \times 2 = 1{,}0 (bit 1). On obtient
0{,}101_2, d'où 110{,}101_2.]]>Représentation des réels — Q27 : Décimal sans écriture binaire finieParmi les réels suivants (écrits en base 10), lequel n'a pas une écriture finie en base 2 ?]]>Un nombre décimal p/q irréductible a une
écriture binaire finie si et seulement si q est une
puissance de 2. Pour 0{,}1 = \dfrac{1}{10},
q = 10 = 2 × 5 contient un facteur 5, ce qui
provoque le caractère infini en base 2. Cette
observation explique pourquoi tant de calculs simples en
apparence (0{,}1 + 0{,}2) deviennent imprécis sur
machine.]]>1.00.00truetrueabc0{,}1]]>Bonne réponse : 0{,}1 ne s'exprime pas comme une somme
finie de puissances négatives de 2. Son écriture
binaire est périodique :
0{,}0001100110011\ldots_2. C'est précisément la cause
de l'écart entre 0.1 + 0.2 et 0.3 en flottant.]]>0{,}75]]>Erreur : 0{,}75 = 0{,}5 + 0{,}25 = 2^{-1} + 2^{-2},
donc son écriture binaire est 0{,}11_2, finie sur
deux bits.]]>0{,}25]]>Erreur : 0{,}25 = 2^{-2}, donc son écriture binaire est
0{,}01_2, finie sur deux bits.]]>0{,}5]]>Erreur : 0{,}5 = 2^{-1}, donc son écriture binaire est
0{,}1_2, finie sur un seul bit fractionnaire.]]>Représentation des réels — Q28 : Exposant biaisé en simple précisionLe réel 5{,}5 s'écrit en notation scientifique binaire
5{,}5 = 1{,}011_2 \times 2^{2}. Quel est son exposant biaisé sur huit bits, tel qu'il sera stocké en simple
précision (norme IEEE 754) ?]]>Le biais (127 en simple précision, 1023 en double
précision) sert à coder à la fois les exposants positifs et
négatifs sur un champ non signé. La formule de décodage est
symétrique : valeur lue E → exposant réel
e = E - \text{biais}. Pour la simple précision, les
exposants stockés vont de 0 à 255, ce qui donne des
exposants réels de -127 à 128 (avec les valeurs
extrêmes réservées pour les cas particuliers).]]>1.00.00truetrueabc2]]>Erreur : 2 est l'exposant réel (e), pas l'exposant
stocké. La norme IEEE 754 stocke e + 127 pour la
simple précision afin de représenter tous les exposants
(positifs et négatifs) sur des bits non signés.]]>125]]>Erreur : on a soustrait le biais (2 - 127 = -125,
changement de signe) au lieu de l'ajouter. Pour stocker l'exposant, on calcule e + 127, pas
e - 127.]]>130]]>Erreur de calcul : 2 + 127 = 129, pas 130. Vérifier
la somme.]]>129]]>Bonne réponse : en simple précision, le biais est de
127. L'exposant stocké est e + 127 = 2 + 127 = 129,
ce qui s'écrit 10000001₂ sur huit bits.]]>Représentation des réels — Q29 : Décoder un flottant simple précisionOn considère le mot 32 bits suivant, stocké en simple
précision (norme IEEE 754) :
`
0 | 10000001 | 01000000000000000000000 `
(signe sur 1 bit, exposant sur 8 bits, mantisse sur
23 bits). Quelle est la valeur décimale représentée ?
]]>Procédure de décodage en trois étapes : (1) lire le bit de
signe ; (2) lire l'exposant biaisé E et calculer
e = E - 127 ; (3) reconstituer la mantisse en préfixant le
bit implicite 1, puis appliquer la formule
(-1)^s \times 1{,}\!M \times 2^e. Pour cette question :
(-1)^0 \times 1{,}25 \times 2^2 = 5.]]>1.00.00truetrueabc2{,}5]]>Erreur : on a oublié d'ajouter le bit implicite à la
mantisse. La forme normalisée IEEE 754 stocke seulement
les bits après la virgule ; la valeur 1 avant la
virgule est implicite. Ici, la mantisse vaut donc
1{,}01_2 = 1{,}25, pas 0{,}25.]]>5]]>Bonne réponse : signe 0 (positif), exposant
10000001₂ = 129, donc e = 129 - 127 = 2. Mantisse
implicite 1{,}01_2 = 1{,}25. Valeur :
1{,}25 \times 2^2 = 5.]]>10]]>Erreur sur l'exposant : on a peut-être lu la mantisse à
l'envers ou doublé la puissance. L'exposant biaisé vaut
129, donc e = 2 et le facteur est 2² = 4, pas
2³ = 8.]]>-5]]>Erreur : le bit de signe vaut 0 (positif). Le résultat
est +5, pas -5.]]>