Forums Développement Multimédia

Les formations Mediabox
Les formations Mediabox

Système binaire et représentation des nombres

Par Thoutmosis, le 16 janvier 2010

Bonjour et bienvenue dans ce tutoriel consacré au système binaire et à la représentation des nombres. Ce tutoriel est aussi la seconde partie d'un dossier consacré à l'optimisation. Ici vous allez apprendre à voir les nombres et les calculs à la manière d'un ordinateur, et nous savons tous que plus deux personnes se comprennent et mieux elles bossent ensembles. Vous saurez donc ( en théorie ) mieux tirer parti des capacités de calcul de votre machine et ce, quel que soit le langage de programmation utilisé.

Au programme donc:

  1. Système décimal et système binaire.
  2. Les bits et les octets.
  3. Représentation des nombres entiers.
  4. Représentation des nombres réels ( à virgule ).

Système décimal et système binaire

Il y a 10 types de personnes dans le monde ceux qui comprennent le binaire ...

Avant d'introduire le système binaire nous allons un bref apparté sur le système de comptage que tout le monde utilise, j'ai nommé le système décimal. Le système décimal qu'est-ce qu'est ? Eh bien remontez loin ( mais vraiment très loin ) dans votre enfance lorsque l'on vous a jadis appris à compter. On vous a d'abord appris que l'on pouvait compter avec les doigts de la main et donc ( normalement ) jusqu'à 10. Ensuite, on a commencé à introduire en vous la notion de dizaines et donc que après 10 on recommençait avec 11 puis 12 puis 13 etc etc… La dizaine représentant le point de pivot du système de comptage.

Exemple :

00 01 02 03 04 05 06 07 08 09
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29

On remarque bien ici que la série 0 1 2 3 4 5 6 7 8 9 recommence à chaque dizaine. Ce système de comptage s'appelle le système décimal ou alors notation en base 10.

Sachez qu'il existe une multitude de systèmes de comptage notammenten base 2, 12, 16, 20, 100 etc etc… En vérité il peut y avoir une infinité de système des notations.

Et ceux qui ne le comprennent pas

Le système binaire ou système de la notation en base 2 fonctionne sur le même principe sauf que cette fois-ci c'est le 2 qui répresente la point de pivot.

Exemple :

  1. le 0 : 0
  2. le 1 : 1
  3. le 2 : 10. Ici on a franchi le point de pivot on recommence donc la série dès le début ( le 0 ) et on ajoute une unité à gauche, comme pour la base 10
  4. le 3 : 11. Comme pour la base 10, on ajoute une unité à droite jusqu'à ce que l'on franchisse à nouveau le pôint de pivot.
  5. le 4 : 100. Ici il y a une subtilité, normalement on aurait dû ajouter une unité à gauche et repartir de 0 ce qui nous aurait donné: 20. Seulement voilà le 2 étant le point de pivot, on ne peut obtenir 20.On suit donc la règle de départ qui est d'ajouter une unité à gauche et de repartir de 0, ce qui nous donne 100.

Dans le système binaire, chaque bit positionnée à 1 représente une puissance de 2. On part de la droite et de 2^0 et ensuite on incrémente au fur et à mesure que l'on se décale vers la droite.

/*
2^7      2^6       2^5       2^4       2^3       2^2        2^1       2^0
  1         1          1          1          1          1           1         1 
  */
 

On peut donc dire que 5 = 101 = 1 * 2^2 + 0 * 2^1 + 2^0 * 1 = 2^2 + 0 + 2^1 + 4 + 0 + 1.

Vous pouvez donc comprendre maintenant cette blague de geeks programmeurs : “Il y a 10 types de personnes dans le monde, ceux qui comprennent le binaire et ceux qui ne le comprennent pas”. Il faut savoir que votre ordinateur ne peut compter qu'en base 2, ce qui explique assez clairement que dans un ordinateur tout se résume à une suite de 0 et de 1 alignés dans un certain ordre. Nous allons maintenant passer à la manière dont ces 0 et ces 1 sont regroupés.

Les bits et les octets

On va commencer par la plus petit unité de mesure, le bit. Un bit c'est tout simplement un 0 ou un 1 dans un nombre noté en base 2.

Exemple: Le chiffre 5 se note en base 2: 101 Dans cette représentation il y a 3 bits, le 1, le 0 puis le 1.

Ensuite il y a les octets, et bien les octets c'est également très simple, il s'agit tout bêtement de 8bits collés les uns aux autres. Ce qui fait que sur un octet, on peut représenter les nombres allant de 0 à 255 ( 2^7 + 2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0 ).

