Université des Sciences et Technologie M.

Boudiaf Structure Machine 1

Faculté des Mathématiques et Informatique
Département d’Informatique TD2 (Corrigé)

Exercice N°1 : Signe et valeur, complément à 1, complément à 2

Représenter sur 8 bits les nombres entiers signés: +45(10); -65(10), -128(10) par les méthodes :
a/ Signe et valeur absolue (SVA)
b/ Complément à 1 (CP1)
c/ Complément à 2 (CP2)

Solution :
On commence d’abord par convertir ces nombres en binaire et les écrire sur 8 bits ensuite on
les représentent par ces trois méthodes.

a) Signe et valeur absolue (SVA) :

1) +45(10) = +101101(2) = 00101101(2)

On a ajouté deux zéro à gauche pour qu’il soit représenté sur 8 bits.

+45(10) = 0 | 0101101(2)

bit Valeur absolue du nombre représentée sur 7 bits

de signe

Remarque : bit de signe = 0 si le nombre est positif,

1 sinon

2) 65(10) = 1000001(2) = 01000001 (2)

-65(10) = 1 | 1000001 (2)

bit Valeur absolue du nombre représentée sur 7 bits

de signe

Remarque : un nombre négatif commence toujours par 1.

3) 128(10) = 10000000(2)

On remarque que la valeur absolue du nombre -128 est déjà sur 8 bits donc ce
n’est pas possible de représenter le bit de signe dans ce cas. En conclusion, il est
impossible de représenter -128(10) par la méthode du SVA.

Remarque : En d’autre terme, on peut dire que les nombres possibles à représenter sur
8 bits par la méthode du SVA sont compris dans l’intervalle [-127, 127], on remarque
que -128 n’appartient pas à cet intervalle.
 Université des Sciences et Technologie M. Boudiaf Structure Machine 1
Faculté des Mathématiques et Informatique
Département d’Informatique TD2 (Corrigé)

b) Complément à 1 (CP1) :
Il s’agit, dans cette méthode, d’inverser les bits du nombre binaire ( 0 devient 1 et vice
versa).

1) +45(10) est positif donc il sera représenté par le code binaire naturel,
d’où : +45(10) = 00101101(2)

2) 65(10) = 01000001 (2)

-65(10) = cp1(65) = cp1(01000001) = 10111110(2)

3) 128(10) = 10000000(2)
-128(10) = cp1(128) = cp1(10000000) = 01111111(2) >0 (car le premier bit est égal
à zéro ce qui indique un nombre positif alors que -128 est négatif). D’où, il est
impossible de représenter -128 par la méthode du CP1.

Remarque : Par ailleurs, on sait que dans la méthode du CP1 l’intervalle des
nombres codés sur 8 bits est [-127, 127]. On remarque que le nombre -128 est en
dehors de l’intervalle ce qui explique pourquoi c’est impossible de le représenter.

c) Complément à 2 (CP2) :
Etant donné N un nombre en binaire, pour calculer son complément à 2, il suffit
d’ajouter un 1 à son complément à 1.
Donc : cp2(N) = cp1(N) + 1
Remarque : il existe d’autres méthodes pour calculer le complément à 2 mais dans ce
corrigé, on va opter pour celle-ci.

1) +45(10) >0 donc il sera représenté par le code binaire naturel,

d’où : 45(10) = 00101101(2)

2) -65(10) = cp2(65) = cp1(65) + 1 = cp1(01000001) + 1 =10111110 + 1 = 10111111(2)

3) -128(10) = cp2(128) =cp1(128)+1= cp1(10000000) + 1= 01111111+1= 10000000(2)

Remarque : On remarque qu’on peut représenter -128 par la méthode de cp2

puisqu’il est inclut dans l’intervalle [-128, 127] des nombres codés sur 8 bits et qui
peuvent être représentables par cette méthode.

Exercice N°2 : Décodage des nombres entiers signés

Donner la valeur décimale des codes binaires suivants représentés sous le format CP2.
00110110 ; 11101000
Solution :
 00110110 (2) >0 (car son bit de poids fort est égal à 0)
 Université des Sciences et Technologie M. Boudiaf Structure Machine 1
