Représentation binaire des nombres décimaux

Comment représenter des nombres décimaux dans un système numérique. Dit autrement, comment transformer des nombres décimaux en binaire pour pourvoir utiliser des opérateurs de calcul matériels.

Pour les représenter en binaire, il faut transformer ces nombres décimaux en entiers en les multipliant par un facteur d’échelle et ne garder que la partie entière. Cette représentation est appelée représentation en virgule fixe et elle permet d’approximer n’importe quel nombre par un nombre entier (la précision de l’approximation est inversement proportionnelle au facteur d’échelle).

Pour des raisons pratiques, ce facteur d’échelle doit être une puissance de deux (2^n), car les divisions et multiplications par une puissance de deux ne nécessitent de matériel supplémentaire et correspondent à des sélections de signaux dans un vecteur.

La partie entière du nombre mis à l’échelle est un nombre représenté sur n \text{bits} permet d’approximer le nombre décimal avec une précision de 1/{2^n}.

Nous allons principalement discuter la représentation des nombres dans l’intervalle [0:1[ bien que cette représentation puisse être généralisée comme discuté à la fin de ce document.

Exemples:

Nous voulons représenter les nombres 0, 0.25, 0.3, 0.5, 0.66, 0.75 et 0.9.

sur 1 bit, facteur multiplicatif 2, précision 0.5

Sur 1 bit on ne peut avoir que deux valeurs, on constate donc que toutes les valeurs inférieures à 0.5 sont représentées par 0 et celles supérieures ou égales à 0.5 par 1.

sur 2 bit, facteur multiplicatif 4, précision 0.25

Ici 4 valeurs différentes peuvent être utilisées. Les seules valeurs qui peuvent être représentées sans erreurs sont 0, 0.25, 0.5 et 0.75.

sur 3 bit, facteur multiplicatif 8, précision 0.125

Forme générale

Un nombre réel N_d \in [0:1[ peut être approché par un entier N et représenté par un vecteur binaire (b_{n-1},...b_0) de taille n.

N = \lfloor N_d\times 2^n\rfloor

Pour retrouver la valeur approchée à partie de la représentation binaire, il suffit de diviser par le facteur d’échelle:

\begin{aligned} N & = \frac{1}{2^n}\sum_{i=0}^{n-1} 2^i \cdot b_i\\ & = \sum_{i=-n}^{-1} 2^i \cdot b_i \end{aligned}

Cette représentation est équivalente à la représentation des entiers à l’exception que nous avons ici des puissances de deux négatives et décroissantes.

Opérations arithmétiques

La multiplication

Dans le cas d’une multiplication, l’opérateur de multiplication est identique à celui utilisé pour des nombres entiers. Il faut juste ne pas oublier le facteur d’échelle dans l’interprétation de la valeur du résultat.

Rappel le résultat de la multiplication de deux nombres représentés sur n\text{bits} doit être représenté sur 2n\;\text{bits}.

Exemple:

Calculons 0.5\times 0.66 représentés sur 3 bits (facteur d’échelle 8) à partir de leurs représentations binaires approchées.

           décimal
     100    (4)/8
   x 101    (5)/8
   -----
     100
+   000.
+  100..
--------
  010100    (20)/64

Ce résultat est aussi une représentation en virgule fixe, sauf que le facteur d’échelle est 2^6=64 et donc la précision plus élevée (car sur 6 bits) La valeur en décimal est:

0\cdot 2^{-1} + 1\cdot 2^{-2} + 0\cdot 2^{-3} + 1\cdot2^{-4} + 0\cdot 2^{-5} + 0\cdot 2^{-6} = 0.3125

Pour retrouver un résultat utilisant la même représentation que les opérandes de départ, il suffit de diviser le résultat une fois par le facteur d’échelle.

Pour l’exemple, il faut diviser par 8=2^3, ce qui revient à supprimer les 3 bits de poids faible.

  010100    (20)/64
  \_/
  010        (2)/8

Ce qui donne:

• (010) en binaire
• et une valeur décimale de:

0\cdot 2^{-1} + 1\cdot 2^{-2} + 0\cdot 2^{-3} = 0.25

cohérent avec la précision de 0.125.

L’addition

Rappel le résultat de la somme de deux nombres représentés sur n\text{bits} doit être représenté sur n+1\;\text{bits}.

Si le facteur d’échelle est le même, la somme se calcule de façon standard. Comme le résultat nécessite un bit de plus correspondant à une retenue potentielle valant 0 ou 1. Ici on voit apparaitre une puissance de 2 égale à 0.

Exemple:

Calculons 0.5+0.66 représentés sur 3 bits (facteur d’échelle 8) à partir de leurs représentations binaires approchées.

           décimal
     100    (4)/8
   + 101    (5)/8
   -----
    1001    (9)/8

Que nous pouvons écrire (1.001) en binaire.

La valeur en décimal et:

1 \cdot 2^0 + 0\cdot2^{-1} + 0\cdot 2^{-2} + 1\cdot 2^{-3} = 1.125

cohérent avec la précision de 0.125.

Si les facteurs d’échelle ne sont pas les mêmes, il faudra veiller à aligner correctement les puissances de 2. Pour des nombres dans l’intervalle [0,1[, ceci revient à les aligner à gauche et à compléter le plus court par des zéros à droite.

Nous pouvons généraliser à la représentation des nombres avec une partie entière non nulle et même signés en CA2.

Généralisation de la représentation

On voit que l’on peut approximer des nombres positifs avec une partie entière non nulle. Dans ce cas, les puissances de 2 correspondantes seront positives et négatives.

Un nombre représenté en virgule fixe sur m+n bits (m pour la partie entière, et n pour la partie après la virgule) de la forme (b_{m-1},...,b_0,b_{-1},..,b_n) a pour valeur:

\begin{aligned} N & = \sum_{i=-n}^{m-1} 2^i b_i \end{aligned}

et peut approximer des nombres dans l’intervalle [0,2^m[ avec une précision de 1/2^n.

On a une représentation binaire avec une virgule et une taille fixe pour la partie avant (entière) la virgule et après (décimale) la virgule.

D’où le nom Représentation en virgule fixe. Comme en base 10, à gauche de la virgule les bits sont multipliés par des puissances de 2 positives et croissantes alors qu’à droite par des puissances de 2 strictement négative et décroissantes.

Exemple 3 bites à gauche de la virgule, 4 bites à droite.

• L’intervalle de représentation [0:8[ avec une précision de 0.0625 = 1/16
• (000.0001)_2 = (0.0625)_{10} la précision (1/16)
• (110.0101)_2 = (6.3125)_{10}
• (111.1111)_2 = (7.9375)_{10} la valeur maximale (127/16)

Précautions pour les opérations arithmétiques:

• pour les additions, il faudra veiller à “aligner les virgules” (la position du bit correspondant à 2^0).
• pour les multiplications, il faudra correctement positionner la virgule dans le résultat (retrouver le facteur d’échelle)

Généralisation pour les nombres signés

La représentation en virgule fixe fonctionne aussi pour les nombres signés en complément à 2 (CA2). Il faut juste considérer le bit de poids fort comme négatif.

• Exemple, les nombres dans l’intervalle [-1,1[ sur n\text{bits} (en facteur d’échelle de 2^{n-1}):

\begin{aligned} N & = \frac{1}{2^{n-1}}(-b_{n-1} 2^{n-1} + \sum_{i=0}^{n-2} 2^i b_i)\\ & = -b_{n-1} + \sum_{i=1-n}^{-1} 2^i b_i \end{aligned}

Retour à la page principale

© Copyright 2022-2025, Télécom Paris.
	Le contenu de cette page est mis à disposition selon les termes de la licence Creative Commons Attribution - Partage dans les Mêmes Conditions 4.0 International.