De plus, il existe une infinité indénombrable de nombres réels, mais il est difficile de conceptualiser cette indénombrabilité. Une manière de l'approcher est donnée par l'argument de la diagonale de Cantor W dont on trouvera une explication très pédagogique dans la vidéo au lien suivant .

Et il faut avoir conscience que, quelles que soient deux bornes a et b (avec a < b), il existe autant de réels dans l'intervalle [a, b] que dans l'ensemble ℝ de tous les nombres réels. (Cette propriété est aussi vraie pour l'ensemble ℚ des nombres rationnels.)

Erreur relative d'encodage

Remarque. L'erreur d'encodage peut parfois être nulle : en effet, les nombres qui sont égaux à une somme finie de puissances croissantes de 2 (éventuellement d'exposant négatif) sont encodables sans erreur.

Notion de chiffres significatifs

Particularités syntaxiques

Syntaxe de codage alternative en notation hexadécimale et puissances de 2

Comme pour les entiers, cette stratégie permet de minimiser les risques de débordement et de pertes de précision au cours de l'évaluation des expressions calculatoires. De plus, elle optimise la capacité de calcul des architectures 64 bits puisque, en mémoire comme en registre, une donnée de type double fait exactement cette largeur.

Toutefois, cette stratégie présente un coût non négligeable en termes de temps de calcul sur des architectures « étroites » comme les cartes à microcontrôleur. C'est pourquoi l'environnement Arduino limite la taille des types double et long double(cf. supra), au détriment de leur étendue et de leur précision (cf. chap. C3‑I ).

Spécification d'un type flottant

Pour coder l'affectation d'une constante littérale à une donnée de type long double, l'emploi du suffixe l ou L est indispensable. Sinon la valeur est encodée dans le type double avant l'affectation proprement dite, avec à la clef une perte de précision.

long double a = 1.1;  // prefix l or L missing!
long double b = 1.1L; // OK

A contrario, coder le suffixe f ou F est inutile pour l'affectation d'une constante littérale à une donnée de type float. En effet, même sans suffixe, la constante sera de toute façon convertie dans le type dans le type float lors de l'affectation. Et a priori, rien ne permet d'affirmer que l'ajout du suffixe f ou F puisse améliorer la vitesse de compilation ou d'exécution du programme, tant les compilateurs modernes intègrent des mécanismes d'optimisation…

float c = 1.1;  
float d = 1.1F; 

Néanmoins, le suffixe f ou F trouve son utilité dans les expressions calculatoires hétérogènes, faisant intervenir des données décimales et entières. Si le type float est systématiquement imposé aux données décimales, les données entières ne seront converties que dans ce type, et non pas dans le type double, avec à la clef un gain en rapidité et en registres de calcul, ce qui est peut être appréciable sur des cartes à microcontrôleur.

Paramètres optionnels

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(void)
{
  printf("   x   |   exp(1/x) \n");
  for (float x = -0.1; x < 0.11; x += 0.05) {
      if (fabs(x) > 0.0001) {
        printf(" %+5.2f | %+.3e \n", x, exp(1/x));
      }
      else {
        printf(" %- 5.0f | not a number\n", round(x+0.0001));
      }
  }
}

   x   |   exp(1/x) 
 -0.10 | +4.540e-05 
 -0.05 | +2.061e-09 
  0    | not a number
 +0.05 | +4.852e+08 
 +0.10 | +2.203e+04 

Attention ! La représentation en mémoire des nombres décimaux est bien plus complexe que celle des entiers. Pour comprendre le principe de l'encodage en binaire des valeurs de types flottants, il est nécessaire de connaître préalablement deux algorithmes élémentaires :

• l'algorithme de formatage d'un nombre décimal en notation scientifique,
• de conversion en base 2 d'un nombre décimal.

Ces algorithmes sont exposés ci‑après.

Formatage en notation scientifique des nombres décimaux

Pour formater en notation scientifique un nombre décimal écrit de la forme x,y × 10ⁿ où x, y et n sont trois chaînes numériques quelconques, l'algorithme est le suivant :

• si x ⩾ 10, on divise x,y par 10 autant de fois que x compte de chiffres en plus de celui des unités et on incrémente d'autant l'exposant n ;
Exemple : le nombre 123,45 × 10⁶⁷ s'écrit 1,2345 × 10⁶⁹ en notation scientifique.
• si x = 0, on multiplie x,y par 10 autant de fois qu'il faut pour obtenir un chiffre des unités non nul et on décrémente d'autant l'exposant n.
Exemple : le nombre 0,00123 × 10⁴⁵ devient 1,2345 × 10⁴² en notation scientifique.

Conversion en base 2 d'un nombre décimal

• Si n > 0, on multiplie x,y par 10 autant de fois que n et on décrémente d'autant n (qui devient nul).
Exemple : le nombre 6,543 × 10² s'écrit 654,3 × 10⁰ soit simplement 654,3 puisque le facteur exponentiel 10⁰ vaut 1.
• Si n < 0, on divise x,y par 10 autant de fois que la valeur absolue de n et on incrémente d'autant n (qui devient nul).
Exemple : le nombre 9,87 × 10⁻³ devient 0,00987 × 10⁰ soit simplement 0,00987 puisque le facteur exponentiel 10⁰ vaut 1.

La conversion en base 2 de la partie entière x s'effectue comme avec n'importe quel entier par divisions euclidiennes successives par 2 (cf. chap. C3‑II ).

Les bits d_k obtenus constituent les coefficients binaires d'une somme discrète pondérée avec des poids de la forme 2^k où k est le rang du bit, allant de 0 à m −1 (m étant le nombre de bit d'encodage).

La conversion en base 2 de la partie décimale 0,y s'effectue via un algorithme « réciproque » de multiplications-soustractions successives sur des valeurs purement décimales (c'est‑à‑dire des nombres de la forme « 0,… ») notées F_k où l'indice k est un rang négatif et commence par k = −1 avec F₋₁ = 0,y. À l'itération de rang k :