Faculté des Mathématiques et Informatique
Département d’Informatique TD2 (Corrigé)

Puisqu’il s’agit d’un nombre positif, on le convertit directement en décimal.

76543210
D’où : 00110110 (2) =25+24+22+21 = 32+16+4+2= +54(10)

 11101000(2) <0 (car son bit de poids fort est égal à 1). Il représente le complément à 2
d’un nombre négatif N et il est demandé de trouver la valeur décimale de N.
D’où : 11101000(2) = cp2(|N|)
Alors : |N| = cp2 (cp2(|N|))
= cp2(11101000)
= cp1(11101000) +1
= 00010111+1
= 00011000(2)
Maintenant, on calcule sa valeur en décimal :
7654 3210
|N| = 00011000(2) = 24+23 =16+8= 24(10)

Donc : N= -24(10)

Exercice N°3 : opérations en cp2

Soient N1 et N2 trois entiers signés représentés sur 08bits.
Sachant que N1= 01101110(2) et N2=01110011(2)
Effectuer en complément à 2 les opérations : 1) N1-N2 ; 2) N2-N1 ; 3) -N1-N2.

Solution :

1) N1-N2 = N1+(-N2) = N1+cp2(N2)

Cp2(N2) = Cp1(N2)+1
= Cp1(01110011)+1
= 10001100+1 0 1 1 10 11 1 1 0
= 10001101(2) + 1 0 0 0 1 1 0 1
= 1 1 1 1 1 0 1 1
Donc : N1-N2 = N1+cp2(N2)
= 11111011(2)
= R <0 (le bit à gauche est égal à 1)

Etant donné que R<0 et mathématiquement nous avons N1-N2 <0 donc le résultat est
cohérent. Il reste à calculer sa valeur en décimal. Mais comme N1-N2 est négatif, il
faut d’abord calculer son complément à 2.
Cp2(R) = Cp1(R) +1
= Cp1(11111011)+1
= 00000100+1
= 00000101(2) =5(10) → R= N1-N2 = -5(10)

2) N2-N1= N2+(-N1) = N2+cp2(N1)

Cp2(N1) = Cp1(N1) +1
 Université des Sciences et Technologie M. Boudiaf Structure Machine 1
Faculté des Mathématiques et Informatique
Département d’Informatique TD2 (Corrigé)

= Cp1(01101110) +1 bit de dépassement à

= 10010001+1 ignorer
1
= 10010010(2) 0 11 11 1 0 10 1 1
+ 1 0 0 1 0 0 1 0
Donc : N2-N1= N2+cp2(N1) = 00000101(2) = 1 0 0 0 0 0 1 0 1
= R >0
Etant donné que R>0 et mathématiquement nous avons N2-N1 >0 alors le résultat est
cohérent. Il reste à convertir R en décimal.

R=N2-N1= 00000101(2) = +5(10)

1 0 0 1 0 0 1 0
3) -N1-N2 = (-N1) + (-N2) = cp2(N1)+cp2(N2) + 1 0 0 0 1 1 0 1
= 1 0 0 0 1 1 0 1 1
Cp2(N1) = 10010010(2) déjà calculé
Cp2(N2) = 10001101(2) déjà calculé

Donc : -N1-N2 = cp2(N1)+cp2(N2) =00011011 > 0

On a trouvé que –N1-N2 >0 alors que mathématiquement il est négatif.

De ce fait, on dit que c’est un overflow (ou dépassement de capacité). En d’autres

termes, la machine ne peut pas calculer cette opération sur 8 bits seulement.

Exercice N°4 : la virgule fixe

