MPSI A - ITC Représentation des nombres en mémoire

Le développement de ce chapitre a été motivé par les interrogations soulevées par les
résultats suivants :

>>> import numpy as np

# addition des deux entiers 233 et 124

>>> np.add(np.uint8(233),np.uint8(124)))

?????????????????????????

# addition de deux flottants

>>> 0.1 + 0.2

?????????????????????????

Le programme nous demande de s’intéresser particulièrement aux points suivants :

1 / 13
MPSI A - ITC Représentation des nombres en mémoire

1. Écriture décimale des nombres entiers, écriture en base b .

(a) Écriture d’un entier naturel en base b .
Pour comprendre l’écriture binaire, il peut être utile de se replonger dans la
signification de l’écriture décimale, que nous sommes habitués à utiliser depuis
notre enfance - à tel point que nous ne faisons plus en général la distinction
entre un nombre et la façon de le représenter.
Que signifie par exemple 8473 ? Nous le voyons comme un nombre entier, mais
il s’agit en fait d’une suite finie de caractères - appelés chiffres - représentant un
nombre entier. Le 3 correspond au chiffre des unités, le 7 à celui des dizaines,
etc. Cela peut se traduire par la relation mathématique suivante :

8473 = 8 × 1000 + 4 × 100 + 7 × 10 + 3 × 1 = 8.103 + 4.102 + 7.101 + 3.100 .

Le choix d’utiliser 10 chiffres ( de 0 à 9 ) et des puissances de 10 vient probable-

ment du fait que nous avons généralement 10 doigts, mais est mathématiquement
arbitraire : il est possible de remplacer 10 par n’importe quel entier b supérieur
ou égal à 2.
En base b , un entier sera représenté sous la forme :

ap . . . a1 a0 = ap .bp + ... + a1 .b1 + a0 .b0

où les ai sont des symboles codant les entiers compris entre 0 et b − 1 .
Nous pouvons montrer la propriété dite de représentation des nombres entiers
en base b, qui justifie en partie l’intérêt l’usage de ces notations.
Soit b un entier supérieur ou égal à 2.
Pour tout entier naturel n , il existe p appartenant à N et a0 , . . . , ap des entiers
compris entre 0 et b− tels que :
p
X
n= ai .bi .
i=0

On notera alors : n = ap . . . a1 a0 b - ou simplement n = ap . . . a1 a0 s’il n’y a pas

d’ambigüité sur la base.
Les ai sous la barre sont donc des entiers compris entre 0 et b − 1 mais sont
généralement représentés par b symboles choisis à l’avance. Par exemple, pour
la base 10, ces symboles sont 0,1,2,3,4,5,6,7,8 et 9, que l’on confond avec les
nombres qu’ils représentent.
À noter qu’il n’y a pas unicité de l’écriture en base b : il est toujours possible
de rajouter des 0 devant l’écriture d’un nombre sans le modifier. Par exemple,
en écriture décimale, on peut théoriquement écrire 00292 au lieu de 292. Si l’on
omet ces 0 surnuméraires en début de nombre, on peut alors prouver un résultat
d’unicité en toute base.

2 / 13
MPSI A - ITC Représentation des nombres en mémoire

Enfin, le choix de mettre le chiffre des unités tout à droite plutôt que tout à
gauche est également largement arbitraire : l’écriture décimale pourrait très bien
fonctionner - par convention - dans l’autre sens.
En informatique, on utilise fréquemment la base 2, dont nous allons beaucoup
parler ci-dessous.
Mais notons qu’il existe d’autres bases :
— La base 16 est également utilisée en informatique - par exemple pour repré-
senter des niveaux de canaux de couleur. Les chiffres en base 16 s’écrivent
usuellement 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F .
— La base 24 est utilisée pour les heures et la 60 est utilisée pour les secondes
et les minutes ? ! Mais plutôt que d’utiliser 24 et 60 symboles de chiffres (
qui seraient fastidieux à retenir ), on note ces chiffres en base 10. Cela oblige
d’ailleurs à utiliser des séparateurs ( h , : , ... ) et/ou à rajouter des 0 inutiles.
Par exemple si l’on notait simplement un horaire ( heure + minute ) 203, on
ne saurait pas si cela correspondrait à 20h03, 20h30 ou 2h03. . .
(b) Conversion d’un entier naturel de la base 10 à la base 2 .
Quelle est la représentation en base 2 de 0 ?
Nous est donné un entier naturel non nul n sous sa représentation décimale,
il existe donc de manière unique p appartenant à N et a0 , . . . , ap des entiers
appartenant à {0, 1} tels que :
 p