• on opère F_k × 2 puis :
• si 2.F_k ⩾ 1, alors F_k−1 = 2.F_k − 1 et on obtient d_k = 1 ;
• sinon, F_k−1 = 2.F_k − 0 = 2.F_k et on obtient d_k = 0 ;
• et ce, en principe, jusqu'à avoir F_k = 0. Mais en pratique, l'algorithme n'a le plus souvent pas de fin – de même qu'une division euclidienne ne s'achève presque jamais si on la prolonge dans le domaine décimal. On doit donc y mettre un terme en acceptant une erreur d'encodage après un nombre d'itérations suffisant pour atteindre une précision acceptable.

Les bits d_k obtenus :

• constituent, comme pour un entier, les coefficients d'une somme discrète pondérée par les poids de la forme 2^k où k est le rang du bit ;
• mais, en attribuant aux bits des rangs négatifs en commençant à −1 pour le bit immédiatement à droite du séparateur décimal, les poids sont fractionnaires, ils valent respectivement 2⁻¹ = 0,5 puis  2⁻² = 0,25 puis 2⁻³ = 0,125, etc.

Formatage normalisé de l'écriture en base 2 d'un nombre décimal

Pour cela, il suffit d'adjoindre à l'écriture du nombre un facteur exponentiel de la forme 2^p et de procéder comme exposé supra . Autant de fois que nécessaire, on déplace le séparateur décimal d'un rang :

• vers la droite en divisant le nombre par 2, donc en incrémentant de 1 l'exposant p pour compenser ;
• vers la gauche en multipliant le nombre par 2, donc en décrémentant de 1 l'exposant p pour compenser.

La répartition des bits des 3 champs sur les octets d'encodage obéit aux règles suivantes :

• le bit de signe est placé au plus haut rang du format ;
• au rang immédiatement inférieur du bit de signe se trouve le bit de poids fort de l'exposant décalé ;
• le bit de poids faible du significande est placé au plus bas rang du format (0).

De plus, conformément au format à précision étendue dit x86 W, le type long double présente deux particularités :

• certains octets ne sont pas utilisés ; ils constituent ce qu'on appelle une marge dans le format (en anglais, padding) ;
• le significande comprend à son plus haut rang un bit supplémentaire (bit 63) qui code la partie entière de la mantisse (integer part), afin d'optimiser la vitesse d'exécution des algorithmes de calcul des opérations sur les valeurs de types flottants.

Toute valeur z encodée dans un type flottant peut donc s'exprimer par le produit :
z = (−1)^s . |z|

Le décalage médian des valeurs d'exposant permet d'encoder les valeurs négatives de p sans recourir à un bit de signe dans le champ de l'exposant et de simplifier les algorithmes de calcul des opérations sur les valeurs décimales. Pour l'encodage d'une valeur décimale normalisée notée z :

• si q < q_med alors p < 0 ;
• si q = q_med alors p = 0 ;
• si q > q_med alors p > 0 ;

et dans tous les cas, on a |z| = m × 2^p  où m est la mantisse de la valeur décimale encodée z.

De plus, les valeurs extrêmes de q sont réservées :

• 00…00 pour les valeurs dites dénormalisées, qui sont de très petites valeurs et qui comprennent les deux zéros ±0 – cf. infra  ;
• 11…11 pour les deux « infinis » (±∞) et les valeurs dites NAN (not a number) – cf. infra .

Les valeurs de q laissées pour l'encodage des valeurs normalisées vont donc de q_min = 1 à q_max = 2^r − 2.