Représenter le nombre réel -127,2(10) suivant en format virgule fixe (1 bit de signe, 8 bit
pour la partie entière et 7 bits pour la partie fractionnaire.

Solution :
On commence par convertir le nombre 127.2(10) en binaire :
127,2(10) = 1111111, 0011001(2)

La représentation du nombre -127,2(10) par la virgule fixe est donnée par :

-127,2(10) = 1|01111111|0011001

bit de signe Partie entière sur 8 bits Partie fractionnaire sur 7 bits
bs PE PF

Exercice N°5 : la virgule flottante simple précision

Convertir le nombre 8,625(10) en virgule flottante simple précision suivant la norme IEEE
754.

Solution :
On convertit le nombre 8,625(10) en binaire :
8,625(10) = 1000,101(2)
 Université des Sciences et Technologie M. Boudiaf Structure Machine 1
Faculté des Mathématiques et Informatique
Département d’Informatique TD2 (Corrigé)

Avant de représenter un nombre en virgule flottante, il faut d’abord l’écrire en format

normalisé qui est : N= ± 1, M × bE
Sachant que :
M : mantisse (ou pseudo mantisse)
b : la base (dans ce cas b=2)
E : exposant réel

 On va normaliser le nombre 8,625 :

+8,625(10) = +1000,101(2) = +1,000101×23

Où : M = 000101(2)
E = 3(10)

Le format de représentation des nombres en virgule flottante simple précision est sur 32 bits
organisé comme suit :

1 bit de signe (bs) Exposant décalé (sur 8 bits) Mantisse (sur 23 bits)

Exposant Décalé = Exposant Réel + Décalage

Décalage = 127

 Calculons l’exposant décalé :

On a l’exposant réel = 3(10)

Donc : Exposant décalé = 3 + 127 = 130(10) = 10000010(2)

Enfin nous aurons :

+8,625(10) = 0 |10000010| 00010100000000000000000

 Donner la valeur décimale du nombre suivant, codé suivant la norme IEEE 754 et
représenté en binaire.
N = 0 01111011 00000000000000000000000

Remarque : le nombre N est codé sur 32 bits donc il est représenté en virgule flottante simple
précision.

N= 0 | 01111011| 00000000000000000000000

bs =0 Exposant décalé (sur 8 bits) Mantisse (sur 23 bits)

alors N>0 Exposant réel = Exposant décalé-127 M= 00…0(2)
127(10) = 1111111(2)
d’où : Exposant réel = 01111011-1111111
= - 100(2)
= - 4(10)

L’écriture normalisée de N est :

N = +1,00…0 × 2-4
N = 2-4(2)
Enfin nous aurons : N = 0,0625(10)
 Université des Sciences et Technologie M. Boudiaf Structure Machine 1
Faculté des Mathématiques et Informatique
Département d’Informatique TD2 (Corrigé)

Exercice N°6 : La virgule flottante double précision

Ecrire le nombre -0.625(10) en virgule flottante double précision suivant la norme IEEE 754 .

Solution :
Commençons d’abord par convertir -0.625(10) en binaire et l’écrire en format normalisé :

-0, 625(10) = - 0,101(2) = - 1,01 × 2-1

Où : M = 01(2)
E = -1(10)

Le format de représentation des nombres en virgule flottante double précision est sur 64 bits
organisé comme suit :

1 bit de signe (bs) Exposant décalé (sur 11 bits) Mantisse (sur 52 bits)

Exposant Décalé = Exposant Réel + Décalage

Décalage = 1023

 Calculons l’exposant décalé :

On a l’exposant réel = -1(10)
Donc : Exposant décalé = -1 + 1023 = 1022(10) = 01111111110(2)

Enfin nous aurons :

-0,625(10) = 1 |01111111110| 01000…0

 Donner la valeur décimale du nombre suivant, codé suivant la norme IEEE 754 et
représenté en Hexadécimal.

N= C00F000000000000(16) = 110000000000111100000…0(2)

Remarque : le nombre N est codé sur 64 bits donc il est représenté en virgule flottante double
précision.

N= 1 | 10000000000 | 111100000…0

bs =1 Exposant décalé (sur 11 bits) Mantisse (sur 52 bits)

alors N<0 M= 11110000…0(2)
Exposant réel = Exposant décalé-1023
Exposant décalé = 10000000000 (2) = 210 = 1024(10)
d’où : Exposant réel = 1024-1023
= +1(10)

D’où l’écriture normalisée de N est :

N = -1,111100…0 × 21
N = -11,111(2)
Enfin nous aurons : N = -3,875(10)