Chapitre II – DÉFINITION DES SYSTÈMES LOGIQUES

2.1 LES NOMBRES DANS LES SYSTÈMES LOGIQUES

Les humains comptent en DÉCIMAL

2.1.1 DÉCIMAL:
o Base 10
o 10 chiffres: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
o M C D U
o --------------------
o 5 3 0 4

= 5 x 1000 + 3 x 100 + 0 x10 + 4 x 1

= 5304 (base 10)
Note:
1 = 10 ^ 0
10 = 10 ^ 1
100 = 10 ^ 2
1000 = 10 ^ 3 etc...

Les systèmes logiques (ordinateur) utilisent le BINAIRE

2.1.2 BINAIRE:
o Base 2
o "0" et "1"
o Exemple:
o 8 4 2 1
o -------------------
o 1 0 1 1
o
=1x8+0x4+1x2+1x1
= 1011 base 2
o Note:
1=2^0
2=2^1
4=2^2
8=2^3
16 = 2 ^ 4 etc...

LSB : "Least Significant Bit" 1=2^0

MSB : "Most Significant Bit" 8=2^3

Remarque 2 bits ... 2^2 = 4 combinaisons

4 bits ... 2^4 = 16 combinaisons
8 bits ... 2^8 = 256 combinaisons
Dans les premiers ordinateurs on utilisait des groupes de 4 bits

o 8 bits = 1 byte (octet)

2.1.3 OCTAL
o Octal est Base 8
o exemple. 9 base 10 = 001001 base 2 = 11 base 8

2.1.4 HEXADECIMAL
o Utilise les chiffres 0-9 et A, B, C, D, E, F
o Hexadécimal est Base 16
o exemple. 30, base 10 = 00011110, base 2 = 1E, base 16
o On ecrit "$1E" or "1Eh"

Décimal Binaire Octal Hex

(base 10) (base 2) (base 8) (base 16)
0 0000 0 0
1 0001 1 1
2 0010 2 2
3 0011 3 3
4 0100 4 4
5 0101 5 5
6 0110 6 6
7 0111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
35 10 0011 43 23
100 110 0100 144 64
255 1111 1111 377 FF

2.1.5 UNITÉS UTILISÉES EN BINAIRE

1 chiffre binaire = 1 bit
8 bits = 1 byte (octet)
1 kilobyte (1k) = 2^10 bytes = 1024 bytes
1 Megabyte (1Mb) = 2^20 bytes = 1024 kbytes
1 Gigabyte (1Gb) = 2^30 bytes = 1024 Mbytes
1 Terabyte (1Tb) = 2^40 bytes = 1024 Gbytes
2.1.6 ÉCRITURE D'UN NOMBRE EN GÉNÉRAL DANS UNE BASE b ET CONVERSION
DES SYSTÈMES DE NUMÉROTATION

Nombre entier:
(an . . . a2 a1 a0 )b = (bn an + . . . + b2 a2 + b1 a1 + b0 a0 )10

Nombre fractionnel:
(an . . . a1 a0 ,a-1 a-2 . . . )b =
(bn an + . . . + b1 a1 + b0 a0 + b-1 a-1 + b-2 a-2 . . . )10

Conversion des systèmes de numérotation

Exemples: (Voir différentes techniques et exemples au cours)

- Conversion décimale / binaire : 8710 = 1 0 1 0 1 1 12

- Conversion hexadécimale / binaire: 3B916 =11101110012

- Conversion binaire / octal: 10110, 0011102 =26,168

Représentation des fractions dans des bases différentes:

Exemple: Soit le nombre 0,8125 en décimal, comment obtenir les chiffres 8, 1, 2 et 5 de
0,8125?
Réponse:
10 × 0,8125 = 8,125 ce qui donne 8
10 × 0,125 = 1,25 ce qui donne 1
10 × 0,25 = 2,5 ce qui donne 2
10 × 0,5 =5 ce qui donne 5

On remarque qu'à partir de cet exemple en décimal on peut déduire une généralisation à toute
base b. Par exemple trouver la représentation du nombre décimal 0,8125 dans la base 2 :

2 × 0,8125 = 1,625 ce qui donne 1