Le poids 2^−w du dernier bit du significande détermine la précision du type flottant. Il donne l'écart entre deux valeurs successives de f, et correspond donc à la pseudo‑constante type_EPSILON.

Détermination de la mantisse

À partir de la valeur f encodée dans le champ du significande, on obtient la valeur m de la mantisse d'un nombre décimal encodé dans un type flottant standard, sachant que cette dernière est toujours de la forme :

• 1,… ₍₂₎ pour les valeurs normalisées ; on a donc m = 1 + f
• 0,… ₍₂₎ pour les valeurs dénormalisées ; on a donc m = f

Comme la distinction entre les valeurs normalisées et dénormalisées est encodée par l'exposant décalé (cf. supra ), le bit unique de la partie entière de la mantisse n'a pas besoin d'être encodé pour le calcul de m. On dit que ce bit est « caché » W (sauf pour le type long double – cf. supra ).

Décodage des valeurs dénormalisées

En « sacrifiant » une valeur d'exposant (la valeur p = −q_med) mais en permettant à la mantisse de prendre des valeurs très petites (jusqu'à 2^−w), cette technique permet de réduire l'intervalle entre les plus petites valeurs encodables négatives et positives. Au lieu de s'étendre entre les valeurs normalisées ±type_MIN, il se réduit à celui entre les valeurs normalisées ±type_TRUE_MIN.

Cet intervalle est appelé l'underflow gap dans la mesure où toute valeur qu'il contient est forcément encodée ±0, ce qu'on qualifie de débordement par valeurs inférieures ou underflow (cf. infra ).

Toutefois, la précision d'encodage des valeurs dénormalisées est moindre que celles des valeurs normalisées. L'écart relatif entre deux valeurs successives n'est pas constant, il croit exponentiellement tandis que les valeurs diminuent, pour atteindre 100 % au voisinage de type_TRUE_MIN. La pseudo‑constante type_EPSILON n'est donc pas représentative des valeurs dénormalisées.

Encodage de valeurs spéciales

Une valeur spéciale dite « infinie » (symbole mathématique ∞) est encodée par son champ du significande égal à 00…00. La valeur du bit de signe 0 ou 1 permet de distinguer respectivement « +∞ » et « −∞ ».

Une valeur spéciale dite « NAN » (pour not a number W) est encodée par son champ du significande différent de 00…00 ; mais ce dernier n'est employé que pour distinguer deux sortes de NAN. Avec la plupart des implémentations :

• de 00…01 à 01…11, il s'agit d'un NAN dit avertisseur – abrégé sNAN (« s » pour signaling) ;
• de 10…00 à 11…11, il s'agit d'un NAN dit silencieux – abrégé qNAN (« q » pour quiet) ;

sachant qu'un sNAN déclenche une condition d'exception lors de l'exécution du programme, contrairement à un qNAN.

Tableau récapitulatif pour le type float

Le tableau ci‑dessous récapitule par catégories de valeurs encodées – dénormalisées, normalisées et spéciales – les plages des codes des champs exposant décalé et significande pour le type standard float.

Par soucis de simplicité, le bit de signe n'est pas pris en compte. Les valeurs encodées sont donc valables au signe ± près.

Propriétés des valeurs ±∞

Les valeurs ±∞ obéissent à des règles de calcul spécifiques. Ces règles sont consignées dans le tableau ci‑dessous, où a désigne une expression de type flottant prenant une valeur numérique quelconque normalisée ou dénormalisée, mais pas infinie ou non définie. On raisonne en valeurs absolues (avec des opérandes signés, le signe du résultat est en général conforme aux règles usuelles de calcul).

Méthode de codage des tests d'égalité des expressions décimales

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>

int main(void)
{
    float a = 0.0;
    printf("      a     |      b     | a == b | |(a - b)/a| <= 10 * ESP\n");
    for (int i = 1; i < 10; i++) {
      a += 0.1;
      float b = i / 10.0;
      printf(" %.8f | %.8f | %3d    | %13d  \n", a, b, a == b, fabs((a - b)/a) <= 10 * FLT_EPSILON);
    }
    return 0;
}

      a     |      b     | a == b | |(a - b)/a| <= 10 * ESP
 0.10000000 | 0.10000000 |   1    |             1  
 0.20000000 | 0.20000000 |   1    |             1  
 0.30000001 | 0.30000001 |   1    |             1  
 0.40000001 | 0.40000001 |   1    |             1  
 0.50000000 | 0.50000000 |   1    |             1  
 0.60000002 | 0.60000002 |   1    |             1  
 0.70000005 | 0.69999999 |   0    |             1  
 0.80000007 | 0.80000001 |   0    |             1  
 0.90000010 | 0.89999998 |   0    |             1