Il faut savoir que l'octet est la plus petite unité pour représenter un nombre dans votre ordinateur càd que même si j'ai uniquement besoin de 3bits pour représenter mon chiffre 5, l'ordinateur va quand même utiliser un octet entier et donc 8bits. En réalité, cette règle n'est pas toujours vraie, il existe des cas ou l'on utilise moins de 8bits mais il s'agit de cas spécifiques qui n'ont aucun rapport avec ce que l'on veut étudier.

Exemple :

chiffre 5 : 00000101

Mais comment représenter des nombres plus grands que 255 ? Et bien on utilise tout simplement plusieurs octets à la queue leu-leu en partant de l'octet de droite.

Exemple

le nombre 256 ou 2^8: 00000001 00000000

Il faut savoir que, jusqu'à récemment, les systèmes géraient au maximum des chiffres codés sur 32bits soit 4 octets, ce qui donnait un nombre positif maximal de 2^32 - 1, en général cela corresponds au type int dans les langages de programmation. Ce qui nous amène à la partie suivante…

Représentation des nombres entiers

Les nombres entiers sont les nombres positifs et négatifs qui ne possèdent pas de virgule. Jusqu'à présent, nous n'avions parlé que de nombre positifs mais comment peut-on représenter un nombre négatif ? Pour cela il nous faut introduire deux nouvelles notions :

  1. Les nombres signés : Il s'agit des nombres qui peuvent être soit positifs, soit négatifs.
  2. Les nombres non signés : Ces nombres ne peuvent être que positifs

Nous avons déjà vus comment l'on pouvait représenter les nombres entiers non signés, nous ne reviendrons pas dessus, retenez juste qu'un nombre non signé codé sur 4 octets peut atteindre un maximum de 2^32 - 1.

Pour les nombres signés, il faut retenir 2 règles:

  1. Le bit le plus à gauche, appelé aussi le bit de poids fort, est utilisé pour déterminer le signe du nombre, 0 pour les nombres positifs et 1 pour les nombres négatifs.
  2. Les nombres positifs sont représentés normalement, donc un nombre non signé codé sur 32 bits et positif peut atteindre un maximum de 2^31 - 1.

Avant de montrer la manière correcte de représenter un nombre négatif en base 2 on va essayer d'aborder le problème avec les éléments que l'on a déjà. Admettons que je veuilles représenter -2, actuellement je sais déjà représenter le chiffre 2 et je sais que le bit le plus à gauche doit être à 1 pour dire que mon nombre est négatif.

On obtient donc normalement: 1000 0010.

Voilà, maintenant on va pouvoir aborder le problème, que se passe-t'il si je veux additionner 2 et -2 par exemple ?

0000 0010 + 1000 0010 = ?

Si on suit les règles que l'on connaît déjà on obtient :

1000 0100

On obtient -4 ? En effet, l'addition et toutes les autres opérations binaires ne fonctionnent pas si l'on représente les nombres négatifs de cette manière. La bonne nouvelle, c'est que les pères de nos pères ont compris ça bien avant nous et qu'ils ont déjà une solution. Pour représenter un nombre négatif il suffit de suivre 3 étapes.

  1. Partir de la représentation positive de ce nombre.
  2. Inverser les valeurs de tout les bits càd les 1 deviennent des 0 et les 0 des 1.
  3. Ajouter 1 au résultat de l'opération précédente.

Ce procédé en 3 étapes à un nom, il s'agit du complément à 2.

Exemple:

 
//On veut obtenir la représentation de -5, on part donc de la représentation de 5.
00000101
 
//Ensuite on inverse tout les bits
11111010
 
//Et on ajoute 1 au résultat**
11111011

Ainsi, l'octet 11111011 peut avoir deux significations, si l'on considère qu'il s'agit d'un nombre non signé on obtient 250, en revanche, si on souhaite le lire comme un nombre signé, on obtient -5. Considérons maintenant que les nombres ne sont codés que sur un seul octet et additionons -5 et 5.

 
	00000101
//+
	11111011
//=
  1	00000000

Le 1 tout à gauche n'est pas pris en compte car on lit le nombre uniquement sur un octet, on obtient bien donc le résultat logique 5 -5 = 0.

Représentation des nombres réels ( ou à virgule )

Les nombres à virgules sont stockés d'une manière assez particulière dans un ordinateur, ici nous allons parler du stockage d'un nombre à virgule à précision simple, càd que nous allons représenter ce qui corresponds par exemple au type float en C. La norme IEEE prévoit que les nombres réels soient stockés sur 32bits, donc 4octets et sous la forme binaire 1,XXXX * 2^n. Par exemple, le nombre binaire réel suivant 1,11 * 2^1 ne se lit pas “un virgule onze ” mais bien “3 virgule 5”.

