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 dont la forme irréductible est $n/2^q$, 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_{31}$
• 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_{31}$
• $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}$

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^{128}$, par les bits 1111 1111 ; $2^0$ 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^{127}$ (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 cfloat :

• 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;

Certaines constantes mathématiques sont définies dans <cmath>, en particulier $\pi$ par M_PI.

Un nombre flottant peut être lu sur l'entrée standard (le clavier) cin au moyen de l'opérateur >>, et écrit sur la sortie standard (l'écran) cout au moyen de l'opérateur << :

  double x;
  cin >> x;
  cout << x;

La précision peut être indiquée de la façon suivante (ici, 15 chiffres significatifs, sinon 6 chiffres par défaut) :

  cout.precision(15);
  cout << x;

Le format scientifique (pour obtenir, par exemple, 1.5421e-3) le format fixe, et le format par défaut peuvent être spécifiés de la façon suivante :

  cout.setf(ios::scientific, ios::floatfield);
  cout << "format scientifique : " << x;
  cout.setf(ios::fixed, ios::floatfield);
  cout << "format fixe : "  << x;
  cout.setf(0,ios::floatfield);
  cout << "format par défaut : "  << x;