X
ai .2i

n =
i=0
.

ap = 1


p
!
X
En écrivant : n = 2× ai .bi−1 +a0 , à quoi correspond a0 ? à quoi correspond
i=1
p
X
ai .bi−1 ?
i=1
Proposer une méthode pour déterminer a − 1 , puis a2 , .... et un critère d’arrêt.
Appliquer cette méthode pour déterminer la représentation binaire de 124 .
Écrire une fonction ( itérative et/ou récursive ) Python decimal_vers_binaire
(n:int) -> list qui prend en argument un entier n ( une assertion pourra
intervenir pour valider la positivité de l’entier ) et renvoie la liste [a0 , a1 , ..., ap ] ,
et proposer quelques jeux d’essai.
(c) Conversion d’un entier naturel de la base 2 à la base 10 .
Nous est donnée l’écriture binaire d’un entier naturel n = ap . . . a1 a0 2 .
i. Une approche naı̈ve.
2
Quelle est l’écriture décimale de 10110100010 ? Quel calcul trouvez-vous
pénible ?

3 / 13
MPSI A - ITC Représentation des nombres en mémoire

Écrire suivant le schéma utilisé ci-dessus, une fonction itérative Python bi-
naire_vers1_decimal (L:list) -> int qui prend en argument une liste
[a0 , a1 , ..., ap ] et renvoie l’entier n = ap . . . a1 a0 2 ,
et proposer quelques jeux d’essai.
Les calculs pénibles s’expliquant en évaluant la complexité de l’algorithme
itératif utilisé dans la fonction ci-dessus. À vous de jouer !
ii. Une approche améliorée.
2
Reprendre la conversion de 10110100010 en trouvant un moyen d’éviter ce
calcul pénible.
Écrire suivant le schéma utilisé ci-dessus, une fonction itérative Python bi-
naire_vers2_decimal (L:list) -> int qui prend en argument une liste
[a0 , a1 , ..., ap ] et renvoie l’entier n = ap . . . a1 a0 2 ,
et proposer quelques jeux d’essai.
Évaluer la complexité de l’algorithme utilisé dans la fonction ci-dessus.
Alors ?
iii. La meilleure méthode !
Nous avons : n = a0 + 2 × (a1 + 2 × (a2 + ... + 2 × (ap−1 + 2 × ap ))) !
2
Reprendre la conversion de 10110100010 en suivant cette écriture.
Écrire suivant le schéma utilisé ci-dessus, une fonction ( itérative et/ou
récursive ) Python binaire_vers3_decimal (L:list) -> int qui prend
en argument une liste [a0 , a1 , ..., ap ] et renvoie l’entier n = ap . . . a1 a0 2 ,
et proposer quelques jeux d’essai.
Évaluer la complexité de l’algorithme utilisé dans la fonction ci-dessus.
Alors ?
Cette méthode est connue sous le nom d’algorithme de Hörner, c’est la
méthode la plus efficace pour évaluer la valeur d’un polynôme en un point
( dans notre cas, nous avons fait une évaluation en 2, nous pouvons évaluer
en tout point ).
iv. Une approche récursive.
Écrire une fonction récursive Python binaire_vers4_decimal (L:list)
-> int qui prend en argument une liste [a0 , a1 , ..., ap ] et renvoie l’entier
n = ap . . . a1 a0 2 ,
et proposer quelques jeux d’essai.
Pourquoi le parenthésage de la méthode de Hörner peut-il se révéler natu-
rel ?
2. Représentation des données en mémoire.
(a) L’unité de mémoire en informatique.
L’unité de mémoire en informatique est le bit, contraction des mots anglais
binary digit qui signifient « chiffre binaire » .

4 / 13
MPSI A - ITC Représentation des nombres en mémoire