2 × 0,625 = 1,25 ce qui donne 1
2 × 0,25 = 0,5 ce qui donne 0
2 × 0,5 = 1,0 ce qui donne 1

Donc 0,8125 10 ↔ 0,1101 2

Vérification: 0,1101 = 1×1/2 + 1×1/4 + 0×1/8 + 1×1/16

= 0,8125
Exercice:
Obtenir la représentation hexadécimale (base 16) du nombre 0,781218 10
16 × 0,781218 = 12,5 ce qui donne C (équivalent du 12 en héxa)
16 × 0,5 = 8,0 ce qui donne 8
Donc: 0,781218 10 = 0,C8 16

Exercice:
Trouver l'équivalent en octal du nombre fractionnel décimal suivant: 0,3125 10
8 × 0,3125 = 2, 5 ce qui donne 2
8 × 0,5 = 4,0 ce qui donne 4
Donc 0,3125 10 = 0,24 8

Exercice:
Convertir 125,3125 10 en octal (base 8)
Partie entière: 125 10 → 175 8
Partie fractionnelle: 0,3125 10 → 0,24 8
Donc: 125,3125 10 → 175,24 8

Exercice:
Convertir 125,3125 10 en binaire (base 2)
Réponse: 125,3125 10 → 1111101,0101 2

2.1.7 REPRÉSENTATIONS EN "VIRGULE FIXE"

2.1.7.1 Nombres sans signe :

1° Habituellement, un nombre est représenté par sa traduction en binaire, sur un nombre fixé
de bits (en général 8, 16, 32 ou 64) ; la position de la virgule est fixe. Par exemple, si 8 bits
sont alloués à la partie supra-unitaire et 8 bits à la partie sub-unitaire du nombre à représenter,
(56,3125)10 est représenté par

0 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0
partie supra-unitaire partie sub-unitaire

La valeur maximale que nous pouvons représenter est 28 -2-8 (11111111,11111111 en binaire)
et la valeur minimale 2-8 (0,00000001). Nous constatons que la fidélité de la représentation (le
nombre de chiffres significatifs gardés) dépend directement de la valeur à représenter : plus le
nombre à représenter est petit, moins on peut garder de chiffres significatifs. Ce désavantage
se manifeste pour toutes les représentations en "virgule fixe".

2° Une autre possibilité, moins courante, est d'employer une représentation de type Décimal
Codé Binaire Naturel (Binary Coded Decimals). Dans ce cas, chaque chiffre du nombre
décimal à représenter est traduite individuellement en binaire sur 4 bits, et le nombre est
représenté par la concaténation de ces groupes de 4 bits (représentation BCD compacte).
Par exemple, pour (56,3125)10 :

5 6 , 3 1 2 5
0101 0110, 0011 0001 0010 0101

En version non compacte, chaque quartet qui code un chiffre décimal constitue le quartet le
moins significatif d'un octet, l'autre quartet étant 0000 (ex. : 5 0101 00000101). Le nombre est
représenté par la concaténation de ces octets.
Cette technique de représentation est moins économique, mais facilite la traduction.

2.1.7.2 Nombres avec signe :

(Voir plus bas, paragraphe 2.2.2, pour les définitions concernant les compléments à 1 et à 2)

1° Une première possibilité : le premier bit (le plus significatif) est réservé au signe (0 si N 0,
1 sinon), les autres contiennent la traduction en binaire de la valeur absolue :

signe partie supra-unitaire partie sub-unitaire

MSB LSB

Par exemple, avec 7 bits pour la partie supra-unitaire et 8 bits pour la partie sub-unitaire, nous
obtenons :

(+56,3125)10 = (+111000,0101)2
0 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0
(-56,3125)10 = (-111000,0101)2
1 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0

2° Complément à 1 (C 1 (N)) : le premier bit (le plus significatif) est réservé au signe (0 si N 0,
1 sinon), les autres contiennent la traduction en binaire de la valeur si le nombre est positif, ou
les chiffres opposés (0 1) à ceux de la traduction si le nombre est négatif. Par exemple, avec 7
bits pour la partie supra-unitaire et 8 bits pour la partie sub-unitaire, nous obtenons :

(+56,3125)10 = (+111000,0101)2
0 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0
(-56,3125)10 = (-111000,0101)2
1 1 0 0 0 1 1 1 1 0 1 0 1 1 1 1

