Représentation des nombres en machine

Info 2
REPRÉSENTATION DES NOMBRES EN MACHINE
Problèmes liés au codage de nombres en binaire
Au moment de manipuler des données numériques avec un ordinateur, deux aspects doivent être pris en compte :
i. la représentation des nombres manipulés sous forme de séquences de 0 et de 1 (seule forme de données lues par un ordinateur) ;
ii. les limites de cette représentation : la mémoire d'un ordinateur ne peut contenir qu'une quantité nie de nombres !
1
Représentation binaire des entiers
1.1 Représentation binaire d'un nombre entier naturel
I Tout entier naturel N peut s'écrire sous la forme :
N = xn0 × 2n0 + · · · + xk × 2k + · · · + x1 × 2 + x0 ,
n0 est un entier naturel
où
x0 , ... , xn0 sont des bits ,→ des entiers prenant la valeur 0 ou 1
I Cette écriture est appelée représentation binaire de N .
I On l'écrit symboliquement sous la forme : N = (xn0 · · · x1 x0 )2 .
Exemples :
→ Puisque 271 = 256 + 8 + 4 + 2 + 1
= 1 × 28 + 0 × 27 + 0 × 26 + 0 × 25 + 0 × 24
+1 × 23 + 1 × 22 + 1 × 21 + 1 × 20
en reprenant le symbolisme précédent, on peut écrire : 271 = 1 0000 11112 ;
→ La notation 1100102 correspond au nombre :
0 × 20 + 1 × 21 + 0 × 22 + 0 × 23 + 1 × 24 + 1 × 25 = 50
1.2 Codage en machine d'un entier relatif
Restons sur l'exemple de mots de 8 bits
Dans ce cas, on peut coder 28 = 256 nombres : si l'on ne codait que des entiers
naturels, on pourrait représenter tous les entiers compris entre 0 et 28 − 1.
On va s'attacher à proposer une méthode permettant de coder tous les entiers compris
entre −27 et 27 − 1 (il y en a bien 256).
Pour
cela, on convient que :
:::::::::::::::::::::::::
. si un entier n est compris entre 0 et 27 − 1, il est codé par sa représentation
binaire classique , décrite précédemment ;
. si un entier n est compris entre −27 et −1, il est représenté par le codage en
binaire de l'entier positif 28 + n, qui est compris entre 28 − 27 = 27 et 28 − 1.
:::::::::::::::::::::::::::::::::::
Par cette méthode appelée méthode du complément à 2 , l'entier -1 est représenté par le codage de 255 en binaire, ce qui donne 1111 11112 , -2 est représenté par
le codage de 254 en binaire , et ainsi de suite, jusqu'à -128, qui est représenté par le
codage de 128 en binaire.
On réalise alors que, en suivant cette convention :
. le premier bit qui apparaît dans le codage d'un entier relatif vaut 0 si ce nombre
est positif, 1 si ce nombre est négatif : voilà une façon simple de détecter rapidement le signe d'un entier ;
. les règles d'addition des entiers relatifs prolongent celles des entiers naturels.
Le début des ennuis...
Dans la mémoire des ordinateurs, les circuits dans lesquels les données sont véhiculées sont souvent groupés par huit : les octets.
On utilise souvent des nombres exprimés en notation binaire sur un, deux, quatre
ou huit octets, soit 8, 16, 32 ou 64 bits, ce qui permet de représenter les nombres
de 0 à 255 sur un octet ; de 0 à 65 535 sur deux octets, etc.
Ainsi, on ne code qu'un nombre ni d'entiers... alors que
l'ensemble N des entiers naturels est inni !
1.3 Dépassement de capacité
De nouveau, le codage des entiers ne peut être réalisé que dans les limites dénies
par la taille des nombres manipulés par la machine considérée.
Ainsi, une addition de deux nombres positifs ou négatifs peut entraîner un dépassement de capacité (overow en anglais). Sur certains ordinateurs, les calculs
continuent. Sur d'autres, une erreur est signalée, d'une façon diérente d'un
constructeur à l'autre.
2
2.3 Limites de la représentation des réels en machine
Codage en machine d'un nombre réel
2.1 Nombres à virgule, virgule ottante
I On peut écrire des nombres à virgule en binaire, en adaptant la démarche
précédente avec les puissances négatives de 2.
Par exemple :
11, 01012
1
0
= 1×2 +1×2 +0×2
−1
Comme, en machine, l'exposant et la mantisse ne peuvent prendre qu'un nombre
ni de valeurs, tout réel ne peut donc pas être codé en machine !... et les problèmes
de représentation des nombres réels en machine ne s'arrêtent pas là !
.
−2
+1×2
−3
+0×2
+1×2
−4
= 2 + 1 + 0 + 0, 25 + 0 + 0, 0625
= 3, 3125
I On peut écrire tout nombre réel x non nul sous la forme :

 s est le signe de x,