Un bit ne peut donc prendre que deux valeurs. Selon le contexte, numérique,
logique, électronique, magnétique ou optique, on les appelle « zéro » et « un » ,
ou « faux » et « vrai » , ou « ouvert » et « fermé » , ou « déchargé » et « chargé » ,
ou « nord » et « sud » , ou « noir » et « blanc » :
Contexte Valeurs
numérique 0 1
logique non/faux oui/vrai
interrupteur ouvert fermé
condensateur déchargé chargé
magnétique nord sud
optique noir blanc
Technologiquement parlant, il existe donc une grande variété de moyen d’enco-
dage binaire de l’information, selon le support de stockage ou de transmission
utilisé : les propriétés physiques telle que la polarisation magnétique, la charge,
le courant ou la tension électrique, l’intensité lumineuse, sont couramment uti-
lisées.
L’essentiel est d’autoriser avec une très bonne fiabilité la distinction entre les
deux états 0 et 1 de manière à limiter les erreurs.
(b) L’unité de stockage en informatique.
En informatique, toutes les données, quelles qu’elles soient, sont alors stockées
sous la forme abstraite d’une suite ininterrompue de zéros et de uns ( Matrix ! )
Par exemple, nous pouvons imaginer : 1101011101 et nous nous interrogeons
alors sur ce que représente cette série ... un mot ou plusieurs mots ? Il semble
alors nécessaire d’avoir un séparateur donc un nouveau symbole et nous n’avons
que deux symboles ... dilemme ! ! ! !
Nous choisissons alors une unité de stockage c’est-à-dire une longueur de regrou-
pement de bits.
Traditionnellement, l’unité de stockage est l’octet, constitué d’un groupement
de 8 bits.
Les premiers ordinateurs personnels (transportables) étaient « 8 bits » , c’est à
dire que processeur, bus et mémoires avaient pour unité de stockage l’octet.
Combien y a-t-il d’états différents possibles pour un octet ? ?
Les besoins grandissant en informatique ont amené une évolution de l’unité de
stockage en assemblant les unités de stockage, ce qui explique l’évolution par
doublement de la capacité :
— 8 bits ( fin des années 70, premiers ordinateurs personnels, performances
limitées )
— 16 bits ( milieu des années 80, les premiers PC, Apple Macintosh, Atari St,
jeux graphiques, ... )
— 32 bits ( années 90, internet, système d’exploitation avec interface graphique,
multimédia, ... )

5 / 13
MPSI A - ITC Représentation des nombres en mémoire

— 64 bits ( années 2000, tout connecté, multitâche multimédia )

Quelques exercices ...
On souhaite coder les 26 lettres de l’alphabet sur un nombre n fixe de bits -
c’est-à-dire établir une bijection entre les 26 lettres de l’alphabet et une partie de
l’ensemble des séquences de n bits possibles. De combien de bits a-t-on besoin ? ?
On considère une image constituée de 3600 ?2400 pixels. Pour chaque pixel, il y
a trois canaux de couleur, R, G et B (pour rouge, vert, et bleu). Chacun de ses
canaux à un niveau compris entre 0 et 255, déterminant l’intensité de la couleur
correspondante pour le pixel considéré. Évaluer la taille d’une telle image en
mémoire. Comparer avec l’ordre de grandeur que vous aviez éventuellement en
tête avant de faire l’exercice.
Dans la suite, l’entier naturel non nul N ( généralement une puissance de 2 pour
des raisons matérielles ) désigne la taille de l’unité de stockage, plus précisément
le nombre de bits d’une unité de stockage.
3. Représentation normalisée des entiers relatifs.
(a) Représentation des entiers naturels ou entiers non signés.
En informatique, les entiers naturels se représentent naturellement à l’aide de
leur écriture en base 2.
Nous définissons alors la représentation binaire sur N bits de l’entier naturel n
d’écriture binaire ap ap−1 ...a1 a0 2 par la liste de longueur N :

[a0 , a1 , ..., ap−1 , ap , 0, 0, ..., 0, 0]

notée dans la suite par commodité :

2
00...00ap ap−1 ...a1 a0 .

Pour tout entier k compris entre 0 et N − 1, ak est appelé le bit de poids k,

le bit de poids le plus faible est a0 , le bit de poids le plus fort aN−1 .
N−1
2 2
X
Notons que : 000
| . {z. . 0000} = 0 , 111
| . {z. . 1111} = 2k = ............ ,
N fois N fois k=0
une représentation binaire sur N bits permet donc de représenter tous les entiers
naturels compris entre 0 et 2N − 1, soit 2N valeurs.
Un entier naturel supérieur ou égal à 2N aura une représentation binaire sur N
bits erronée sans nécéssairement provoquée une erreur.
Ainsi :
— Sur un octet, 8 bits, nous pouvons représenter tous les entiers de :
2 2
0 = 0 à 11111111 = 28 − 1 = 255 ,

