Types flottants

        

Les flottants sont des représentations en mémoire d'une partie des nombres rationnels (il est évidemment impossible de représenter des nombres réels quelconques, pour des raisons de cardinalité). Seuls les rationnels dyadiques peuvent avoir une représentation exacte ; les autres ont nécessairement une représentation approchée (par exemple, le nombre décimal 1/10 a $0,00011\underline{0011}\ldots_2$ comme représentation en base 2, la partie soulignée étant répétée indéfiniment). Cette représentation fait l'objet de la norme IEEE 754, proposée par William Kahan (Turing Award 1989), publiée en 1985 et adoptée par la plupart des fabricants d'ordinateurs (Cray étant une exception notable). Cette norme distingue deux niveaux de précision : simple (sur 4 octets) et double (sur 8 octets).

Prenons l'exemple des flottants en simple précision ; les 32 bits (b_i) sont répartis en :

• 1 bit de signe, b₃₁
• 8 bits d'exposant, $b_{30}\ldots b_{23}$
• 23 bits de mantisse, $b_{22}\ldots b_{0}$

La valeur d'un flottant normalisé est $(-1)^s \times f \times 2^e$, où

• s = b₃₁
• $e = b_{30}2^7 + b_{29} 2^6 +\ldots + 2^1 b_{24} + b_{23} - 127$
• $f = 1 + b_{22} 2^{-1} + b_{21} 2 ^{-2} + \ldots + b_{0} 2^{-23}$

  

Figure 8: Flottants

Dans l'exposant, soustraire 127 permettrait de représenter le plus petit exposant, 2^-127, par les bits 0000 0000 et le plus grand exposant, 2¹²⁸, par les bits 1111 1111 ; 2⁰ est par exemple représenté par 0111 1111. En fait, 0000 0000 et 1111 1111 ont des significations spéciales, pour représenter 0, $+/- \infty$, et NaN (c'est-à-dire Not a Number ) ; les exposants extrêmes des flottants normalisés sont donc 2^-126 (par 0000 0001) et 2¹²⁷ (par 1111 1110).

La valeur de la mantisse étant toujours $1+\ldots$, zéro n'est pas représentable dans ce schéma ; par convention, le bit de signe suivi de 31 bits nuls représentent la valeur $(-1)^s\times 0$ (et non $(-1)^s\times 2^{-127}$). Il y aurait alors un << trou >> entre 0 et le plus petit nombre normalisé, qui a comme bits d'exposant 0000 0001 et les bits de mantisse nuls. Pour combler ce trou, on convient que si les 8 bits d'exposant sont nuls, la valeur est un flottant dénormalisé , de valeur $(b_{22} 2^{-1} + b_{21} 2 ^{-2} + \ldots + b_{0} 2^{-23}) 2^{-126}$.

 

Si les bits d'exposant valent 1, et les bits de mantisse valent 0, la valeur est $(-1)^s \infty$, qui est obtenue dans le cas d'une division par 0. Enfin, si les bits d'exposant valent 1, et les bits de mantisse ne sont pas tous nuls, la valeur est NaN , qui peut être obtenue comme le résultat d'opérations illicites, comme 0/0 , $\log (-1)$, ou $\infty-\infty$.

Bien que portant les mêmes noms (addition, multiplication), les opérations flottantes ne sont pas ces opérations mathématiques, et n'ont pas les mêmes propriétés. Par exemple, l'addition n'est pas associative : on peut vérifier que (10000003.0 -10000000.0)+7.501 = 10.501, tandis que 10000003.0 + (-10000000.0 +7.501) = 11.0. Autre exemple : la série $1.0+1.0+1.0+\cdots$ converge !

Il est souhaitable que le numéricien programmeur ait une idée de l'implémentation des flottants, sans qu'il doive nécessairement en connaître tous les détails. Il y a en C plusieurs niveaux de précision, qui caractérisent différents types flottants : float (sur 4 octets), double (sur 8) et long double (sur 8 ou 16). Diverses constantes sont définies dans float.h :

• FLT_EPSILON : le plus petit x de type float tel que $1.0 + x \not=1.0$
• FLT_MIN et FLT_MAX, le plus petit et le plus grand float

Il y a des constantes analogues DBL_EPSILON, DBL_MIN et DBL_MAX pour le type double.

On ne testera jamais l'égalité de deux flottants avec == ou != ; il est préférable de tester un écart relatif :

  if (fabs(x-y) < epsilon * x) { ... }

Les valeurs de type double peuvent être notées avec un signe, un point décimal et un exposant optionnel. Pour le type float, la constante doit être terminée par f :

const double pi = 3.141592653;
const float avogadro = 6.02e23f;

Un nombre flottant peut être lu sur l'entrée standard avec la fonction scanf, et écrit sur la sortie standard avec printf ; en écriture, on utilise l'indicateur de conversion   %f pour la notation flottante ou %e  pour la notation scientifique ; la lecture d'un double utilise la conversion %lf:

   

  float x;
  double y;
  scanf("%f%lf", &x, &y);
  printf("%f\t%e%f\t%e", x, x, y, y);

La précision peut être indiquée entre le % et le caractère f ou e : %6.2f spécifie une impression sur au moins 6 caractères, dont 2 après le point décimal, le tout calé à droite.