m est un réel de [1, 2[ (appelé mantisse ),
x = s m 2n , où

n est un entier relatif (appelé exposant ).
Par exemple, le nombre x = 3, 3125 s'écrit aussi x = +1, 65625 × 21 : il a pour
mantisse 1, 65625 et pour exposant 1.
Cette écriture est celle sur laquelle on va s'appuyer pour représenter le réel x
en machine.
2.2 Virgule ottante en machine
Dans
le cas où on utilise 64 bits pour représenter un nombre à virgule, la norme IEEE
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
754 (Institute of Electrical and Electronics Engineers ) convient qu'on utilise 1 bit
pour le signe, 11 bits pour l'exposant et 52 bits pour la mantisse :
• le signe + est représenté par 0 et le signe − par 1 ;
• l'exposant n est un entier relatif compris entre -1022 et 1023, représenté par
l'entier naturel n + 1023, qui est compris entre 1 et 2046 ;
• la mantisse m est un nombre binaire à virgule dans l'intervalle [1, 2[, comprenant
52 chires après la virgule.
Nota bene
Un premier problème se pose : on remarque rapidement qu'il n'est pas possible
de représenter 0 sous la forme s m 2n , où s est un signe, m ∈ [1, 2[ et n ∈ Z. Il
est pourtant bien commode de pouvoir le coder en machine, car on est amené à
l'utiliser fréquemment.
Par convention, on décide qu'un nombre vaut zéro si et seulement si tous les bits
de son exposant et de sa mantisse valent 0. Il reste un choix pour le bit de signe :
il y a donc un zéro positif et un zéro négatif dans l'ensemble des nombres à virgule
ottante.
Dépassement de capacité
Un dépassement de capacité peut avoir lieu lorsqu'un calcul produit :
→ un nombre trop grand en Python, ce dépassement de capacité peut retourner à l'utilisateur la valeur
inf (pour ∞) ou simplement un message d'erreur comportant la mention
Overflow.
→ un nombre trop proche de 0 : un tel nombre peut être arrondi à 0 et ainsi
produire une erreur.
,→ dépassement
de capacités par valeurs inférieures ( underow).
::::::::::::::::::::::::::::::::::::::::::
. Le résultat d'un calcul faisant intervenir deux nombres à virgule ottante peut
donner un résultat qui, sans poser de problème d'ordre de grandeur, n'est pas représentable dans la norme précédente : des erreurs de calculs risquent, là encore,
de se produire...
En particulier, la plupart des nombres décimaux ne sont pas codables dans ce
format avec 64 bits.
Par exemple, le nombre 0, 4 admet 0, 011001100110011 · · ·2 pour développement
en base 2 : il s'agit d'un développement inni périodique.
La représentation en virgule ottante sera donc forcément une valeur approchée
de ce nombre. Par défaut, la norme IEEE 754 impose que les nombres à virgule
soient arrondis à la valeur représentable la plus proche. Dans le cas de 0, 4, la
valeur approchée choisie vaut alors 0, 400000000000000022204460492503.