Explication:

1, 11 * 2^1 = 11,1. 11,1 = 2^1 + 2^0 + 2^-1 = 2 + 1 + 0.5 = 3,5 en notation décimale.

Pour stocker un nombre réel il faut respecter plusieurs étapes:

-Le bit le plus à gauche ( bit de poids fort ) représente, comme pour les nombres signés, le signe du nombre.
-Obtenir la représentation du nombre sous la forme 1,XXXX * 2^n, cette représentation a pour nom **la représentation normalisée**.
-L'exposant 2^n obtenu précédemment doit être codé sur un octet, on lui ajoute 127, ce qui permets d'obtenir  des exposants négatifs et positifs. les exposants 00000000 et 11111111 sont interdits car réservés à d'autre usages.
-L'ensemble des nombres se situant après la virgule, aussi appellé la mantisse, est codé sur les 23bits restants. Il contient ** la partie décimale de la représentation normalisée ** précédemment calculée complétée avec des 0 jusqu'à obtenir les 23bits requis.

Le fait d'ajouter 127 à l'exposant permet de déterminer facilement si l'exposant est négatif ou positif, en effet si l'exposant nouvellement calculé est supérieur à 127, il s'agit d'un exposant positif , sinon il sera négatif.Vu qu'un exemple vaut mieux qu'un long discours passons tout de suite à la pratique.

 
//On veut représenter -5,25
 
 
// 1. Le bit le plus à gauche sera 1 car -5,25 est négatif.
 
1
 
// 2. Obtenir la représentation normalisée du nombre càd quelque chose ressemblant à 1,XXXX... * 2^n.
// On part donc de la forme, nous dirons "de base" de 5,25 càd :
 
101,01 ou 2^2 + 2^0 + 2^-2.
 
// On décale les bits jusqu'à obtenir la forme normalisée, on doit donc décaler tout les bits deux fois vers la droite, l'exposant n sera donc 2.
 
1,0101 * 2^2 ou ( 2^0 + 2^-2 + 2^-4 ) * 2^2
 
// On ajoute 127 à l'exposant n, ce qui donne:
 
127 + 2 = 129.
 
// On doit donc représenter le chiffre 129 sur 8bits soit un octet soit:
 
10000001
 
// On obtient donc pour l'instant la suite de bits suivants :
 
110000001
 
// Ensuite, nous obtenons la mantisse en prenant uniquement en compte la partie décimale de la représentation normalisée de 5,25.
// On abandonne donc la partie entière de 1,0101 ce qui nous laisse :
 
0101
 
// On obtient 4 bits, mais pour que la mantisse soit complète il faut qu'elle couvre 23 bits. On doit donc compléter avec des 0 :
 
01010000000000000000000
 
// La représentation binaire de -5,25 est donc:
 
11000000101010000000000000000000
 
// si on découpe cette suite de bits par groupes de 1 octet on obtient bien 4 octets soit 32bits:
 
11000000 10101000 00000000 00000000
 
 
//Autre exemple on veut représenter 0,125  soit 0,001 soit 2^-3
 
// 1 le bit le plus à gauche sera égal à 0.
 
0
 
// On obtient la forme normalisée de 0,125 soit quelque chose de la forme 1,XXX 2^n. 
// On décale donc les bits mais cette fois vers la gauche. On obtient
 
0,001 -> 1,0 * 2^-3
 
// On ajoute 127 à l'exposant soit :
 
127 + -3 = 127 -3 = 124 = 01111100
 
// On obtient donc :
 
001111100
 
// Ensuite on prends la partie décimale de la forme normalisée ce qui nous laisse :
 
0
 
// On complète avec des 0 jusqu'à obtenir 23bits soit:
 
00000000000000000000000
 
// Finalement on obtient :
 
00111110000000000000000000000000
 
// ou
 
 
00111110 00000000 00000000 00000000

Conclusion

Voilà maintenant vous savez comment sont représentés les nombres entiers et les nombres réels au sein de votre ordinateur. Dans la suite de ce tuto, vous apprendrez ce que sont les opérateurs binaires et comment s'en servir.

En attendant, Have fun !

Retour au sommaire du dossier
Page 1 du dossier » Pourquoi, quand et comment optimiser une application ?
Page 2 du dossier » système binaire et représentation des nombres
Page 3 du dossier » Les opérateurs binaires
Page 4 du dossier » une_classe_pour_realiser_des_benchmarks