Chapitre 4 la représentation des nombres. Chapitre 4 : La représentation des nombres 1 - Introduction 1.1 – Notion de mot 2 - La représentation des entiers.

Présentation au sujet: "Chapitre 4 la représentation des nombres. Chapitre 4 : La représentation des nombres 1 - Introduction 1.1 – Notion de mot 2 - La représentation des entiers."— Transcription de la présentation:

1 Chapitre 4 la représentation des nombres

2 Chapitre 4 : La représentation des nombres 1 - Introduction 1.1 – Notion de mot 2 - La représentation des entiers négatifs 2.1 – Méthode qui ne marche pas #1 2.2 – Méthode qui ne marche pas #2 2.3 – Méthode qui marche 3 - La représentation des nombres fractionnaires 3.1 – Les nombres en virgule fixe 3.2 – Les nombres en virgule flottante

3 1.1 – Notion de mot Les systèmes informatiques manipulent des bits et travaillent sur des paquets de longueur fixe que l’on appelle mot. La taille d'un mot dépend de l'architecture de la machine (8, 16, 32, 64 bits)... ou plus Les processeurs actuels (Intel Core 2 en 2008) utilisent des mots de 64 bits. Le mot se décline en demi-mots, double mots, gros mots...

4 Chapitre 4 : La représentation des nombres 1 - Introduction 1.1 – Notion de mot 2 - La représentation des entiers négatifs 2.1 – Méthode qui ne marche pas #1 2.2 – Méthode qui ne marche pas #2 2.3 – Méthode qui marche 3 - La représentation des nombres fractionnaires 3.1 – Les nombres en virgule fixe 3.2 – Les nombres en virgule flottante

5 2 – Représentation des entiers négatifs Vous savez maintenant comment représenter une valeur avec uniquement des 0 et des 1 Par exemple (12) 10 s'écrit (1.100) 2... mais comment faire pour représenter (-12) 10 ? Soyons clair, on vas laisser l'écriture ( 1.100) 2 aux blondes...

