2. Nombres flottants

2.1. Introduction

Les nombres réels ne sont pas représentables en totalité en informatique en raison de la forme et de la taille de la représentation utilisée. Nous allons voir que nous ne pouvons en coder qu'une partie. On utilise une notation spécifique issue de la norme IEEE 754. Les nombres qui résultent de cette transformation sont appelés nombres flottants ou nombres à virgule flottante.

En informatique, on note les nombres flottants sous la forme suivante :

zéro : $0.0$, ou parfois $0$ comme pour les entiers, la conversion sera réalisée par le compilateur
$3.14159265$, la virgule est remplacée par le point, il s'agit de la notation anglo-saxonne
$1.89e-3 = 0.00189$, le caractère 'e' ou 'E' représente l'exposant, c'est à dire $10^n$, avec ici $n=-3$

Dans la norme IEEE 754, il existe une modélisation qui utilise 32 bits, appelée également simple précision. La double précision utilise quant à elle 64 bits.

Nous allons étudier la simple précision qui correspond au type float du langage C. Elle consiste à représenter un nombre sous la forme :

$$ 1,0101... × 2^E $$

où la mantisse $1,0101...$ est une suite quelconque de $0$ et de $1$, et $E$ est l'exposant.

1 bit de signe $S$, le bit de poids fort (bit 31) qui vaut 0 pour un nombre positif et 1 pour un nombre négatif
8 bits pour coder l'exposant décalé (ou biaisé) $E_d$, car par convention on lui ajoute 127
23 bits pour coder la mantisse tronquée $M_t$, elle est dite tronquée car on a supprimé le premier bit du nombre qui vaut forcément 1 pour tout nombre différent de 0

Signe	Exposant Décalé								Mantisse Tronquée
1	1	0	0	0	1	0	0	1	0	0	0	0	0	0	0	0	1	1	1	0	1	0	0	0	0	0	0	0	0	0	0
1 bit	← 8 bits →								← 23 bits →

Le nombre réel $n$ qui correspond au nombre flottant s'exprime alors sous la forme :

$$ n = (-1)^S × 1,M_t × 2^(E_d - 127) $$

On peut alors coder des nombres entre ± $3,4027 × 10^{38}$ et ± $1,1754 × 10^{-38}$.

Par exemple :

si $S=1$, $M_t = 0$ et $E_d = 127$, alors on a $n = -1$.
si $S=0$, $M_t=11_2$ et $E_d = 128$, alors on a $n = 1,11_2 × 2^(128-127) = 11,1_2 = 2 + 1 + 0,5 = 3,5$
si $S=0$, $M_t=0$ et $E_d = 0$, alors il s'agit de $+0$
si $S=1$, $M_t=0$ et $E_d = 0$, alors il s'agit de $-0$

Vous pouvez utiliser l'IEEE 754 Converter pour représenter des nombres flottants.

2.1.1. Coder un réel en flottant

Comment coder un nombre réel au format IEEE 754 ? Prenons l'exemple de la représentation en simple précision sur 32 bits du codage de $n = -1027,625$ ci dessous.

On procède comme suit :

il s'agit d'un nombre négatif donc $S = 1$
on code la partie entière en valeur absolue : $$1027_{10} = 1024_{10} + 2_{10} + 1_{10} = 2^{10} + 2^{1} + 2^{0} = 100\_0000\_0011_{2}$$
on code la partie décimale en utilisant des puissances de 2 négatives : $$0,625 = 0,5 + 0, 125 = 2^{-1} + 2^{-3}$$

La mantisse qui regroupe partie entière et décimale est alors:

$$M = 100\_0000\_0011,101_{2}$$

Pour obtenir la mantisse tronquée et l'exposant décalé, il suffit de déplacer la virgule vers la gauche derrière le premier 1 qui compose la mantisse, on parle alors de normalisation du nombre à représenter :

$$1,0000\_0000\_1110\_1_{2}$$

Par conséquent, on a déplacé la virgule de 10 rangs vers la gauche (cf. image ci-dessus) ce qui correspond à l'exposant $E = 10$.

la mantisse tronquée est alors égale à la mantisse à laquelle on a enlevé le premier 1 devant la virgule, on obtient donc $M_t = 0000\_0000\_1110\_1_{2}$
l'exposant décalé est égal, par convention en 32 bits, à $127 + E$, dans notre cas $E = 10$, donc : $$E_d = 127 + 10 = 137_{10} = 1000\_1001_{2}$$

On remplit alors chacun des champs du nombre flottant et on complète la mantisse tronquée par des zéros à droite. Au final on obtient une valeur sur 32 bits que l'on exprime généralement en hexadécimal pour plus de lisibilité. On obtient donc $C4\_80\_74\_00_{16}$.

