01 QualiteNumeriqueLogiciel

Master Électronique, Automatique, Informatique Université de Perpignan Via Domitia
Semestre 9 (M2) - Mention Informatique Année universitaire 2012/2013
Qualité Numérique du Logiciel
Représentation des nombres, arithmétique flottante,

norme IEEE 754
Guillaume Revy
guillaume.revy@univ-perp.fr
Université de Perpignan Via Domitia
Guillaume Revy (Univ. de Perpignan Via Domitia) Représentation des nombres, arithmétique flottante, norme IEEE 754 1/36
Organisation du cours “Qualité Numérique du Logiciel”
Organisation :
I 18h de cours
I 18h de TD
2 intervenants :
I G. Revy 9 séances de 2h de CM/TD
I Ph. Langlois 9 séances de 2h de CM/TD
Plan du cours
1. Introduction générale
2. Représentation des nombres entiers et réels
3. Norme IEEE 754
Introduction générale
Plan du cours
3. Norme IEEE 754
Introduction
L’informatique est, aujourd’hui, omniprésente
I ordinateurs personnels (bureautique, audio-vidéo, jeux vidéos, ...)
I outils pour la calcul numérique, de simulation, modélisation,
I systèmes embarqués (audio-vidéo, téléphonie mobile, tablettes PC, ...)
En informatique, les ordinateurs effectuent des calculs

I puis-je avoir confiance en les résultats de mon ordinateur ?
Bourse de Vancouver (1982)
1982 : création d’un nouvel indice de valeur initiale 1000

I recalculé après chaque transaction
I tronqué après le 3e chiffre
Au bout de 22 mois : valeur calculée = 524.881 au lieu de 1098.811
Bourse de Vancouver (1982)
1982 : création d’un nouvel indice de valeur initiale 1000

I recalculé après chaque transaction
I tronqué après le 3e chiffre
Au bout de 22 mois : valeur calculée = 524.881 au lieu de 1098.811
Source du problème : la valeur calculée était tronquée au lieu d’être arrondie

I dans ce cas : toutes les erreurs sont de même signe
I aucune compensation possible
Missile Patriote (25 février 1991)
Échec lors de l’interception d’un Scud (Dharan, Arabie Saoudite)

I bilan : 28 morts / 100 blessés
Compteur dans la batterie du missile : ajout de 1/10 tous les dixièmes de seconde
I 1/10 non représentable exactement en machine
I 1/10 ≈ (0.000110011001100110011001100110011001...)2
I erreur (24 bits) ≈ 9.5 × 10−8 par ajout de 1/10
I au bout de 100h : erreur ≈ 0.34 secondes
Vitesse du missile Scud : 1676 m/s

I au bout de 100h : erreur ≈ 568 m
Premier vol d’Ariane 5 (4 juin 1996)
Après 39 sec. de vol : autodestruction de la fusée

I coût de la fusée / du cargot ≈ 500 millions $
I coût du développement ≈ 7 milliard $
Système de Référence Inertielle (SRI) : calcule la position, la vitesse et

l’inclinaison de la fusée, en fonction de mesures d’accélération et de rotation
I identique à celui d’Ariane 4
I accélération 5 fois plus élevée
Forte accélération de la fusée dépassement de capacité lors du calcul des

position et vitesse
I dû à la conversion d’un nombre virgule flottante 64 bits (double) en nombre entier
de 16 bits dans un logiciel en Ada
Autres exemples de bugs

Bug du Pentium (1994) : Bug dans la fonction de division de l’unité de calcul à
virgule flottante du Pentium P5
4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 820 449 136 241 002 <-- valeur correcte
4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 739 068 902 037 589 <-- Pentium P5
I coût ≈ 475 millions $

4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 820 449 136 241 002 <-- valeur correcte
4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 739 068 902 037 589 <-- Pentium P5
Bug dans Maple 7.0 : Erreur dans la fonction factorielle de Maple 7.0
I 1001!/1000! 1 (au lieu de 1001)

4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 820 449 136 241 002 <-- valeur correcte
4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 739 068 902 037 589 <-- Pentium P5
I 1001!/1000! 1 (au lieu de 1001)
Bug dans Excel 2007 : Problème d’affichage dans Excel 2007

