$course$/QCM de NSI/Première/Représentation des réels Repré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 Python Quel 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.0 0.0 0 true true abc number

]]> 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 scientifique L'écriture scientifique d'un nombre réel sépare un
réel en :

]]> En base $2$ (binaire), la notation scientifique s'écrit
$m \times 2^e$, avec une mantisse $m$ entre $1$ et $2$
et un exposant $e$ entier. C'est exactement ce que fait
la norme IEEE $754$.

]]> 1.0 0.0 0 true true abc Une fraction irréductible

]]> Une fraction irréductible
(comme $\dfrac{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 754 Que 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.0 0.0 0 true true abc La 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éels Pourquoi 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.0 0.0 0 true true abc Parce 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 $\pi$, $\sqrt{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 Python Que 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.0 0.0 0 true true abc Une 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 flottants Pour 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.0 0.0 0 true true abc a == 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^{-9}$)

]]> 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 fixe Quelle 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.0 0.0 0 true true abc La 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^{-300}$) à très
grand ($10^{300}$), 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 Python En 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.0 0.0 0 true true abc $128$ 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 754 La 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.0 0.0 0 true true abc Aucune valeur spéciale

]]> Erreur : les valeurs spéciales sont une partie
essentielle de la norme.

]]> $+\infty$, $-\infty$, et NaN (« Not a Number »)

]]> Bonne réponse : ces valeurs gèrent les opérations
extrêmes. $1/0$ donne $+\infty$, $\sqrt{-1}$ ou
$0/0$ donnent NaN. Cela évite les plantages et
permet des calculs plus robustes.

]]> $\pi$, $e$, $\sqrt{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 754 Quels 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.0 0.0 0 true true abc Partie 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 cumulative Que 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.0 0.0 0 true true abc Le 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épassement Que renvoie en Python l'opération 1e308 * 10 (où
1e308 désigne $10^{308}$) ?

]]> 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.0 0.0 0 true true abc $10^{309}$

]]> Erreur : $10^{309}$ 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écision Combien 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.0 0.0 0 true true abc Une 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.isclose En 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.0 0.0 0 true true abc Convertit 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^{-9}$ 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 financier Pour 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.0 0.0 0 true true abc Utiliser 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 flottant En 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.0 0.0 0 true true abc 7 (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 signification Pourquoi (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.0 0.0 0 true true abc Parce que $1$ est négligeable face à $10^{16}$, 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^{16}$, 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ée En 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.0 0.0 0 true true abc $0{,}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 \times 10^e$ 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 \times 2^e$).

]]> Représentation des réels — Q19 : Non-associativité de l'addition flottante En 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.0 0.0 0 true true abc Cela 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 binaire Pourquoi $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.0 0.0 0 true true abc Parce 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.0 0.0 0 true true abc Pour 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és Quand 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.0 0.0 0 true true abc Pour 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 erreurs Quel 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.0 0.0 0 true true abc $a - 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 \times 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 float En 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.0 0.0 0 true true abc decimal 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 flottants Parmi 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.0 0.0 0 true true abc La 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 virgule Quelle 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.0 0.0 0 true true abc $1010{,}11$

]]> Erreur : $1010_2 = 10$, pas $6$. Confusion sur la partie
entière : $6 = 4 + 2 = 110_2$.

]]> $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_2$. 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 finie Parmi les réels suivants (écrits en base $10$), lequel n'a
pas une écriture finie en base $2$ ?

]]> Un nombre décimal $\dfrac{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 \times 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.0 0.0 0 true true abc $0{,}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écision Le 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.0 0.0 0 true true abc $2$

]]> 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_2$ sur huit bits.

]]> Représentation des réels — Q29 : Décoder un flottant simple précision On 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.0 0.0 0 true true abc $2{,}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_2 = 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^2 = 4$, pas
$2^3 = 8$.

]]> $-5$

]]> Erreur : le bit de signe vaut $0$ (positif). Le résultat
est $+5$, pas $-5$.

]]>