S	Exposant Décalé								Mantisse Tronquée
1	1	0	0	0	1	0	0	1	0	0	0	0	0	0	0	0	1	1	1	0	1	0	0	0	0	0	0	0	0	0	0
C				4				8				0				7				4				0				0

2.1.2. Pourquoi ajouter 127 à l'exposant ?

The eight-bit exponent uses excess 127 notation. What this means is that the exponent is represented in the field by a number 127 greater than its value. Why? Because it lets us use an integer comparison to tell if one floating point number is larger than another, so long as both are the same sign.

Soit $x$ et $y$ deux nombres décimaux et $x'$ et $y'$ leurs représentations à virgule flottante.

Pour les nombres positifs :

si $x < y$ alors $x' < y'$

Pour les nombres négatifs :

si $x < y$ alors $x' > y'$

pour les nombres positifs :

Exemples de valeurs positives
Nombre	Hexadécimal
0.001	3A_83_12_6F
0.290	3E_94_7A_E1
0.300	3E_99_99_9A
0.310	3E_9E_B8_52
100.000	42_C8_00_00
1.000.000	44_7A_00_00

Comparaison de valeurs positives
x_1	comp	x_2	comp	x_3	comp	x_4
$0,001$	<	$0,29$	<	$10^2$	<	$10^3$
3A_83_12_6F	<	3E_94_7A_E1	<	42_C8_00_00	<	44_7A_00_00
981_668_463	<	1_049_918_177	<	1_120_403_456	<	1_148_846_080

pour les nombres négatifs :

Exemples de valeurs négatives
Nombre	Hexadécimal
-0.001	BA_83_12_6F
-0.290	BE_94_7A_E1
-0.300	BE_99_99_9A
-0.310	BE_9E_B8_52
-100.000	C2_C8_00_00
-1000.000	C4_7A_00_00

Comparaison de valeurs négatives
x_1	comp	x_2	comp	x_3	comp	x_4
$-10^3$	<	$-10^2$	<	$-0,29$	<	$-0,001$
C4_7A_00_00	>	C2_80_00_00	>	BE_94_7A_E1	>	BA_83_12_6F
3_296_329_728	>	3_263_168_512	>	3_197_401_825	>	3_129_152_111

2.1.3. Comment coder la partie décimale ?

Imaginons que nous ayons à coder $0,4$, comment procéder ?

Il existe un algorithme simple pour réaliser le codage :

Cette méthode consiste à multiplier la partie décimale par $2$ jusqu'à obtenir 0 quand cela est possible ou, si on ne s'arrête pas, à obtenir assez de chiffres pour remplir la mantisse.