Valeur à calculer Valeur attendue Valeur affichée dans Excel 2007
850 × 77.1 100000

(850 × 77.1) + 1 100001
(850 × 77.1) - 1

4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 820 449 136 241 002 <-- valeur correcte
4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 739 068 902 037 589 <-- Pentium P5
I 1001!/1000! 1 (au lieu de 1001)

850 × 77.1 100000

(850 × 77.1) + 1 100001
(850 × 77.1) - 1 65534

4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 820 449 136 241 002 <-- valeur correcte
4 195 835 ,0 / 3 145 727 ,0 = 1 ,333 739 068 902 037 589 <-- Pentium P5
I 1001!/1000! 1 (au lieu de 1001)

850 × 77.1 65535 100000

(850 × 77.1) + 1 65536 100001
(850 × 77.1) - 1 65534 65534
I la valeur en machine est correcte seule la valeur affichée est erronée
Suite de J.-M. Muller

int
main ( void )
Soit un la suite définie par :

{
float u0 = 2.0f , u1 = -4.0 f;
 printf ("u( 0) = % 1.19 e\n" ,u0 );
u0
 =2 printf ("u( 1) = % 1.19 e\n" ,u1 );
int n; for (n = 1 ; n <= 19 ; n ++) {
u1 = −4 float tmp = 111. f - 1130. f/ u1 + 3000. f * 1/( u1 * u0 );
printf ("u (%2 d) = % 1.19 e\n" ,n+1 , tmp );
= 111 − 1130 + (u3000

u u0 = u1 ; u1 = tmp ;
n+1 un n ·u n-1 ) }
return 0;
}

int
main ( void )

{
float u0 = 2.0f , u1 = -4.0 f;
 printf ("u( 0) = % 1.19 e\n" ,u0 );
u0
 =2 printf ("u( 1) = % 1.19 e\n" ,u1 );
int n; for (n = 1 ; n <= 19 ; n ++) {
printf ("u (%2 d) = % 1.19 e\n" ,n+1 , tmp );
= 111 − 1130 + (u3000

u u0 = u1 ; u1 = tmp ;
n+1 un n ·u n-1 ) }
return 0;
}
$ > ./ suite - jmmuller

u( 0) = 2.0000000000000000000 e +00 120 float
u( 1) = -4.0000000000000000000 e +00
u( 2) = 1.8500000000000000000 e +01
u( 3) = 9.3783798217773437500 e +00 100
u( 4) = 7.8011646270751953125 e +00
u( 5) = 7.1545600891113281250 e +00
u( 6) = 6.8088302612304687500 e +00 80
u( 7) = 6.6227531433105468750 e +00
u( 8) = 6.9049758911132812500 e +00
u( 9) = 1.2952423095703125000 e +01 60
u (10) = 5.7301113128662109375 e +01
u (11) = 9.5321716308593750000 e +01
40
u (12) = 9.9694656372070312500 e +01
u (13) = 9.9981079101562500000 e +01
u (14) = 9.9998840332031250000 e +01 20
u (15) = 9.9999923706054687500 e +01
u (16) = 9.9999992370605468750 e +01
u (17) = 1.0000000000000000000 e +02 0
u (18) = 1.0000000000000000000 e +02
u (19) = 1.0000000000000000000 e +02 0 5 10 15 20
u (20) = 1.0000000000000000000 e +02

int
main ( void )

{
float u0 = 2.0f , u1 = -4.0 f;
 printf ("u( 0) = % 1.19 e\n" ,u0 );
u0
 =2 printf ("u( 1) = % 1.19 e\n" ,u1 );
int n; for (n = 1 ; n <= 19 ; n ++) {
printf ("u (%2 d) = % 1.19 e\n" ,n+1 , tmp );
= 111 − 1130 + (u3000

u u0 = u1 ; u1 = tmp ;
n+1 un n ·u n-1 ) }
return 0;
}