3° Complément à 2 (C 2 (N), ou complément vrai). Le premier bit (le plus significatif) est
réservé au signe (0 si N 0, 1 sinon). Considérons que n des bits suivants sont réservés à la
partie supra-unitaire des nombres. Alors la représentation signe mis à part contient la
traduction en binaire de la valeur si le nombre est positif, ou la différence entre 2n et le résultat
de cette traduction si le nombre est négatif. Par exemple, avec 7 bits pour la partie supra-
unitaire et 8 bits pour la partie sub-unitaire, nous obtenons :

(+56,3125)10 = (+111000,0101)2
0 0 1 1 1 0 0 0 0 1 0 1 0 0 0 0
 (-56,3125)10 = (-111000,0101)2 27 - 111000,0101 = 1000111,10110000 =
1 1 0 0 0 1 1 1 1 0 1 1 0 0 0 0

Le plus grand nombre positif représentable : 01111111.11111111 +127,99609375.

Le plus petit nombre positif représentable : 00000000.00000001 +0,00390625.
Le plus grand nombre négatif représentable : 11111111.11111111 -0,00390625.
Le plus petit nombre négatif représentable : 10000000.00000000 -128.
Ecart minimal entre deux nombres représentables : 0,00390625 (constant).

4° Codage par excédent (employé pour des nombres sans partie fractionnaire) : la
représentation contient la traduction en binaire de la somme entre le nombre à représenter et
une valeur positive fixe (choisie telle que le résultat soit toujours positif pour les nombres
qu'on veut représenter). Par exemple, avec 8 bits, par excédent à 128 (= 27 ), nous obtenons :

(+56)10 = (+111000)2 27 + 111000 = 10111000 =

1 0 1 1 1 0 0 0
7
(- 56)10 = (- 111000)2 2 - 111000 = 01001000 =
0 1 0 0 1 0 0 0

Nous constatons que le premier bit ne correspond plus à la convention de signe employée
jusqu'ici.

2.1.8 REPRÉSENTATIONS EN "VIRGULE FLOTTANTE"

Les nombres sont d'abord mis sous forme normale :

N=(± 0, a-1 a-2 a-3 ...)x b ±n avec a-1 ≠ 0 (normalisation)

a-1 a-2 a-3 s'appelle mantisse et n exposant.
Par exemple :
(56,3125)10 = (+111000,0101)2 = 0,1110000101 × 26 .

Des bits sont réservés pour représenter le signe, l'exposant et la mantisse.

1° En simple précision (IEEE 754), 32 bits sont employés pour la représentation. Ainsi, le
nombre 1,f × 2e -127 est représenté sous la forme suivante :

signe e f
31 30 23 22 0
Par exemple :
1 10000001 01000000000000000000000 représente :
signe = 1 nombre négatif
e - 127 = (10000001)2 - 127 = 129 - 127 = 2
f = (0,01)2 = 0,25
donc le nombre représenté est -1,25 × 22 = -5.
+0,25 = (0,01)2 est représenté par :
nombre positif signe = 0
(0,01)2 = 1,0 × 2-2 = 1,0 × 2125-127
donc +0,25 est représenté par 0 01111101 00000000000000000000000

2° En double précision (IEEE 754), 64 bits sont employés pour la représentation. Le nombre
1,f × 2e -1023 est représenté sous la forme suivante :

signe e f
63 62 52 51 0

Interprétation complète des codes possibles :

e f représente
0 0 0
0 0 0,f × 2-127 ou* 0,f × 2-1023
0 < e < e max f 1,f × 2e -127 ou* 1,f × 2e -1023
e max (255 ou* 2047) 0
e max (255 ou* 2047) 0 NaN (Not a Number)
(*simple ou double précision)

NaN est le résultat, par exemple, de −1 ou de log(1) ; le résultat d'une opération dont un des
arguments est NaN doit être NaN. est le résultat, par exemple, des divisions par 0 ou de
log(0) ; peut intervenir dans des calculs, par exemple 1/ = 0.

Exercice
Montrer comment s'écriraient les nombres suivants sous les formats IEEE 754 simple (32
bits) et double (64 bits) précision.

