Vous êtes sur la page 1sur 4

Chapitre 3 : Arithmétique à virgule fixe et à virgule flottante

3.1. REPRESENTATION DES NOMBRES


Pour représenter les nombres fractionnaires il est nécessaire de définir la position de la virgule : pour
ce faire, il existe deux méthodes.
– La représentation en virgule fixe.
– La représentation en virgule flottante.

3.2. REPRESENTATION EN VIRGULE FIXE


La représentation polynomiale d’un nombre réelle signé est donnée par la forme suivante :
𝑛−2

𝑉 = −𝑏 𝑛−1 𝑆 + ∑ 𝑎𝑖 𝑏 𝑖
𝑖=−𝑚

Cette méthode consiste à diviser par ‘b’ autant de fois que cela est nécessaire pour obtenir un
quotient nul. Ensuite on écrit les restes successifs dans l’ordre inverse de celui dans lequel ils
ont été obtenus. Pour la partie fractionnaire on multiplie par b la partie fractionnaire si le
résultat est un nombre plus grand ou égal à b-1 on garde la valeur sinon le résultat
intermédiaire est nul.
Partie entière : (𝑉)10 = 𝟏𝟎 ; (𝑉)2 = 1010
10 2
0 5 2
1 2 2
0 1 2
1 0

On retranche ensuite la valeur gardée à la partie fractionnaire restante et on recommence


autant de fois qu’il faut pour obtenir la précision demandée.
Partie fractionnaire : (𝑉)10 = 𝟎. 𝟒 ; (𝑉)2 = 0110 …
0.4*2 = 0.8  0
0.8*2 = 1.6  1
0.6*2 = 1.2  1
0.2*2 = 0.4  0
0.4*2 = 0.8  0
0.8*2 = 1.6  0
La figure suivante montre la structure d’un nombre réelle signé placé dans un registre de N bits.

S an-2 . . . a0 a-1 . . . a -m

n bits: Partie entier m bits : Partie fractionnaire


La position du point décimal dépend du nombre à représenter. Pour avoir une précision maximale, le
nombre de bits de la partie entier (signe compris) doit répondre à la relation suivante :
𝑛 = 𝑟𝑜𝑢𝑛𝑑 (𝑙𝑜𝑔2 (|𝑉|) + 0.5) + 1
Avec :
log2 : Le logarithme binaire (logarithme en base 2) en fonction du logarithme népérien (ln) :
ln(x )
log 2 (x ) 
ln(2)
La partie fractionnaire, pour un nombre représenté sur N bits prend la valeur triviale suivante :
𝑚 = (𝑁 − 𝑛)
La résolution ou quantification du codage représente la variation la plus petite entre deux nombres
successifs :
𝑞 = 2−𝑚
Définis selon le format {n.m} correspond aux valeurs extrêmes [xmin , xmax] qu’il est possible de
représenter :

𝐷 = [−2𝑛−1 , 2𝑛−1 − 2−𝑚 ]

Exemple :
Soit le nombre V = 10.4. Sur 16 bits, le format optimal est donné par :
n = round(log2(v) + 0.5) +1 = round ( 3.3785+0.5)+1 = 4+1 = 5
m = 16 − 5 = 11
(V)2 = 01010011001101001
La valeur décimale reconstituée vaut :
Vr =10.4004
La différence entre la valeur décimale à convertie et la valeur décimale reconstituée est
donnée par la relation :
Δq = | Vr – V | = 10.4004 –10.4 = 0.0004

Avec Matlab :
>> q = quantizer('fixed', 'Ceiling', 'Saturate', [16 5]);
>> num2bin(q, 10.4);
ans = 0101001100110100

>> bin2num(q,'0101001100110100')

ans = 10.4004
2.2. REPRESENTATION EN VIRGULE FLOTTANTE
Le standard IEEE 754 pour les nombres en virgules flottantes en simple précision est de 32 bits.
Le premier bit S (le plus à gauche) représente le signe, les 8 bits suivants (E0-E7) l’exposant et les
23 derniers (F9-F31) la représentation fractionnaire du nombre en format 0.23, appelé mantisse.

S E0 . . . E7 F9 . . . F31

Exposant Mantisse

La valeur V représentée par le mot codé en 32 bits peut être déterminé de la manière suivante :
 E = 255 , F≠0 𝑉 = 𝑁𝑎𝑁
 E = 255, F=0, S=1 𝑉 = −∞
 E = 255, F=0 ,S=0 𝑉 = +∞
 0 < E < 255 𝑉 = (−1)𝑆 2(𝐸−127) ⋅ (1. 𝐹)
 E = 0 , F≠0 𝑉 = (−1)𝑆 2(𝐸−126) ⋅ (0. 𝐹)

La résolution ou quantification du codage en virgule flottante dépend de la valeur de l’exposant E. Pour


un exposant de nE bits et une mantisse de nm bits, soit un codage en virgule flottante de N=nm+nE+2 bits
et pour un exposant 0 < 𝐸 < 2𝑛𝐸−1 :
q = 22nE −1 2−n𝑚
Le domaine de définition des nombres en virgule flottante avec un exposant de nE bits et une mantisse
de nm bits, pour un exposant 0 < 𝐸 < 2𝑛𝐸−1
𝐷 = [−22 (𝑛𝐸−1) . . . 22(𝑛𝐸−1) ]
Example 1:
S=10.4
q = 2/(2^N);
y = q * floor((s*(1-q)/q) + 0.5) ;
Sq = 10.3203
Rappel :
Les fonctions Matlab qui arrondi les nombres sont les suivants : fix ; ciel; round; floor
Exemple d’un Décodeur HCF4532