u( 0) = 2.0000000000000000000 e +00 120 float
u( 1) = -4.0000000000000000000 e +00 théorique
u( 2) = 1.8500000000000000000 e +01
u( 3) = 9.3783798217773437500 e +00 100
u( 4) = 7.8011646270751953125 e +00
u( 5) = 7.1545600891113281250 e +00
u( 6) = 6.8088302612304687500 e +00 80
u( 7) = 6.6227531433105468750 e +00
u( 8) = 6.9049758911132812500 e +00
u( 9) = 1.2952423095703125000 e +01 60
u (10) = 5.7301113128662109375 e +01
u (11) = 9.5321716308593750000 e +01
40
u (12) = 9.9694656372070312500 e +01
u (13) = 9.9981079101562500000 e +01
u (14) = 9.9998840332031250000 e +01 20
u (15) = 9.9999923706054687500 e +01
u (16) = 9.9999992370605468750 e +01
u (17) = 1.0000000000000000000 e +02 0
u (18) = 1.0000000000000000000 e +02
u (19) = 1.0000000000000000000 e +02 0 5 10 15 20
u (20) = 1.0000000000000000000 e +02

int
main ( void )

{
float u0 = 2.0f , u1 = -4.0 f;
 printf ("u( 0) = % 1.19 e\n" ,u0 );
u0
 =2 printf ("u( 1) = % 1.19 e\n" ,u1 );
int n; for (n = 1 ; n <= 19 ; n ++) {
printf ("u (%2 d) = % 1.19 e\n" ,n+1 , tmp );
= 111 − 1130 + (u3000

u u0 = u1 ; u1 = tmp ;
n+1 un n ·u n-1 ) }
return 0;
}

u( 0) = 2.0000000000000000000 e +00 120 float
u( 1) = -4.0000000000000000000 e +00 théorique
u( 2) = 1.8500000000000000000 e +01 double
u( 3) = 9.3783798217773437500 e +00 100
u( 4) = 7.8011646270751953125 e +00
u( 5) = 7.1545600891113281250 e +00
u( 6) = 6.8088302612304687500 e +00 80
u( 7) = 6.6227531433105468750 e +00
u( 8) = 6.9049758911132812500 e +00
u( 9) = 1.2952423095703125000 e +01 60
u (10) = 5.7301113128662109375 e +01
u (11) = 9.5321716308593750000 e +01
40
u (12) = 9.9694656372070312500 e +01
u (13) = 9.9981079101562500000 e +01
u (14) = 9.9998840332031250000 e +01 20
u (15) = 9.9999923706054687500 e +01
u (16) = 9.9999992370605468750 e +01
u (17) = 1.0000000000000000000 e +02 0
u (18) = 1.0000000000000000000 e +02
u (19) = 1.0000000000000000000 e +02 0 5 10 15 20
u (20) = 1.0000000000000000000 e +02
Quelles sont les propriétes d’une bonne arithmétique ?
Rapidité des calculs

I calcul rapide de la trajectoire d’un missile de défense aérienne
Précision des calculs

I calcul correct de cette trajectoire
Dynamique des valeurs représentées

I représenter des valeurs très petites et très grandes
Portabilité des calculs

I reproductibilité des résultats d’un programme d’une machine à une autre
Facilité d’utilisation et d’implantation
Lien avec la qualité numérique d’un logiciel
Dans un programme (logiciel) numérique, les erreurs sont principalement dues :

I à la difficulté de traduire un problème mathématique en une implantation dans un
langage de programmation erreurs de méthode,
I à l’arrondi des données d’entrées du problème (données physiques ou de capteur,
par exemple) erreurs de données,
I à l’imprécision de l’arithmétique utilisée erreurs d’arrondi.
Lien avec la qualité numérique d’un logiciel
Dans un programme (logiciel) numérique, les erreurs sont principalement dues :

I à la difficulté de traduire un problème mathématique en une implantation dans un
langage de programmation erreurs de méthode,
I à l’arrondi des données d’entrées du problème (données physiques ou de capteur,
par exemple) erreurs de données,
I à l’imprécision de l’arithmétique utilisée erreurs d’arrondi.
Comment déterminer et contrôler ces erreurs d’arrondi ?

