Codification des nombres

De WikiMéca
Sauter à la navigation Sauter à la recherche

Codification des nombres entiers

Pour pouvoir être stocké et manipulé par un ordinateur, un nombre doit être représenté par une succession de bits. Le principal problème est la limitation de la taille du codage : un nombre mathématique peut prendre des valeurs arbitrairement grandes, tandis que le codage dans l’ordinateur doit s’effectuer sur un nombre de bits fixé.

Les entiers naturels

Un codage sur n bits permet de représenter tous les nombres naturels compris entre et .

  • un octet permet donc de coder les entiers compris entre et .
  • un codage sur 64 bits permet de coder les entiers entre 0 et .

Remarque :

  • est codé en binaire par un 1 et p 0 : exemple pour ;
  • est codé en binaire par p 1 : exemple pour ;

Les entiers relatifs

Pour un entier relatif , le signe est codé sur le premier bit (0 pour les nombres positifs et 1 pour les nombres négatifs). Dans un codage sur n bits, il reste donc bits pour coder . Pour pouvoir utiliser une addition directe des entiers positifs et négatifs et pour avoir l'unicité du 0, on utilise le codage en complément à deux ou codage modulo pour les entiers négatifs :

  • si , on représente par son mot binaire associé;
  • si , on représente par le mot binaire qui code l’entier naturel .

Exemple avec n = 3 : Avec 3 bits on peut coder entiers naturels :

Entier bit A bit B bit C
0 0 0 0
1 0 0 1
2 0 1 0
3 0 1 1
4 1 0 0
5 1 0 1
6 1 1 0
7 1 1 1

Ou, avec les mêmes 3 bits, on peut coder 8 entiers relatifs en utilisant le complément à 2 (de -4 à 3) :

Entier bit A (de signe) bit B bit C
0 0 0 0
1 0 0 1
2 0 1 0
3 0 1 1
-4 1 0 0
-3 1 0 1
-2 1 1 0
-1 1 1 1

On remarque que le zéro a une représentation unique et que l'addition binaire fonctionne dans ce tableau :

Exemple : on cherche le résultat de .

  • -2 est représenté par 110;
  • 3 est représenté par 011;
  • 110+011=1001. Les entiers étant représentés modulo , cad ici modulo 8 ce qui revient à ne considérer que les trois derniers bits, donc 001, ce qui correspond bien à l'entier 1.

Remarque : avec 3 bits, on ne peut pas représenter le résultat de toutes les additions d'entiers représentés sur 3 bits. Par exemple, dans l'addition , on additionne les représentations de 3 et 2 : 011 + 010 = 101, qui représente , ce qui correspond à mais à un résultat erroné pour l'addition réalisée. En effet, 5 n'est pas représentable sur 3 bis en complément à 2. On parle alors de dépassement de capacité. Dans Python, le dépassement de capacité est géré de façon transparente et on peut utiliser des grands entiers. La seule limite étant la mémoire allouée à l’exécution du programme.

Codification des nombres décimaux

Décomposition dyadique

Un nombre dyadique est un rationnel qui peut s’écrire sous la forme est un entier relatif, et son développement dyadique s’obtient en plaçant une virgule séparant les chiffres les plus à droite des autres. Par exemple, est un nombre dyadique et son développement dyadique est .

En effet, et

Erreurs d'arrondi

Un ordinateur va travailler avec des nombres dyadiques. Ce n’est pas un problème quand il s’agit d’entiers puisque dans ce cas la conversion binaire/décimal est exacte, mais cela pose un problème pour les nombres décimaux car le développement dyadique d’un nombre décimal peut être infini. La conversion d’un nombre décimal en nombre dyadique va donc parfois provoquer une approximation qui dans certains cas conduit à des résultats surprenants. Par exemple :

>>> 0.1+0.2
0.30000000000000004

>>> 0.1+0.2 -0.3
5.551115123125783e-17

>>> 0.1+0.2 == 0.3
False

L'égalité algorithmique entre deux nombres flottants n'a en général pas de sens. Pour comparer deux flottants, il faudra comparer la valeur absolue de la différence avec un flottant très petit, dépendant de la précision attendue:

>>> abs(0.1+0.2 -0.3) < 10e-6
True

Attention ! Des erreurs d'arrondis qui s'accumulent dans une boucle peuvent donner des résultats complètements faux !

Perte d’associativité

En mathématique, l’addition est associative : ; ce n’est pas le cas pour l’addition entre nombres flottants :

>>> (1. + 2.**53) - 2.**53
0.0

>>> 1. + (2.**53 - 2.**53)
1.0

En effet le flottant est absorbé dans la première somme avec un flottant qui lui est très supérieur (). Mais il n'est pas absorbé dans la deuxième somme.

Les nombres flottants - norme IEEE-754

La norme IEEE-754 est actuellement le standard pour la représentation des nombres à virgule flottante en binaire. Nous allons pouvoir représenter des nombres décimaux écrits en base deux, sous forme scientifique. Nous les appellerons des nombres flottants :

où :

  • est un mot binaire appelé mantisse;
  • un mot binaire représentant un entier relatif, appelé exposant. On le code par la représentation binaire sur 11 bits de l’entier naturel , nommé exposant décalé, défini par . L’entier E étant codé sur 11 bits, il prend les valeurs de . Mais les mots «extrêmes» 00000000000 et 11111111111 étant réservés, l’entier E ne prend que les valeurs de

Dans cette norme, les nombres dyadiques sont codés sur 64 bits en réservant :

  • 1 bit pour le signe;
  • 11 bits pour l’exposant décalé;
  • 52 bits pour la mantisse.
Bit de signe Exposant décalé E Mantisse
1 bit 11 bits 52 bits

Exemple : écriture de La codification dyadique de 6,25 est . Sa représentation normalisée sera : . L'exposant

Bit de signe Exposant décalé E Mantisse
0 10000000001 100100000000000000000000000000000000000000000000000

Il y a trois cas particuliers :

  • si l'exposant décalé E et la mantisse sont tous deux nuls, le nombre est ±0 (selon le bit de signe)
  • si l'exposant décalé E est égal à , et si la mantisse est nulle, le nombre est (selon le bit de signe)
  • si l'exposant décalé E est égal à , mais que la mantisse n'est pas nulle, le nombre est NaN (not a number : pas un nombre).


Autres pages de la catégorie "Informatique"

Pages relatives à l'informatique en CPGE scientifiques.

Bases du langage Python

Algorithmes et méthodes numériques‎