(a) + 1.0111 × 27
Simple précision
Double précision
(b) - 1.10010 × 22
Simple précision
Double précision
0 10000110 0111 0000 ......00
0 10000000110 0111 0000 .....00
1 10000001 1001 0000 ......00
1 10000000001 1001 0000 .....00
2.2 ARITHMÉTIQUE EN BINAIRE

2.2.1 NOMBRES EN BINAIRE, SANS SIGNE

2.2.1.1 L'addition exemples (nombres représentés sur 8 bits) :

1° pas de retenue (transport du MSB)
0100 1010 +
1000 1100
1101 0110

2° retenue (transport du MSB) dépassement du format

0100 1010 +
1100 1100
10001 0110

2.2.1.2 La soustraction (A - B) exemples (nombres représentés sur 8 bits) :

1° A B : pas de retenue (transport vers le MSB)

1000 1010 -
0100 0100
0100 0110

2° A < B : retenue (transport vers le MSB) résultat négatif, à représenter sur plus de 8 bits
0100 0100 - 68 -
1000 1010 138
1011 1010 - 70
(70)10 = (0100 0110)2 , (-70)10 = (1011 1010)2 en complément à 2, sur 8 bits

mais :
0100 0100 - 68 -
1100 1010 202
0111 1010 - 134

(134)10 = (1000 0110)2 , (-134)10 ne peut pas être représenté en complément à 2 sur 8 bits,
9 bits sont nécessaires : (-134)10 = (1 0111 1010)2

2.2.1.3 La multiplication exemple (facteurs représentés sur 8 bits) :

1° 00101011 ×
00001001

00101011
00101011

110000011 (9 bits nécessaires)

2° 11111111 ×
11111111

11111111
11111111
11111111
11111111
11111111
11111111
11111111
11111111

1111111000000001 (16 bits nécessaires)

Il faut réserver au produit le double du nombre de bits réservés aux facteurs.

Cas particulier : multiplication par 2n = déplacement à gauche de n positions.

2.2.1.4 La division exemple (dividende représenté sur 8 bits, diviseur sur 4 bits) :

La division d'un nombre binaire est identique à la division d'un nombre décimal.
Dividende/diviseur = quotient

Exemple : en décimal 12 divisé par 4

12 Dividende
-4 Première soustraction du diviseur
8 Premier reste
-4 Deuxième soustraction du diviseur
4 Deuxième reste
-4 Troisième soustraction du diviseur
0 Reste de zéro
Dans cet exemple, le diviseur est soustrait du dividende trois fois avant l'obtention d'un reste 0
(ou inférieur au diviseur).
Le signe du quotient dépend du signe du dividende et du diviseur.

Exemple de nombres binaires signés:

Les nombres sont 01110 par 01010
Les signes des nombres sont positifs, donc le quotient sera positif. Le quotient est mis à zéro
au départ 00000. On ignorera toutes les retenus.

01110 Dividende
00110 Complément à deux du diviseur, ce qui revient à une soustraction (voir plus bas).
00100 Premier reste positif, on incrémente le quotient 00001
00110 Complément à deux du diviseur
01010 Deuxième reste positif, on incrémente le quotient 00010
00110 Complément à deux du diviseur
00000 Reste de zéro, on incrémente le quotient 00011
Cas particulier : division par 2n = déplacement à droite de n positions.

2.2.2 NOMBRES EN COMPLÉMENT À 2

2.2.2.1 Obtenir le complément à 2 (pour nombres entiers) :

Nous considérons que la représentation du nombre se fait sur n bits, dont 1 bit de signe.
1° C2 (N) = 2n - N, par exemple

positif négatif : 0100 1000 1 0000 0000 - 0100 1000 = 1011 1000 (signe inclus)

négatif positif : 1011 1000 1 0000 0000 - 1011 1000 = 0100 1000 (signe inclus)

2° C2 (N) = C1 (N) + 1, le C1 (N) étant obtenu en inversant tous les chiffres de la représentation
en binaire du nombre (0 1), par exemple

positif négatif : 0100 1000 1011 0111, +1 1011 1000 (signe inclus)
négatif positif : 1011 1000 0100 0111, +1 0100 1000 (signe inclus)