I en encadrant les erreurs par des intervalles,
I en augmentant la précision de calcul ou en compensant les erreurs d’arrondi, afin
d’améliorer la précision du résultat calculé,
I en calculant les solutions exactes,
I ...
Que va-t-on voir dans cette partie de cours ?
Représentation des nombres
Arithmétique flottante : définitions et représentation
Norme IEEE 754 et propriétés de l’arithmétique flottante
Analyse d’erreur : erreur absolue et relative, ...
Arithmétique d’intervalles
Arithmétiques arbitraire et multi-précision
Représentation des nombres entiers et réels
Plan du cours
3. Norme IEEE 754
Représentation en numération simple à position

On appelle base un entier β supérieur ou égal à 2
I dans notre cas, on utilisera principalement la base β = 2
Un chiffre sera un entier (symbole) compris entre 0 et β − 1

I si β = 2 chiffre = bit ∈ {0, 1}
Un nombre X de n chiffres = une séquence (xn−1 xn−2 · · · x1 x0 )β , telle que
n−1
X= ∑ xi · βi
i =0
I numération simple à position
I βn valeurs représentables sur n chiffres
I si β = 2 ⇒ X = un nombre de n bits
Exemple avec β = 2 et n = 8 X = 170 = 27 + 25 + 23 + 21 = (10101010)2
Représentation en complément à la base
En base β, sur n chiffres → représentation de βn nombres

I essayons de représenter les nombres entre −βn /2 et βn /2 − 1

Comment représenter les valeurs de 0 à βn ?

I de 0 à βn /2 − 1 : utilisation de la notation simple à position
I de −βn /2 à -1 : translation de βn − 1 positions

Comment représenter les valeurs de 0 à βn ?

I de 0 à βn /2 − 1 : utilisation de la notation simple à position
I de −βn /2 à -1 : translation de βn − 1 positions
Remarque : si β = 2, alors la chaîne de bits (xn−1 xn−2 · · · x1 x0 ) représente
n−2
−xn−1 · 2n−1 + ∑ xi · 2i
i =0
I bit de poids fort ⇒ bit de poids négatif
I le signe d’un nombre est déterminé par son bit de poids fort
Représentation en virgule fixe
Principe : représentation de nombres réels par des nombres entiers

I utilisation d’un facteur d’échelle implicite
I représentation du nombre entier dans un des systèmes précédents
Exemple : soient X un nombre entier en base β sur n chiffres, et x un nombre réel

représenté par X
X = (xn−1 xn−2 · · · x1 x0 )β
X= X7 X6 X5 X4 X3 X2 X1 X0
Représentation en virgule fixe
Principe : représentation de nombres réels par des nombres entiers

I utilisation d’un facteur d’échelle implicite
I représentation du nombre entier dans un des systèmes précédents
Exemple : soient X un nombre entier en base β sur n chiffres, et x un nombre réel

représenté par X
X = (xn−1 xn−2 · · · x1 x0 )β
et x = X · β−F
= (xn−1 xn−2 · · · xn−I , xn−I −1 · · · x1 x0 )β ,
| {z } | {z }
I chiffres F chiffres
avec n = I + F.
X= X7 X6 X5 X4 X3 X2 X1 X0
I chiffres F chiffres
Remarques sur la virgule fixe
⊕ La virgule fixe est encore utilisée pour des raisons de rapidité

I opérations en virgule fixe = opérations entière
Remarques sur la virgule fixe
⊕ La virgule fixe est encore utilisée pour des raisons de rapidité

I opérations en virgule fixe = opérations entière
Le facteur de mise à l’échelle est implicite

I connaissance de l’ordre de grandeur des données de la part des développeurs
I difficulté de développement
Les nombres représentés ne sont pas d’ordres de grandeurs très différents

I la dynamique des valeurs représentée est plus faible qu’en virgule flottante
Les calculs entre nombres en virgule fixe de magnitudes d’ordre de grandeur

différents est beaucoup plus compliqué
Règles d’arithmétique virgule fixed

addition et multiplication
Ia Fa
Sa a3 a2 a1 a0 a−1 a−2 a−3 a−4 a−5