soit 256 valeurs.

6 / 13
MPSI A - ITC Représentation des nombres en mémoire

— Sur 2 octets, soit 16 bits, nous pouvons représenter tous les entiers de :
2 2
0 = 0 à 1111111111111111 = 216 − 1 = 65535 ,

soit 65536 valeurs.

— Sur 4 octets, soit 32 bits, nous pouvons représenter tous les entiers de :

0 à 232 − 1 = 4294967295 .

soit 429496730 valeurs.

— Sur 8 octets, soit 64 bits, nous pouvons représenter tous les entiers de :

0 à 264 − 1 = 18446744073709551615 .

soit 18446744073709551616 valeurs.

Écrire une fonction ( itérative et/ou récursive ) Python decimal_vers_binaire_Nbits
(n:int,N:int) -> list qui prend en argument un entier n ( une assertion
pourra intervenir pour valider la positivité de l’entier ) et un entier naturel N et
renvoie la représentation binaire sur N bits de l’entier naturel n ,
et proposer quelques jeux d’essai.
Des fonctions de conversion existent en Python, elles vous permettront de vérifier
votre fonction :
>>> bin(10)
’0b1010’

>>> int(’1011’,2)
11
(b) Somme d’entiers naturels.
i. Opérations binaires sur les entiers.
Puisque les entiers sont constitués d’une suite de 0 et de 1 , nous pouvons
effectuer des opérations bit à bit comme des opérations logiques et, ou, ou
exclusif.
Opération Python
et bit à bit a&b
ou bit à bit a|b
ou exclusif bit à bit a∧b
décalage à droite de a sur b bits a >> b
décalage à gauche de a sur b bits a << b
où :

7 / 13
MPSI A - ITC Représentation des nombres en mémoire

a b a&b a b a|b a b a∧b

0 0 0 0 0 0 0 0 0
0 1 0 0 1 1 0 1 1 ,
1 0 0 1 0 1 1 0 1
1 1 1 1 1 1 1 1 0
et nous avons aussi les tables de vérité suivantes :
a b a⇒b a b a⇔b
a ¬a 0 0 1 0 0 1
0 1 0 1 1 0 1 0 ,
1 0 1 0 0 1 0 0
1 1 1 1 1 1
ii. Somme d’entiers.
Un microprocesseur ne manipule que des données représentées par des suites
de 0 et de 1 et n’effectue que des opérations logiques sur ces données.
Aussi comment réaliser une addition d’entiers en n’utilisant que des opéra-
tions binaires ?
L’algorithme d’addition d’entiers binaires et similaire à l’addition d’entiers
en base 10 appris à l’école primaire !
Par exemple , effectuons l’addition : 23 + 5 = 28 ,
2 2
nous avons : 23 = 10111 , 5 = 101 ,
et :
23 : 0 1 0 1 1 1
5 : 0 0 0 1 0 1
Résultat reporté : 0 1 0 0 1 0
Retenue : 0 0 1 0 1 (0)
Résultat reporté : 0 1 1 0 0 0
Retenue : 0 0 0 1 (0) (0)
Résultat reporté : 0 1 1 1 0 0
Retenue : 0 0 0 (0) (0) (0)
Résultat : 0 1 1 1 0 0
2
et : 11100 = 16 + 8 + 4 = 28 .
Remarquons que dans l’addition de deux entiers naturels a et b :
— le résultat reporté est a ∧ b,
— la retenue a & b.
Ainsi dans l’addition d’entiers a et b :
 
a + b = (a ∧ b) + ((a & b) << 1) = (a ∧ b) + (a & b)*2 .

En déduire l’algorithme pour l’addition d’entiers, ne faisant appel qu’à des

opérations binaires :

8 / 13
MPSI A - ITC Représentation des nombres en mémoire

def binadd(a,b):
..............................
....................................
return(a)

Nous constatons que l’addition de deux entiers est de complexité constante

Retenons que pour récupérer le bit de poids i d’un entier b, il suffit de saisir
b & (2**i) , ou plutôt : b & (1 << i).
iii. Multiplication d’entiers ... en seconde lecture !
Pour la multiplication d’entiers :
p p
X X
k
n× bk 2 = (n.bk ) 2k .
k=0 k=0

La multiplication d’entiers est analogue à la multiplication décimale, mais