2.2.2.2 L'addition exemples (nombres représentés sur 8 bits, dont 1 bit de signe) :
1° pas de retenue, pas de dépassement du format
0100 1010 +
0010 1100
0111 0110
résultat correct

2° pas de retenue, mais dépassement du format

0100 1010 +
0100 1100
1001 0110
résultat incorrect sur 8 bits (la somme de deux nombres positifs ne peut pas être un nombre
négatif)

3° retenue, mais pas de dépassement du format

0100 1010 +
1100 1100
0001 0110
résultat correct (la retenue n'est pas prise en compte)

4° retenue et dépassement du format

1000 1010 +
1100 1100
0101 0110
résultat incorrect sur 8 bits (la somme de deux nombres négatifs ne peut pas être un nombre
positif)
Observation : le format n'est jamais dépassé quand les termes ont des signes opposés.
Règle pour savoir si un dépassement a eu lieu :
dépassement (transport vers le MSB transport du MSB).
2.2.2.3 La soustraction en complément à deux :
Rappels: a - b = a + (-b)
Le nombre négatif peut être généré par son complément à 2
Soustraction = addition avec le complément à 2 du nombre à soustraire.

Représentation circulaire de nombres en complément à 2 sur 3-bits

Soustraction en complément à 2:

Cas 1: Soustraire un nombre d'un nombre plus grand que lui.

1. Déterminer le complément à 2 du petit nombre
2. Ajouter au grand nombre le complément à 2 du petit
3. Négliger la retenue (il y aura toujours une retenue dans ce cas)

Cas 2: Soustraire un grand nombre d'un plus petit.

1. Déterminer le complément à 2 du grand nombre
2. Ajouter au petit nombre le complément à 2 du grand
3. Il n'y a pas de retenue dans ce cas, le résultat est en complément à deux et il
est négatif.
4. Pour obtenir le résultat sous une forme correcte il faut prendre le
complément à 2 et changer de signe.

Exemple: Soustraire en binaire 1100 de 0101

Il faut ajouter le C'2(1100) à 0101 ce qui donne 0101+0100= 1001 et il
n'y pas de retenue. Pour le résultat final il faut calculer le C'2(1001) et changer
son signe ce qui donne - 0111

Remarque: On dit qu'il y dépassement (overflow) quand, par exemple, l'addition de deux
nombres positifs donne un résultat négatif ou alors l'addition de deux nombres négatifs donne
un résultat positif.
 2.2.3 Nombres en DCBN compacte
Les quartets sont entre 0000 (correspondant à 0)et 1001 (correspondant à 9).

2.2.3.1 L'addition exemples (nombres à deux chiffres décimaux, représentés sur 8

bits) :
En général, nous effectuons l'addition en binaire sans prendre en compte le caractère
particulier du codage, et ensuite nous corrigeons le résultat de la façon suivante : s'il y a une
retenue dans le quartet ou si le quartet contient une valeur supérieure à 9 (1001), on ajoute 6
(0110) au quartet (et on propage l'éventuelle nouvelle retenue vers le quartet supérieur).
Par exemple :
0010 1001 + 29 +
0100 0100 44
0110 1101 73
quartet inférieur supérieur à 1001, donc la correction doit être appliquée 0111 0011 (73),
ou
0000 1001 + 9 +
0100 1000 48
0101 0001 57
retenue obtenue dans le quartet inférieur, la correction doit être appliquée 0101 0111 (57).

2.2.3.2 La soustraction (A - B) exemples (nombres à 2 chiffres décimaux, sur 8 bits) :

En général, nous effectuons l'addition en binaire sans prendre en compte le caractère
particulier du codage, et ensuite nous corrigeons le résultat de la façon suivante : nous
soustrayons 6 (0110) de tout quartet qui a demandé une retenue.
Par exemple :
0010 0000 - 20 -
0000 1001 9
0001 0111 11
retenue demandée par le quartet inférieur, donc la correction doit être appliquée à ce quartet
0001 0001 (11).

2.3 REPRÉSENTATION DES CARACTÈRES

Standard ASCII 8 (8 bits) :
Exemple : A = 65 en décimal
A = 41 en hexadécimal
Représentation d'un caractère sur un octet
(ASCII)