Addition Ib Fb
I format virgule fixe identique
Sb Sb Sb b1 b0 b−1 b−2 b−3 0 0
I alignement des virgules
I extension du bit de signe Sr r4 r3 r2 r1 r0 r−1 r−2 r−3 r−4 r−5
Ir = max(Ia ,Ib )+1 Fr = max(Fa ,Fb )
Règles d’arithmétique virgule fixed

addition et multiplication
Ia Fa
Sa a3 a2 a1 a0 a−1 a−2 a−3 a−4 a−5

Addition Ib Fb
I format virgule fixe identique
Sb Sb Sb b1 b0 b−1 b−2 b−3 0 0
I alignement des virgules
I extension du bit de signe Sr r4 r3 r2 r1 r0 r−1 r−2 r−3 r−4 r−5
Ir = max(Ia ,Ib )+1 Fr = max(Fa ,Fb )
Ia Fa
Sa a2 a1 a0 a−1 a−2 a−3

Multiplication Ib Fb
I doublement de la taille Sb b1 b0 b−1 b−2

pour représenter le bit de
signe Sr Sr r4 r3 r2 r1 r0 r−1 r−2 r−3 r−4 r−5
Ir = Ia +Ib Fr = Fa +Fb
Représentation d’un nombre virgule flottante
En virgule flottante, en base β, un nombre réel x est représenté par :


 un signe s ∈ {0, 1} 0 : positif / 1 : négatif


une mantisse m, écrite en virgule fixe en base β sur p chiffres (β ≥ 2)

 un exposant e ∈ {e , · · · , e }

min max
de telle sorte que
x = (−1)s · m · βe ,
avec pour k ∈ {0, · · · , p − 1}
m = m0 · · · mi .mi +1 · · · mp−1 et mk ∈ {0, · · · , β − 1}.
On dit que le nombre flottant x est de précision p (avec p ≥ 1)
Remarques sur l’arithmétique virgule flottante
Remarque 1 : βe joue ici le rôle du facteur de mise à l’échelle

I il est explicite en virgule flottante
Remarque 2 : Cette représentation
x = (−1)s · m · βe
n’est pas unique. Par exemple, le nombre 2.617 en base β = 10 se représente en

précision p = 4 de différentes manières :
.2617 · 101 ou 2617 · 10−3 .
I notion d’exposant convention choisie pour représenter la mantisse
Dynamique des nombres : floating-point vs. fixed-point

800
Fixed-point
700 Floating-point

600
log10 max(x)/ min(x)
500
400
300

200
100
0
10
16
24
32
64
bi
bi
bi
bi
bi
ts
ts
ts
ts
ts
Different standard formats (IEEE 754-2008 and OpenGL).
Dynamique des nombres : floating-point vs. fixed-point

120
Fixed-point
Floating-point
100

log10 max(x)/ min(x)
80
60

40
Fixed-point DSP
20
0
10
16
24
32
bi
bi
bi
bi
ts
ts
ts
ts
Different standard formats (IEEE 754-2008 and OpenGL).
La virgule flottante avant la norme IEEE 754
Différentes machines avec différents systèmes flottants :
Système et arithmétique Base β Précision p Exposants (emin , emax )

Cray 1 (single) 2 48 (−8192, 8191)
Cray 1 (double) 2 96 (−8192, 8191)
DEC VAX G format (double) 2 53 (−1023, 1023)
DEC VAX D format (double) 2 56 (−127, 127)
HP 28 et 48G 10 12 (−499, 499)
IBM 3090 (single) 16 6 (−64, 63)
IBM 3090 (double) 16 14 (−64, 63)
IBM 3090 (extended) 16 28 (−64, 63)
Comment écrire un programme qui soit portable ?
La virgule flottante avant la norme IEEE 754
Sur certaines machines Cray, on avait :
pour certaines entrées x, 1×x overflow (dépassement de capacité)

x + y 6= y + x
0.5 × x 6= x /2.0
Sur IBM 370 (1970), en Fortran, on avait :