en plus simple ... il n’est plus nécessaire de connaı̂tre ses tables de multipli-
cations !
Par exemple, effectuons la multiplication : 18 × 5 = 90 ,
2 2
nous avons : 18 = 10010 , 5 = 101 ,
1 0 0 1 0
× 1 0 1
1 0 0 1 0
0 0 0 0 0 (0)
1 0 0 1 0 (0) (0)
1 0 1 1 0 1 0
2
et : 1011010 = 90 .
Nous en déduisons l’algorithme de multiplication binaire :
def binmult(a,b):
res = 0
i = 0
while (b>>i) != 0:
if ((b & (1<<i)) != 0):
res = binadd(res,a<<i)
i = binadd(i,1)
return(res)
C’est sur ce modèle que le microprocesseur implémente une addition ou une
multiplication d’entiers non signés.
Sur un ordinateur N bits , le temps d’exécution d’une telle opération est
majorée par une valeur constante ( fonction de N ).

9 / 13
MPSI A - ITC Représentation des nombres en mémoire

iv. Limite de la représentation des entiers non signés.

Lorsque les nombres sont représentés dans un espace alloué de taille fixée,
nous pouvons être confrontés à des problèmes de dépassement dans les cal-
culs.
Par exemple, dans la représentation sur 8 bits des entiers naturels :
2 2
1111 1111 + 0000 0001 = 1 0000 0000 ,

le résultat de l’addition de deux nombres d’un octet peut donner un résultat

qui ne peut pas s’écrire sur 8 bits. Si le résultat de l’opération est représenté
sur 8 bits, le résultat retourné sera erroné, ce sera 0 ...
Que dire maintenant du résultat de np.add(np.uint8(233),np.uint8(124))) ?
(c) Représentation des entiers relatifs ou entiers signés.
i. Une première idée.
Pour représenter un entier signé sur N bits ( N = 8, 16, 32, 64, . . . ), le bit
de poids fort est utilisé pour coder le signe : 0 pour positif, 1 pour négatif.
Nous pourrions alors utiliser les N − 1 bits restants pour coder la valeur
absolue du nombre,
ce qui permet de coder les entiers relatifs de valeur absolue inférieure ou
égale à 2N−1 − 1 ( il ne reste plus que N − 1 bits disponibles ).
Cette idée présenterait deux désavantages :
— le zéro admettrait les deux représentations 0000 0000 et 1000 0000 (exemple
sur 8 bits),
or la comparaison à zéro est une opération très souvent réalisée, elle
consisterait alors en 2 tests au niveau du processeur !
— l’algorithme d’addition demeure correct entre entiers positifs, mais est
incorrect en général :
2 + 1 = 0000 0010 + 0000 0001 = 0000 0011 = 3 ,
(−2) + (−1) = 1000 0010 + 1000 0001 = 1 | 0000 0011 = 0000 0011 = 3 ,
(−2) + 1 = 1000 0010 + 0000 0001 = 1000 0011 = −3 .
ii. Représentation en complément à deux ( puissance N ).
Pour pallier à ces inconvénients, nous allons utiliser la notation en complément
à deux des entiers signés.
Nous allons représenter tout entier relatif x compris entre −2N−1 et 2N−1 −1
par un entier naturel compris entre 0 et 2N − 1 de la façon suivante :
— dans le cas où x est positif, x est représenté par sa représentation binaire
en tant qu’entier non signé,
— dans le cas où x est strictement négatif, x est représenté par la repré-
sentation binaire en tant qu’entier non signé de x + 2N ,
notons que : 2N−1 ⩽ x + 2N < 2N .

10 / 13
MPSI A - ITC Représentation des nombres en mémoire