6 2.1 – Les entiers signés (Dit méthode qui marche pas #1) La solution la plus simple pour représenter le signe consiste à réserver un bit pour ce signe, les autres bits représentants la valeur absolue du nombre. Par convention, on utilisera le premier bit (celui de gauche) pour représenter le signe : ● 0 pour un nombre positif ● 1 pour un nombre négatif. On parle de données signées quand on utilise cette convention. Exemple: ( 0 0.0 1 1.0 1 1 ) 2 -> (27) 10 ( 1 0.0 1 1.0 1 1 ) 2 -> (-27) 10 Avec cette méthode, on peut représenter sur 8 bits l’intervalle de nombres entiers : [-(2 7 - 1), (2 7 - 1)] soit [-127, +127] Plus généralement, sur n bits, on aura l’intervalle [-(2 n-1 - 1), (2 n-1 - 1)]

7 2.1 – Les entiers signés (Dit méthode qui marche pas #1) Si on fait des calculs avec cette méthode : Par exemple 7 – 5 7 + (-5) --------- 2 Pour économiser de la place dans les circuits, on ne fera pas 7 – 5 mais 7 + (-5)... Mathématiquement c'est la même chose, mais électroniquement, cela évite d'avoir un circuit dédié à la soustraction : C'est une addition dans les deux cas. 0.000.1110 0.000.1011 + 10.001.100 12 10 - Faux ! Voilà pourquoi on n'utilise pas cette méthode çi.

8 2.2 – Le complément restreint (Dit méthode qui marche pas #2) Une autre méthode pour représenter un nombre négatif consiste à inverser tout les bits. A nouveau, on utilise le bit de gauche (dit bit de poids fort) pour représenter le signe : ● 0 pour un nombre positif ● 1 pour un nombre négatif. Pour représenter -27, par exemple: 27 10 0 0. 0 1 1. 0 1 1 2 0 0100111 Si le nombre commence par un 0 : Si le nombre commence par un 1 : C'est un nombre positif Il 'suffit' de le convertir en décimal pour en connaître la valeur C'est un nombre négatif Pour en connaître la valeur il faut : Calculer le complément (inverser tout les bits) Convertir en décimal la valeur absolue

9 2.2 – Le complément restreint (Dit méthode qui marche pas #2) Exercice : Déchiffrer les nombres suivants 11.111.110 2 -> ? 10 - 00.000.001 2 1 10 00.000.00 2 -> ? 10 0 10 11.111.111 2 -> ? 10 -0 10 2 représentations différentes pour la même valeur... Faux !

10 2.3 – Le complément vrai Une troisième méthode pour représenter un nombre négatif consiste à calculer le complément restreint plus 1. C'est ce qu'on appelle le complément vrai. Pour représenter -27, par exemple: 27 10 0 0. 0 1 1. 0 1 1 2 0 0100111 Si le nombre commence par un 0 : Si le nombre commence par un 1 : C'est un nombre positif Il 'suffit' de le convertir en décimal pour en connaître la valeur C'est un nombre négatif Pour en connaître la valeur il faut : Calculer le complément (inverser tout les bits) Convertir en décimal la valeur absolue <- Complément restreint Soustraire 1 + 1 1 1 1 0 0 1 0 1 <- Complément vrai

11 2.3 – Le complément vrai Pour un nombre de 8 bits : Le plus grand nombre positif est 01.111.111 Soit 2 7 – 1 Soit 127 Le plus petit négatif est 10.000.000 Soit -2 7 Soit -128 On peut en déduire une formule générale, fonction du nombre de bits : Pour n bits, on pourra coder en complément vrai, les entiers de l’intervalle [-2 (n-1), 2 (n-1) - 1]

12 2.3 – Le complément vrai 1er cas : Pas de débordement, Résultat négatif Exemple : -64 10 + 16 10 = - 48 10 Négatif, donc : 1° : |-64| 10 -> ? 2 0 1 0 0 0 0 0 0 2° : 1/x 1 0 1 1 1 1 1 1 3° : +1 1 1 0 0 0 0 0 0 Positif donc : 1° : 16 10 -> ? 2 0 0 0 1 0 0 0 0 + 1 1 0 1 0 0 0 0 Vérification Commence par un 1 => Négatif 1 1 0 1 0 0 0 0 1°: -1 1 1 0 0 1 1 1 1 2°: 1/x 0 0 1 1 0 0 0 0 3°: x 2 -> x 10 32 + 16 = 48 OK

13 2.3 – Le complément vrai 2eme cas : Débordement, Résultat positif Exemple : 64 10 + -16 10 = 48 10 0 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 + 1 0 0 1 1 0 0 0 0 1°: 16 10 -> ? 2 2°: 1/x 3°: +1 0 0 0 1 0 0 0 0 1 1 1 0 1 1 1 1 1 1 1 1 0 0 0 0 Comme on travaille sur 8 bits... On ne garde que 8 bits 0 0 1 1 0 0 0 0 Vérification Commence par un 0 => Positif 32 + 16 = 48 OK

14 2.3 – Le complément vrai 3eme cas : Débordement, Résultat négatif Exemple : -64 10 + -16 10 = -80 10 1 1 0 0 0 0 0 0 1 1 1 1 0 0 0 0 + 1 1 0 1 1 0 0 0 0 Plutôt que de recalculer, on remonte de 2 pages... Plutôt que de recalculer, on remonte d'1 page... On ne garde que les 8 bits de droite Résultat : 1 0 1 1 0 0 0 0 Vérification : Le résultat commence par un 1; donc il est négatif Ça c'est bon 1 0 1 1 0 0 0 0 1° : -1 - 1 1 0 1 0 1 1 1 1 2° : 1/x 0 1 0 1 0 0 0 0 3° : ? 2 -> ? 10 64 + 16 = 80 Ça aussi ! OK

15 Chapitre 4 : La représentation des nombres 1 - Introduction 1.1 – Notion de mot 2 - La représentation des entiers négatifs 2.1 – Méthode qui ne marche pas #1 2.2 – Méthode qui ne marche pas #2 2.3 – Méthode qui marche 3 - La représentation des nombres fractionnaires 3.1 – Les nombres en virgule fixe 3.2 – Les nombres en virgule flottante

16 3.1 – Les nombres en virgule fixe Un nombre en virgule fixe est un nombre (signé ou non) enregistré comme un entier. Un tel nombre est dit en virgule fixe car le soin de placer la virgule revient au programmeur (on parle de virgule virtuelle). C’est à dire que la virgule n’apparaît pas dans le stockage du nombre. C'est dans ce cas à l'utilisateur (le programmeur) de créer ce décalage dans le programme qui utilisera ces nombres. Un peu comme si l'on stockait des prix en centimes et qu'on les affichait en euros : On les divise par 100 avant de les afficher. La représentation en virgule fixe est un dinosaure informatique qui ne se justifiait que par le fait de gagner un peu de place pour le stockage de la virgule On utilise de préférence la représentation en virgule flottante

17 Chapitre 4 : La représentation des nombres 1 - Introduction 1.1 – Notion de mot 2 - La représentation des entiers négatifs 2.1 – Méthode qui ne marche pas #1 2.2 – Méthode qui ne marche pas #2 2.3 – Méthode qui marche 3 - La représentation des nombres fractionnaires 3.1 – Les nombres en virgule fixe 3.2 – Les nombres en virgule flottante

18 Il faut trouver une notation qui permette de stocker touts les nombres décimaux, tout en optimisant la place. La manière la plus évidente, et la plus concise, pour représenter un nombre est d’employer une mantisse et un exposant signés : Exemples : -123,45= -1,2345 * 10 2 0,000.006.78 = 6,78 * 10 -6 Avec une telle écriture, on à 4 informations à stocker pour représenter n'importe quel nombre : La mantisse Le signe de la mantisse L'exposant Le signe de l'exposant

19 3.2 – Les nombres en virgule flottante On normalise l'écriture : 1 - On remplace «* 10 x » par «Ex» -123,45= -1,2345 * 10 2 = -1,2345E2 2 - On normalise la mantisse pour qu'elle soit de forme 0,x avec x un nombre != 0 0,000.006.78 = 6,78 * 10 -6 = 6,78E-6 -123,45= -1,2345 * 10 2 = -1,2345E2 = 0,000.006.78 6,78 * 10 -6 = 6,78E-6 = = -0,12345E3 0,678E-5 3 – Pour gagner de la place (et ne plus avoir a stocker le signe de l'exposant) : On décale tout les exposants de 64. -123,45 = -0,12345E3 -0,12345E67 0,000.006.78 = 0,678E-5 0,678E59

20 3.2 – Les nombres en virgule flottante Le coup du décalage de 64 de l'exposant est une invention de l'IEEE (Institute of Electronical and Electronics Engineer). Une association américaine de normalisation. Ce même IEEE donne les formats de représentations de nombres en virgule flottante suivants : La simple précision (sur 32 bits) : 7 bits 1 bit 24 bits Exposant (E : 7 bits ; S : 1 bit ; M : 24 bits) La double précision (64 bits ) La précision étendue (80 bits) SigneMantisse (E : 11 bits ; S : 1 bit ; M : 52 bits) (E : 15 bits ; S : 1 bit ; M : 64 bits)

21 3.2 – Les nombres en virgule flottante Représenter un nombre en virgule flottante (5 étapes) Exemple (Représentation en norme IEEE simple précision) 10,5 (10) Étape 1 : Convertir en hexadécimal (Eh oui, la norme IEEE utilise l'hexa) 10,5 (10) A,8 (16) Étape 2 : Normaliser A,8 0,A8E1 Étape 3 : Décaler l'exposant de 64 0,A8E1 0,A8E65 Étape 4 : Remplir les blancs 4.1 : 7 bits d'exposant(65) 10 -> (?) 2 1000001 4.2 : 1 bit de signe 0 4.3 : 24 bits de mantisse 1010 1000 0000... On complète avec des 0 Étape 2 : Normaliser

22 3.2 – Les nombres en virgule flottante Représenter un nombre en virgule flottante (5 étapes) Étape 5 : « Compacter » en hexadécimal 1000001 01010 1000 0000 Exemple (Représentation en norme IEEE simple précision) (suite) 10,5 (10) 8 2 A 8 0 0 0 0 82.A80.000 (16) Note : Entre l'étape 3 et l'étape 5, on retrouve la forme hexadécimale de la mantisse (A8). On peut gagner du temps en ne la convertissant pas en binaire à l'étape 4

23 3.2 – Les nombres en virgule flottante Retrouver la valeur décimale d’un nombre représenté en virgule flottante Exemple : 84.163.852 (16) Étape 1 : Convertir en binaire 1000 0100 0001 0110 0011 1000 0101 0010 Étape 2 : Appliquer le masque IEEE Exposant = Signe = Mantisse = 1.000.010 (2) 66 (10) = = 0 + 0001 (2 ) = 1 (16) 0110 (2 ) = 6 (16) 0011 (2 ) = 3 (16) 1000 (2 ) = 8 (16) 0101 (2 ) = 5 (16) 0010 (2 ) = 2 (16) +0,163852E66

24 3.2 – Les nombres en virgule flottante Retrouver la valeur décimale d’un nombre représenté en virgule flottante Exemple : 84.163.852 (16) Étape 3 : Décaler de -64 +0,163852E66 +0,163852E2 = 16,3852 (16) Étape 4 : Convertir en décimal 16,3852 (16) 1*16 1 + 6*16 0 = 22 3*16 -1 + 8*16 -2 + 5*16 -3 + 2*16 -4 = 0,220.001.220.703.125 = 22,22 (10) ● Les nombres en virgules flottantes demandent plus de calcul que les autres formes de stockage ● Les nombres en virgules flottantes utilisent beaucoup de place, même pour des petites valeurs ● Les nombres en virgules flottantes stockent souvent des valeurs approximatives