Nombre dénormalisé

La représentation en virgule flottante pour les ordinateurs est fondée sur deux notions : la notation scientifique et le système binaire (ou base 2).

Pour écrire les nombres en base 10, on peut utiliser la notation dite « scientifique », qui comprend deux parties :

• un nombre décimal n, positif ou négatif, dont la valeur absolue est comprise entre 1 inclus et 10 exclus ; 1 ≤ n < 10 ;
• une puissance entière de 10, a ;

sous la forme « n × 10^a ». Par exemple :

• 1 en écriture décimale se note « 1 × 10⁰ » ;
• -85 en écriture décimale se note « -8,5 × 10¹ » ;
• 0,012 3 en écriture décimale se note « 1,23 × 10⁻² ».

Le terme « exposant » correspond à la puissance de 10, et le terme mantisse correspond à la partie décimale. Ainsi, dans « 1,23 × 10⁻² »,

• la mantisse (ou significande) est « 1,23 » ;
• l'exposant est « -2 ».

Le système binaire, dit aussi « base 2 », est une manière de noter les nombres ne faisant intervenir que deux chiffres, 0 et 1. Il est bien adapté à l'électronique, puisque cela correspond à deux états bien distincts : on a aux bornes d'un composant une tension V₀ ou une tension V₁ (« le courant ne passe pas ou le courant passe »). Pour distinguer cette notation de la notation décimale, nous ajoutons ici un « b » à la fin du nombre. Voici quelques exemples de nombres :

• 0b = 0
• 1b = 1 ;
• 10b = 2 ;
• 11b = 3 ;
• 0,1b = 0,5 ;
• 0,01b = 0,25 ;
• 0,11b = 0,75 ;
• …

Un nombre binaire à virgule de quatre chiffres n₁n₀,n_-1n_-2b correspond au nombre décimal n₁ × 2¹ + n₀ × 2⁰ + n_-1 × 2^-1 + n_-2 × 2^-2.

On peut ainsi avoir une notation scientifique binaire :

n₁n₀,n_-1n_-2b peut se noter n₁,n₀n_-1n_-2b × 2¹.

par exemple

• 11b = 1,1b × 2¹
• 0,11b = 1,1b × 2^-1

Dans le cas de la notation scientifique binaire, le nombre à virgule doit être compris entre 1b inclus et 10b exclus (c'est-à-dire 2 exclus), c'est-à-dire que sa partie entière est nécessairement 1b.

Selon ladite norme, la représentation d'un nombre réel peut se décomposer en trois parties :

• le signe, +1 ou -1, sous la forme de un bit ;
• l'exposant décalé, sous la forme de e bits représentant un nombre entier ;
• la mantisse, sous la forme de m bits représentant un nombre positif strictement inférieur à 1.

La valeur du nombre représenté vaut :

valeur = signe × (1 + mantisse) × 2^{(exposant − décalage)}

En effet, en notation scientifique en base binaire, la partie entière est nécessairement 1, il est donc inutile d'utiliser un bit pour la représenter, on se contente de représenter la partie fractionnaire.

Un nombre est dit dénormalisé lorsque

• exposant = 0, et
• mantisse ≠ 0.

Si l'on suivait la même représentation que pour les nombres à exposant non nul, on aurait

valeur = signe × (1 + mantisse) × 2^-décalage

mais la valeur retenue est

valeur = signe × mantisse × 2^{-décalage + 1}

c'est-à-dire que pour un exposant codé sur 8 bits (représentation dite à simple précision), on a

valeur = signe × mantisse × 2^-126

et que pour un exposant codé sur 11 bits (représentation dite à double précision), on a

valeur = signe × mantisse × 2^-1022

Avec les nombres dénormalisés, on abandonne la notation scientifique. Si la mantisse correspond à 0,1b (le « b » signifie que l'on est en mode binaire, en base deux), alors :

• avec la représentation normalisée, on aurait
  valeur = 1,1b × 2^-décalage ;
• avec la représentation dénormalisée, on a
  valeur = 0,1b × 2^{-décalage + 1} = 1b × 2^-décalage

on voit ainsi que le plus petit nombre représentable de manière normalisée est 1,000…00b × 2^-décalage (puisqu'une mantisse nulle et un exposant nul servent à représenter le zéro), alors qu'en représentation dénormalisée, c'est 0,000…01b × 2^-décalage. On peut donc représenter des nombres plus petits. Cela assure également une continuité avec les nombres normalisés, puisque :

• le plus petit nombre normalisé vaut 1,000…00b × 2^{-décalage+ 1}
• le plus grand nombre dé normalisé vaut 0,111…11b × 2^{-décalage + 1}

soit un « saut » de 0,000…01b × 2^{-décalage + 1}

Nous avons donc, en simple précision :

Certaines architectures réalisent des opérations sur les nombres dénormalisés au niveau matériel, cependant il est possible que ces opérations soient effectuées au niveau logiciel. Cela peut avoir pour conséquence de créer des ralentissements conséquents.

Il est possible de demander au processeur de traiter ces nombres au niveau matériel en les ramenant à 0 soit Flush-To-Zero (FTZ) et Denormals-Are-Zero (DAZ). Il faut pour cela activer les bons registres :

sur x86_64:

#if defined(_x86-64)
    asm("stmxcsr -0x4(%rsp)\n\t"          /* stock le registre CSR sur la pile */
        "orl     $0x8040, -0x4(%rsp)\n\t" /* modifie la valeur des  bits 15( FTZ ) and 7( DAZ ) */
        "ldmxcsr -0x4(%rsp)" );           /* charge le registre CSR depuis la pile */
#endif

sur Aarch64:

#if defined(__arm64__) || defined(__aarch64__)
    uint64_t fpcr;
    asm("mrs %0,   fpcr" : "=r"( fpcr ));             /* Charge le registre FPCR */
    asm("msr fpcr, %0"   :: "r"( fpcr | (1 << 24) )); /* Modifie la valeur du 24eme bit (FTZ) */
#endif