Par exemple, sur 8 bits, nous représentons tous les entiers relatifs x compris
entre −128 et 127 par les entiers naturels n compris entre 0 et 255,
les entiers naturels n compris entre 0 et 127 correspondent aux entiers re-
latifs positifs x avec : x = n,
les entiers naturels n compris entre 128 et 255 correspondent aux entiers
relatifs négatifs x avec : n = x + 256 ou x = n − 256,
−1 est représenté par 255 , −2 par 254, ... , −127 par 129, −128 par 128.
Notons que l’opposé de −128 n’est pas représentable.
Un des premiers intérêts de cette représentation est l’unicité de la représen-
2
tation du zéro : 0 = 0000 0000 , nous avons aussi les algorithmes d’addition
et de multiplication vus dans le cas des entiers non signés, qui s’étendent
sans modification aux entiers signés.
Nous pouvons constater que le rôle du bit de poids fort est conservé :
x étant un entier relatif compris entre −2N−1 et 2N−1 − 1,
— dans le cas où x est positif, x est compris entre 0 et 2N−1 − 1, le bit de
poids fort est égal à 0,
— dans le cas où x est strictement négatif , nous utilisons l’écriture binaire
de n = 2N + x ⩾ 2N−1 , le bit de poids fort est donc égal à 1.
Quelle est la représentation en complément à 2 sur 8 bits de -87 ?
Ainsi en complément à 2 :
A. représenter en binaire sur N bits un entier relatif x donné en mode
décimal revient à discuter sur le signe de x,
— si l’entier relatif x est positif ou nul, nous le représentons comme
l’entier naturel n = x,
— si l’entier relatif x est strictement négatif, nous le représentons comme
l’entier naturel n = x + 2N ,
B. représenter en décimal un entier relatif x de représentation binaire sur
N bits notée m revient à discuter de la position de l’entier naturel n
d’écriture binaire m par rapport à 2N−1 − 1 , l’information est donnée
par le bit de poids le plus fort, à savoir :

11 / 13
MPSI A - ITC Représentation des nombres en mémoire

— si n < 2N−1 , x = n,
— et si n ⩾ 2N−1 , x = n − 2N .
Écrire une fonction Python naı̈ve qui rend en argument un entier relatif n et
renvoie sa représentation en complément à deux et proposer quelques jeux
d’essai.
Mettons en place un algorithme ( une méthode ) afin de construire la
représentation en complément à deux d’un entier relatif n appartenant à
J−2N−1 , −1K en évitant le calcul de 2N de très mauvaise complexité.
Nous déterminons dans un premier temps, la représentation binaire sur N
bits de r = −n, −n appartenant J0, 2N−1 − 1K, le bit de poids le plus fort
est donc égal à 0,
nous inversons ensuite tous les bits, 0 devient 1 et 1 devient 0 , nous obtenons
alors une nouvelle représentation r′ ,
et reste à additionner r′ et 1,
la nouvelle représentation r” obtenue est la représentation sur N bits en
complément à 2 de n.
Cherchons à expliquer cet algorithme de représentation en complément à 2
pour des valeurs négatives n.
Nous commençons donc par la représentation non signée de −n notée r ,
et nous construisons une nouvelle représentation r′ en échangeant 0 et 1,
nouvelle représentation r′ associée à un entier naturel n′ ,
et en additionnant ces deux représentations : r + r′ = |111....11
{z },
N bits
′ N
soit en valeur numérique : −n + n = 2 − 1,
c’est-à-dire : 2N + n = n′ + 1,
et par conséquent la représentation non signée de n′ + 1 = 2N + n est donc
la représentation en complément à 2 sur N bits de n.
N = 8

def representation_non_signee(n):
r = []
for k in range(0,N):
r.append(n % 2)
n = n // 2
return(r)

def representation_complementa2(n):
if (n >= 0):
r = representation_non_signee(n)
else:

12 / 13
MPSI A - ITC Représentation des nombres en mémoire

# représentation non signée r de -n ( 1 ligne ! )

# construction de la représentation r’ obtenue à partir de r
en échangeant les 0 et les 1 ( une répétitive en 2 lignes ! )
# addition de $1$ à $n’$ directement à partir de
leur représentation ( une répétitive en 5 lignes ! )
return(r)
iii. Limite de la représentation des entiers signés.
Le même problème que pour les entiers signés en pire :
2 2 2
0011 0011 × 0000 1000 = 0011 1100 , des bits sont perdus, le résultat est
faux !
2 2 2
0111 0011 × 1100 1000 = 0011 1100 , débordement alors qu’il n’y a pas !
2 2 2
0011 0011 + 0110 0100 = 0011 1100 , sans débordement, mais le résultat
est faux !
La gestion du dépassement de capacité ne se fait plus simplement avec la
gestion de la dernière retenue.
iv. Cas particulier de Python, les entiers longs.
En cas de dépassement, Python change automatiquement la représentation
des entiers et propose une représentation exacte,
d’où l’intérêt tant que c’est possible, de travailler dans le domaine entier.
Cette solution va considérablement ralentir le temps d’exécution des opéra-
tions de comparaison, d’addition, de multiplication.

13 / 13