A chaque étape on garde le chiffre le plus à gauche du résultat (c'est à dire la partie entière) de la multiplication qui sera $1$ ou $0$, puis, on réitère la multiplication sur la partie décimale du résultat de la multiplication en supprimant le premier $1$ s'il existe.

Vous pouvez tester avec un exemple :

Exercice 2.1

Essayer de convertir $0,3$, $0,6$ ou $0,9$ en utilisant cet algorithme.

Que remarquez vous ?

2.1.4. IEEE 754 64 bits et les autres précisions

Pour approfondir...

Pour la modélisation en 64 bits, dite double précision, on utilise :

toujours 1 bit pour le signe comme en 32 bits
11 bits pour l'exposant, on ajoute 1023 pour obtenir l'exposant décalé
52 bits pour la mantisse tronquée

Enfin il existe :

la demi précision qui occupe 16 bits
la simple précision étendue (40 bits), la double précision étendue (80 bits)
la quadruple précision qui utilise 128 bits

Caractéristiques des représentations IEEE 754
Précision :	demi	simple	double	quadruple
Signe (bits)	$1$	$1$	$1$	$1$
Exposant (bits)	$5$	$8$	$11$	$15$
Mantisse (bits)	$11$	$23$	$52$	$113$
Plus petit nombre	$± 6,103 10^{-5}$	$± 1,175 10^{-38}$	$± 2,225 10^{-308}$	$± 3.362 10^{-4932}$
Plus grand nombre	$± 65504$	$± 3,402 10^{38}$	$± 1,797 10^{308}$	$± 1.189 10^{4932}$
Décimales	$3$	$7$	$16$	$34$

2.1.5. Erreurs de précision

Lorsque l'on utilise la représentation IEEE 754, on rencontre deux problèmes liés à la précision des valeurs codées :

Comme on utilise que des puissances de 2 négatives qui se terminent par 5, on ne peut donc coder la plupart des nombres décimaux qu'en utilisant une combinaison de puissances de 2 négatives et cela engendre des erreurs de précision :

Vous pouvez utiliser le formulaire suivant pour calculer la somme des valeurs cochées ou chercher une valeur approchée d'une valeur spécifique comprise entre 0 et 1,0. Vous pouvez essayer avec 0,3 ou 0,33 par exemple.

n	Sel.	2^n
-1		0.50000000000000000000000
-2		0.25000000000000000000000
-3		0.12500000000000000000000
-4		0.06250000000000000000000
-5		0.03125000000000000000000
-6		0.01562500000000000000000
-7		0.00781250000000000000000
-8		0.00390625000000000000000
-9		0.00195312500000000000000
-10		0.00097656250000000000000
-11		0.00048828125000000000000
-12		0.00024414062500000000000
-13		0.00012207031250000000000
-14		0.00006103515625000000000
-15		0.00003051757812500000000
-16		0.00001525878906250000000
-17		0.00000762939453125000000
-18		0.00000381469726562500000
-19		0.00000190734863281250000
-20		0.00000095367431640625000
-21		0.00000047683715820312500
-22		0.00000023841857910156250
-23		0.00000011920928955078125
-24		0.00000005860464477539062

L'autre problème lié à la précision provient du fait que la taille de la mantisse peut être trop petite pour représenter certains nombres qui comportent beaucoup de chiffres, notamment en 32 bits, car on dispose de 7 chiffres significatifs.

Pour approfondir...

C'est pour cela que le coprocesseur arithmétique, que l'on appelle également FPU (Floating Point Unit) qui réalise les opérations sur les nombres flottants, utilise un codage sur 80 bits afin de minimiser les erreurs de précision.

Un processeur contient plusieurs coeurs de calcul et chaque coeur possède une ou plusieurs FPU.

2.1.5.a Exemple

On peut voir sur le listing suivant un exemple de code très simple qui réalise la différence entre des valeurs flottantes proches.

CODE
code c++

#include <iostream>
#include <iomanip>
#include <cmath>
 
// Définition de variables globales
float v1 = 1.2;
float v2 = 1.3;
float v3 = 1.3001;
float v4 = 1.3001001;
 
/* ------------------------------------------------------------------
    QUOI
       Fonction principale
       
   ------------------------------------------------------------------ */
int main() {
 
    float diff_v1_v2 = v1 - v2;
    float diff_v2_v3 = v2 - v3;
 
    std::cout << setprecision(10);
 
    std::cout << "v1-v2 = " << diff_v1_v2 << std::endl;
    std::cout << "v2-v3 = " << diff_v2_v3 << std::endl;
 
    // Comparaison de valeurs flottantes
    float diff_abs = fabs(v3 - v4);
    std::cout << "|v3-v4| = " << diff_abs << std::endl;
 
    if (diff_abs < 1E-6) 
        std::cout << "v3 = v4" << std::endl;
    else
        std::cout << "v3 != v4" << std::endl;
    return 0;
}
 

Cependant, le résultat de l'exécution ne correspond pas à ce que nous devrions obtenir :

v1-v2 = -0.09999990463     ! et non -0.1
v2-v3 = -0.0001000165939   ! et non -0.0001
|v3-v4| = 1.192092896e-07  ! et non  0.0000001
v3 = v4

la différence v1 - v2 devrait être égale à $-0.1$
et celle de v2 - v3 devrait être de $-0.0001$

Cela est dû au fait qu'il est impossible de coder exactement certaines valeurs comme nous l'avons expérimenté pour représenter $0,3$.

Le problème lié aux erreurs de précision implique que pour comparer deux valeurs en virgule flottante on ne peut pas utiliser l'opérateur d'égalité (==) du langage C comme on le ferait pour des entiers, il est nécessaire d'utiliser la valeur absolue de la différence des deux valeurs (lignes 27 et 30 du listing précédent) et de vérifier que cette différence est bien inférieure à un $ε$ donné.

On doit donc écrire :

// permet de comparer deux float
if (fabs(x1 - x2) < 1e-6) {
    // égalité
}

au lieu de :

// ne permet pas de comparer deux float
if (x1 == x2) {
    // égalité
}

Si on utilise une précision plus grande de 64 bits, c'est à dire un double en langage C, on obtient un résultat qui correspond à un calcul exact :

v1-v2 = -0.1
v2-v3 = -0.0001
|v3-v4| = 1.000000001e-07
v3 = v4

Néanmoins, on obtiendra les mêmes erreurs de précision dès lors que les nombres à traiter possèdent un nombre de chiffres après la virgule important qui dépasse la capacité de représentation des nombres en double précision.

Pour approfondir...

Si on désire faire des calculs exacts, il existe une librairie dédiée appelée GMP pour The GNU Multiple Precision Arithmetic Library.

Pour les entiers :

CODE
gmp_integer_example.cpp

// compiler avec g++ -o gmp_integer_example.exe gmp_integer_example.cpp -O3 -lgmp
#include <gmp.h>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
 
// fonction qui transforme une chaine de la forme 1289347884
// en 1_289_347_884
 
string separateur(const string& input, char separator = '_') {
    string result;
    int count = 0;
 
    // Iterate the string in reverse order
    for (int i = input.size() - 1; i >= 0; --i) {
        result.push_back(input[i]);
        count++;
 
        // Insert separator every 3 digits, but not after the last group
        if (count == 3 && i != 0) {
            result.push_back(separator);
            count = 0;
        }
    }
 
    // Reverse the result string back to correct order
    std::reverse(result.begin(), result.end());
    return result;
}
 
ostream& operator<<(ostream& out, mpz_t& z) {
    char* str = mpz_get_str(nullptr, 10, z);  
    out << separateur( str );  // Output the string to the stream
    free(str);
    return out;
}
 
int main() {
    mpz_t a, b;
    
    mpz_init(a);
    mpz_init(b);
    
    // calculer 2^64 en multipliant a=1 par b=2 64 fois
    mpz_set_ui(a, 1);
    mpz_set_ui(b, 2);
    
    for (int i = 1; i <= 64; ++i) {
        mpz_mul(a, a, b);
    }
    
    cout << "2^64 = " << a << endl;
    
    // utiliser la fonction puissance pour calculer 2^128
    mpz_ui_pow_ui(a, 2, 128);
    cout << "2^128 = " << a << endl;
    
    // utiliser la fonction puissance pour calculer 2^32
    mpz_ui_pow_ui(a, 2, 32);
    cout << "2^32 = " << a << endl;
    
    
    mpz_clear(a);
    mpz_clear(b);
    
    return EXIT_SUCCESS;
}
 

L'affichage donnera :

2^64 = 18_446_744_073_709_551_616
2^128 = 340_282_366_920_938_463_463_374_607_431_768_211_456
2^32 = 4_294_967_296

Pour les flottants :

CODE
gmp_float_example.cpp

// compiler avec g++ -o gmp_float_example.exe gmp_float_example.cpp -O3 -lgmp
#include <gmp.h>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
 
enum {
    MPF_OUTPUT_SCIENTIFIC = 1,
    MPF_OUTPUT_FIXED = 2
};
 
int mpf_output_format = MPF_OUTPUT_SCIENTIFIC;
char mpf_buffer[100];
 
std::ostream& mpf_scientific(ostream& out) {
    mpf_output_format = MPF_OUTPUT_SCIENTIFIC;
    return out;
}
 
std::ostream& mpf_fixed(ostream& out) {
    mpf_output_format = MPF_OUTPUT_FIXED;
    return out;
}
 
 
ostream& operator<<(ostream& out, mpf_t& z) {
    if (mpf_output_format == MPF_OUTPUT_SCIENTIFIC) {
        mp_exp_t e;
        mpf_get_str(mpf_buffer, &e, 10, 50, z);
        
        // Convert mantissa to scientific notation
        out << mpf_buffer << "e" << (e-1);
 
    } else {
        gmp_sprintf(mpf_buffer, "%.50Ff", z);
        out << mpf_buffer;
    }
    
    return out;
}
 
int main() {
    mpf_t a, b, c;
 
    // créer des nombres avec une précision de 256 bits
    mpf_init2(a, 256);  
    mpf_init2(b, 256);  
    mpf_init2(c, 256);  
 
    // a = Pi
    mpf_set_str(a, "0.031415926535897932384626433832795028841971693993751", 10);  
    // b = e (nombre d'Euler)
    mpf_set_str(b, "0.0271828182845904523536028747135266249775724709369995", 10);  
 
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
 
    // c = a + b
    mpf_add(c, a, b);
 
    // affichage du résultat au format notation scientifique
    // puis point fixe 
    cout << "a + b = " << mpf_scientific << c << endl;
    cout << "a + b = " << mpf_fixed << c << endl;
 
 
    // c = a * b
    mpf_mul(c, a, b);
    
    cout << "a * b = " << mpf_scientific << c << endl;
    cout << "a * b = " << mpf_fixed << c << endl;
 
    // libération des resources
    mpf_clear(a);
    mpf_clear(b);
    mpf_clear(c);
        
    return EXIT_SUCCESS;
}
 

L'affichage donnera :

a = 31415926535897932384626433832795028841971693993751e-2
b = 27182818284590452353602874713526624977572470936999e-2
a + b = 5859874482048838473822930854632165381954416493075e-2
a + b = 0.05859874482048838473822930854632165381954416493075
a * b = 85397342226735670654635508695465744950348885357651e-4
a * b = 0.00085397342226735670654635508695465744950348885358

Page de Jean-Michel Richer

2. Nombres flottants

2.1. Introduction

2.1.1. Coder un réel en flottant

2.1.2. Pourquoi ajouter 127 à l'exposant ?

2.1.3. Comment coder la partie décimale ?

2.1.4. IEEE 754 64 bits et les autres précisions

2.1.5. Erreurs de précision

2.1.5.a Exemple