√
−4 = 2
I = 14./7.0 I=1
Norme IEEE 754
Plan du cours
3. Norme IEEE 754
Norme IEEE 754
Histoire de la norme IEEE 754
Jusque dans les années 80 : chaque constructeur avait sa propre implantation de

l’arithmétique flottante
I quelle base β était utilisée ? quelle plage d’exposant [emin , emax ] ?
I un programme différents résultats sur différentes architectures
Norme IEEE 754

Besoin de standardiser et d’homogénéiser l’implantation l’arithmétique virgule

flottante en base 2
I fixer précisement le format des données et leur encodage en machine
√
I définir le comportement et la précision des opérations de base (+, −, ×, /, )
I définir les valeurs spéciales, les modes d’arrondis, et la gestion des exceptions
Norme IEEE 754

Besoin de standardiser et d’homogénéiser l’implantation l’arithmétique virgule

flottante en base 2
I fixer précisement le format des données et leur encodage en machine
√
I définir le comportement et la précision des opérations de base (+, −, ×, /, )
I définir les valeurs spéciales, les modes d’arrondis, et la gestion des exceptions
1985 : publication du standard IEEE 754-1985, initié par Prof. William Kahan
I 2008 : révision de la norme IEEE 754-2008
Norme IEEE 754
Quelques nouveautés de la norme IEEE 754-2008

... en plus de ce qui est définit dans la norme IEEE 754-1985
Standardisation de la base β = 10, en plus de la base β = 2

I dans le reste du cours, on ne s’intéressera qu’à la base β = 2
Standardisation de l’opération fma (fused multiply-add) :
fma(a, b, c ) = ◦(a × b + c ).
I une multiplication et une addition, avec un seul arrondi final
Standardisation de l’arithmétique quadruple précision
Définition du comportement de certaines fonctions, autres que les opérations de

√
base (+,−,×,/, ),
I fonctions élémentaires : cos(x ), sin(x ), log(x ), exp(x ), ...
Norme IEEE 754
Formats de représentation standards des données
Le standard IEEE 754-2008 définit 3 formats de base pour les nombres flottants :
Simple précision Double précision Quadruple précision
Précision p 24 53 113
Taille de l’exposant w 8 11 15
Taille de la représentation k = p + w 32 64 128
emin , emax -126, 127 -1022, 1023 -16382, 16383
Type C float double -
avec
I taille de la mantisse precision : p bits
I taille d’exposant : w bits
I emax = 2w −1 − 1 et emin = 1 − emax
Norme IEEE 754
Repésentation normalisée des nombres flottants
Même en fixant la position de la virgule dans la mantisse d’un nombre flottant, un

même nombre peut avoir plusieurs représentations :
2.170 × 100 et 0.217 × 10−1 .
Pour pallier ce problème, et éviter de perdre de la précision sur la mantisse, on fait

en sorte qu’elle soit normalisée, c’est-a-dire, que le bit m0 6= 0
I la représentation est alors unique (pour les valeurs non nulles)
I c’est la représentation qui minimise l’exposant
I en base β = 2 : m0 = 1 on a donc pas besoin de stocker le bit m0 en mémoire
(= bit implicite)
Norme IEEE 754
Encodage des nombres flottants normalisés en mémoire

Soit x un nombre flottant normalisé. L’encodage de x est le suivant :
 
 1 bit pour le signe (0 ou 1),

 


w bits pour l’exposant, avec k = w + p.
 
 p − 1 bits pour la fraction de la mantisse, 
 
I on n’a pas besoin de stocker le bit m0 car m0 = 1 (= bit implicite)
Norme IEEE 754
Encodage des nombres flottants normalisés en mémoire

Soit x un nombre flottant normalisé. L’encodage de x est le suivant :
 
 1 bit pour le signe (0 ou 1),

 


w bits pour l’exposant, avec k = w + p.
 
 p − 1 bits pour la fraction de la mantisse, 
 
I on n’a pas besoin de stocker le bit m0 car m0 = 1 (= bit implicite)
L’exposant e ∈ [emin , emax ] et peut donc être négatif. Mais on peut avoir besoin de
comparer deux exposants
I lors d’une addition (par exemple) pour aligner les mantisses
I comparaison délicate en notation signe-valeur absolue ou complément à 2
Encodage de l’exposant en utilsant une représentation biaisée : e + emax

