Chapitre 4
Représentation des nombres
Table des matières
1 Entiers positifs 2
2 Entiers relatifs sur des mots de n lettres (complément à 2) 3
3 Nombres flottants 3
3.1 Représentation des nombres flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.2 Précisions des flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.3 Que faire dans la pratique ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1 Entiers positifs
Théorème no 1 : décomposition d’un entier naturel en base 10
N
DN P N D pa0 , a1 , . . . , aN q P rr 0 ; 9 ssN `1 ak 10k
ř
Soit n P N, alors n se décompose en base 10 : n“
k“0
Exemple 1. 301 “ 3 ˆ 102 ` 0 ˆ 101 ` 1 ˆ 100
On dit alors que 301 est un mot de taille trois, les chiffres utilisés sont appelés lettres et l’ensemble des chiffres utilisés
s’appelle un alphabet. Ici, on a utilisé la base 10. En considérant la base 10 et seulement des mots à trois lettres, on peut
ainsi encoder tous les entiers entre 0 et 999.
Théorème no 2 : décomposition d’un entier naturel en base quelconque
N
pa0 , a1 , . . . , aN q P rr 0 ; b ´ 1 ssN `1 ak bk .
ř
Soit b P Nzt0, 1u. On peut décomposer n P N en base b : DN P N n“
k“0
On note alors n “ paN aN ´1 ...a1 a0 qb , n s’écrit alors comme un mot à N ` 1 lettres dans l’alphabet rr 0 ; b ´ 1 ss.
Remarque 1. Si n P N˚ et si on impose aN ‰ 0, alors N et pa0 , a1 , . . . , aN q sont uniques.
Remarque 2. Si on utilise la base 16 (hexadécimal), on a besoin de 16 chiffres, on peut prend usuellement 0, 1, 2, 3, 4,
5, 6, 7, 8, 9, A, B, C, D, E et F .
Comment calculer la décomposition d’un entier en base b ?
ˆN ˙ n
k´1
ak bk´1 en est
ř ř
Si on écrit n “ ak b b ` a0 , alors a0 est le reste de la division euclidienne de x par b et
k“1 k“1
le quotient. Ainsi, en effectuant une division euclidienne de x par b, le reste nous permet d’obtenir a0 . Puis si on
prend le quotient, on peut recommencer pour obtenir a1 puis on continue etc. Ainsi, l’algorithme suivant permet
de décomposer n’importe quel entier naturel dans la base b
def EcritureBase(n,b):
"""Décompose un entier naturel n dans la base b (b est un entier naturel >1)"""
assert n>=0 and b>1
a = n
L = []
while a != 0:
[Link](a%b)
a = a//b
return [L[len(L)-1-k] for k in range(len(L))]
Exemple 2. Considérons 367 et décomposons-le dans la base 2, alors
367 “ 2 ˆ p183q ` 1 “ 2 ˆ p2 ˆ 91 ` 1q ` 1 “ 22 ˆ 91 ` 2 ` 1 “ 22 p2 ˆ 45 ` 1q ` 2 ` 1
“ 23 ˆ 45 ` 22 ` 2 ` 1 “ 23 p2 ˆ 22 ` 1q ` 22 ` 2 ` 1 “ 24 ˆ p2 ˆ 11q ` 23 ` 22 ` 2 ` 1 “ 25 ˆ p2 ˆ 5 ` 1q ` 23 ` 22 ` 2 ` 1
“ 26 p2 ˆ 2 ` 1q ` 25 ` 23 ` 22 ` 2 ` 1 “ 28 ` 26 ` 25 ` 23 ` 22 ` 21 ` 20 “ p101101111q2
Remarque 3. En tant qu’humain, il peut nous sembler plus naturel d’aller dans l’autre sens : 367 “ 256 ` 111 “
28 ` 64 ` 47 “ 28 ` 26 ` 32 ` 8 ` 4 ` 2 ` 1 “ 28 ` 28 ` 25 ` 23 ` 22 ` 21 ` 20
Exemple 3. Si n “ p322q4 que vaut n ?
Les ordinateurs utilisent la base 2 (c’est le plus facile pour stocker un nombre, en effet, un disque dur est, très grossièrement,
constitué de cellules qui contiennent chacune la valeur 0 ou la valeur 1). Dans la pratique le nombre de mots est fixé par
avance. On dit qu’on représente les entiers sur des mots de taille fixe. Par exemple si on code en binaire sur des mots de
8 bits (un octet), alors on peut coder tous les entiers naturels de 0 à 255, 0 “ p00000000q2 et 255 “ p11111111q2 .
Si n est un entier. On peut alors coder sur des mots de n lettres les entiers entre 0 et 2n ´ 1.
Cela peut causer des soucis, en effet, si on prend, par exemple, n “ 8, alors si on fait la somme 129 “ p10000001q
et 128 “ p10000000q, il n’y aura plus assez de places pour stocker le résultat et on obtiendra une valeur aberrante
p0, 0, 0, 0, 0, 0, 0, 1q. C’est ce genre de problème qui a valu à Ariane 5 un crash en 1996 lors de son vol inaugural.
[Link]@[Link] PCSI du Lycée Lavoisier, 24-25, Chapitre4 2
2 Entiers relatifs sur des mots de n lettres (complément à 2)
Soit n P N, pour coder un entier négatif x, on fait la représentation binaire de 2n ` x Si x est positif, on fait la
représentation binaire de x. Donnons un exemple pour n “ 4. Si on prend x “ ´5, alors 2n ` x “ 11 “ 8 ` 2 ` 1 “ p1011q2 :
0000 0001 0010 0011 0100 0101 0110 0111
0 1 2 3 4 5 6 7
1000 1001 1010 1011 1100 1101 1110 1111
-8 -7 -6 -5 -4 -3 -2 -1
On peut donc représenter tous les nombres entre ´2n´1 et 2n´1 ´ 1.
Les ordinateurs récents codent souvent en n “ 64 bits (soit 8 octets). Ce qui pourrait limiter les nombres utilisables.
Heureusement, Python gère ça très bien, en écrivant les nombres sur plusieurs blocs ce qu’on appelle des entiers multi-
précision. Malheureusement, les temps de calculs pour additionner ou multiplier ces nombres est plus dur à calculer. Ainsi,
évaluer la complexité d’un algorithme en comptant le nombre de multiplication devient moins pertinent quand ces grands
nombres sont en jeu.
3 Nombres flottants
3.1 Représentation des nombres flottants
a
Rappelons qu’un nombre décimal est un nombre de la forme où a P Z et n P N. Malheureusement, tous les nombres
10n
ne sont pas décimaux comme 1{3. En physique, on représente les nombres en écriture scientifique : c “ 2, 99792458 ˆ 108 .
Python va faire pareil mais en base deux. Concrètement, si on code les nombres sur 64 bits. Alors le premier bits va coder
le signe, 52 bits vont permettre de coder les chiffres après la virgule (ce nombre s’appelle la mantisse), et 11 bits vont
permettre de coder l’exposant.
Le nombre de chiffre que l’on met dans l’exposant et dans la mantisse dépend de la norme (ici sur 64 bits) et n’est pas
à connaître 1 . Précisions quand même que :
‚ Le bit de signe vaut 0 si le nombre est positif et 1 sinon.
‚ Le premier chiffre de la mantisse est 1, on ne le stocke pas (on parle de bit implicite)
‚ L’exposant e peut être négatif, ainsi on rentre e avec un décalage est codé sur 11 bits, par l’entier positif e1 “
e ` 210 ´ 1 ainsi e1 P rr 0 ; 211 ´ 1 ss et donc e P rr ´1023 ; 1024 ss. Dans la pratique, e1 “ 0 ou e1 “ 211 ´ 1 sont
réservées.
On ne peut donc coder que certains nombres dans un ordinateur, car il ne faut pas que le nombre soit trop grand ou
trop petit (limite de l’exposant) et s’il a plus de chiffre après la virgule que le nombre de bits alloué à la mantisse, alors il
y aura un arrondi (limite de la mantisse).
On précise que, par convention, 0 a deux représentations particulières : une mantisse avec que des 0, un exposant
décalé à 0 et un signe qui vaut 0 ou 1.
3.2 Précisions des flottants
S=0
for i in range(10):
S=S+1/10
print(1-S)
print(0.1+0.2==0.3)
print(3**1000)
print(3.0**1000)#provoque une erreur
print((1.+2**53)-2**53)
3.3 Que faire dans la pratique ?
Adapter les tests d’égalité et tests d’inéquation
1. Il existe d’ailleurs une version à 32 bits où l’exposant est codé sur 8 bits et 23 bits pour la mantisse.
[Link]@[Link] PCSI du Lycée Lavoisier, 24-25, Chapitre4 3
‚ Le code suivant peut donner une boucle infinie
a=...
while a!=b:
a=...
En effet, même si on est assuré mathématiquement qu’à un moment a prendra la valeur b (et donc de stopper la
boucle), à cause des erreurs d’arrondis, il est possible que a soit toujours différent de b (repenser au cas 0.1+0.2).
À la place, il vaut mieux utiliser le code suivant :
a=...
while abs(a-b)<epsilon:
a=...
Où epsilon a une valeur plus grande que la marge d’erreur attendue.
‚ Le code suivant peut ne pas donner le résultat attendu :
a=...#de positif
while a>=0:
a=a-quelque chose
En effet, même si on est assuré mathématiquement qu’à un moment a sera strictement négatif (et donc de stopper
la boucle), à cause des erreurs d’arrondis, il est possible que a soit négatif alors que Python va penser qu’il est
positif auquel cas la boucle while pourrait s’arrêter trop tôt. À la place, on peut utiliser le code suivant :
a=...
while a>-epsilon:
a=...
[Link]@[Link] PCSI du Lycée Lavoisier, 24-25, Chapitre4 4