I faciliter les comparaisons d’exposants
I éviter de faire intervenir les signes des exposants
Norme IEEE 754
Intérêt des nombres dénormalisés
La normalisation de la mantisse (m0 6= 0) implique qu’il n’y a pas de nombre

représentable entre 0 et 2emin .
Cette situation peut être problématique, comme par exemple dans le cas suivant :
if x != y then
z = 1 / (x - y)
I intérêt des nombres dénormalisés
Norme IEEE 754
Intérêt des nombres dénormalisés
La normalisation de la mantisse (m0 6= 0) implique qu’il n’y a pas de nombre

représentable entre 0 et 2emin .
Cette situation peut être problématique, comme par exemple dans le cas suivant :
if x != y then
z = 1 / (x - y)
I intérêt des nombres dénormalisés
Un nombre dénormalisé est de la forme suivante :
x = (−1)s · m · βe , avec m0 = 0 et e = emin .
I encodage de la fraction uniquement, avec un exposant particulier 0
Norme IEEE 754
Nombres spéciaux {±0, ±∞, NaN}
Le standard IEEE 754-2008 également trois nombres spéciaux (ou valeurs

spéciales), et deux zéros :
I deux infinis : +∞, −∞
I Not-a-Numbers : sNaN (signaling-NaN) et qNaN (quiet-NaN) résultat d’un
opération invalide (0/0, par exemple), se propagent dans les calculs
I deux zéros signés : +0 et −0 cohérent avec les deux infinis
1 1
= +∞ et = −∞.
+0 −0
Les quiet-NaN devraient être utilisés pour propager de l’information en dehors

d’une partie de programme conserver un maximum d’information sur le
problème survenu
I faciliter un diagnostic a posteriori
Norme IEEE 754
Encodages des nombres spéciaux en mémoire

... dans le format simple précision
Encodage des valeurs +0 et −0
+0 0 00000000 00000000000000000000
−0 1 00000000 00000000000000000000
Norme IEEE 754
Encodages des nombres spéciaux en mémoire

... dans le format simple précision
Encodage des valeurs +0 et −0
+0 0 00000000 00000000000000000000
−0 1 00000000 00000000000000000000
I deux représentations pour le zéro cohérent avec les deux infinis
Encodage des valeurs +∞, −∞ et NaN (Not a Number)
+∞ 0 11111111 00000000000000000000
−∞ 1 11111111 00000000000000000000
sNaN 1 11111111 00000000000000000001
qNaN 1 11111111 10000000000000000001
I plusieurs représentations pour les deux NaN

I si m1 = 1 quiet NaN
I si m1 = 0 signaling NaN
Norme IEEE 754
Drapeaux en cas d’exception
Aucune exception ne doit entraver le bon déroulement des calculs. Un mécanisme

de drapeaux informe le système sur ce qui s’est produit.
Les 5 drapeaux qui doivent être levés en cas d’exceptions sont :

I opération invalide : le résultat par défaut est un NaN
I division par zéro : le résultat est un infini (±∞)
I dépassement de capacité vers l’infini (overflow) : le résultat est soit ±∞, soit ± le plus
grand nombre flottant (suivant le mode d’arrondi)
I dépassement de capacité vers 0 (underflow) : le résultat est soit ±0, soit ± le plus
petit nombre flottant dénormalisé (suivant le mode d’arrondi)
I résultat inexact : levé lorsque le résultat d’une opération est inexact
Remarque : les drapeaux restent levés jusqu’à remise à zéro (par l’utilisateur)
Norme IEEE 754
Notions d’arrondi et d’arrondi correct
Le résultat d’une opération flottante entre deux nombres flottants n’est, en

général, pas exactement représentable par un nombre flottant.
I le résultat doit être arrondi
La norme IEEE 754 propose 4 modes d’arrondi

I au plus près pair (RN),
I vers +∞ (RU), vers −∞ (RD),
I et vers 0 (RZ)
Norme IEEE 754


I vers +∞ (RU), vers −∞ (RD), RD(x)
RZ(x) si x > 0 RU(x)
I et vers 0 (RZ)
RN(x)
résultat exact x
Norme IEEE 754


I et vers 0 (RZ)
RN(x)
résultat exact x
Norme IEEE 754


I et vers 0 (RZ)
RN(x) si mantisse paire
résultat exact x
Norme IEEE 754

La norme IEEE 754-2008 requiert l’arrondi correct pour les quatres opérations de
√
base (+,−,×,/), la racine carrée ( ) et le fma, et le recommande uniquement
pour les autres opérations (trigonométriques, logarithmes, exponentielles, ...)
Arrondi correct : le résultat d’une opération flottante entre deux nombres flottants
est dans un premier temps calculé avec une précision infinie et un intervalle
d’exposant [emin , emax ] non borné, puis arrondi dans le format considéré suivant le
mode d’arrondi fixé
I le résultat est dit correctement arrondi
Questions ?

01 QualiteNumeriqueLogiciel

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

01 QualiteNumeriqueLogiciel

Transféré par

Droits d'auteur :

Formats disponibles

Master Électronique, Automatique, Informatique Université de Perpignan Via Domitia

Semestre 9 (M2) - Mention Informatique Année universitaire 2012/2013

Qualité Numérique du Logiciel

Représentation des nombres, arithmétique flottante,

Université de Perpignan Via Domitia

2. Représentation des nombres entiers et réels

3. Norme IEEE 754

2. Représentation des nombres entiers et réels

3. Norme IEEE 754

En informatique, les ordinateurs effectuent des calculs

Bourse de Vancouver (1982)

1982 : création d’un nouvel indice de valeur initiale 1000

Au bout de 22 mois : valeur calculée = 524.881 au lieu de 1098.811

Bourse de Vancouver (1982)

1982 : création d’un nouvel indice de valeur initiale 1000

Au bout de 22 mois : valeur calculée = 524.881 au lieu de 1098.811

Source du problème : la valeur calculée était tronquée au lieu d’être arrondie

Missile Patriote (25 février 1991)

Échec lors de l’interception d’un Scud (Dharan, Arabie Saoudite)

Vitesse du missile Scud : 1676 m/s

Premier vol d’Ariane 5 (4 juin 1996)

Après 39 sec. de vol : autodestruction de la fusée

Système de Référence Inertielle (SRI) : calcule la position, la vitesse et

Forte accélération de la fusée dépassement de capacité lors du calcul des

Autres exemples de bugs

I coût ≈ 475 millions $

Autres exemples de bugs

I coût ≈ 475 millions $

Autres exemples de bugs

I coût ≈ 475 millions $

Bug dans Excel 2007 : Problème d’affichage dans Excel 2007

850 × 77.1 100000

Autres exemples de bugs

I coût ≈ 475 millions $

Bug dans Excel 2007 : Problème d’affichage dans Excel 2007

850 × 77.1 100000

Autres exemples de bugs

I coût ≈ 475 millions $

Bug dans Excel 2007 : Problème d’affichage dans Excel 2007

850 × 77.1 65535 100000

I la valeur en machine est correcte seule la valeur affichée est erronée

Suite de J.-M. Muller

Soit un la suite définie par :

 printf ("u( 0) = % 1.19 e\n" ,u0 );

Suite de J.-M. Muller

Soit un la suite définie par :

 printf ("u( 0) = % 1.19 e\n" ,u0 );

$ > ./ suite - jmmuller

Suite de J.-M. Muller

Soit un la suite définie par :

 printf ("u( 0) = % 1.19 e\n" ,u0 );

$ > ./ suite - jmmuller

Suite de J.-M. Muller

Soit un la suite définie par :

 printf ("u( 0) = % 1.19 e\n" ,u0 );

$ > ./ suite - jmmuller

Quelles sont les propriétes d’une bonne arithmétique ?

Rapidité des calculs

Précision des calculs

Dynamique des valeurs représentées

Portabilité des calculs

Facilité d’utilisation et d’implantation

Lien avec la qualité numérique d’un logiciel