Qu'est ce qu'un subnormale nombre à virgule flottante?

IEEE 754 bases

D'abord, passons en revue les principes de base de la norme IEEE 754 les nombres sont organisés.

Nous allons nous concentrer sur simple précision (32 bits), mais tout peut immédiatement être généralisé à d'autres précisions.

Le format est:

• 1 bit: signe
• 8 bits: exposant
• 23 bits: fraction

Ou si vous voulez des photos:

Source.

Le signe est simple: 0 est positif, et 1 est négatif à la fin de l'histoire.

L'exposant 8 bits de long, et il en va de 0 à 255.

L'exposant est appelé biaisée, car elle a un décalage de -127, par exemple:

  0 == special case: zero or subnormal, explained below
  1 == 2 ^ -126
    ...
125 == 2 ^ -2
126 == 2 ^ -1
127 == 2 ^  0
128 == 2 ^  1
129 == 2 ^  2
    ...
254 == 2 ^ 127
255 == special case: infinity and NaN

Le bit de début de la convention

Lors de la conception de la norme IEEE 754, ingénieurs remarqué que tous les nombres, sauf 0.0, ont un 1 en binaire comme le premier chiffre

E. g.:

25.0   == (binary) 11001 == 1.1001 * 2^4
 0.625 == (binary) 0.101 == 1.01   * 2^-1

à la fois commencer avec ça ennuyeux 1. partie.

Par conséquent, il serait du gaspillage de laisser ce chiffre prend un peu de précision presque chaque numéro unique.

Pour cette raison, ils ont créé le "bit de début de la convention":

toujours supposer que le numéro commence par un

Mais alors, comment traiter avec 0.0? Eh bien, ils ont décidé de créer une exception:

• si l'exposant est 0
• et la fraction est de 0
• puis le nombre représente plus ou moins 0.0

de sorte que les octets 00 00 00 00 représentent également 0.0, ce qui semble bon.

Si nous n'en avons tenu compte de ces règles, puis le plus petit nombre différent de zéro qui peut être représenté serait:

• exposant: 0
• fraction: 1

qui ressemble à quelque chose comme cela dans un hex fraction en raison du bit de début de la convention:

1.000002 * 2 ^ (-127)

où .000002 est de 22 zéros avec une 1 à la fin.

Nous ne pouvons pas prendre fraction = 0, sinon, ce nombre serait 0.0.

Mais alors les ingénieurs, qui avait aussi un sens artistique aiguisé, de la pensée: n'est-ce pas laid? Que nous sauter de droite 0.0 à quelque chose qui n'est même pas une bonne puissance de 2? Ne pourrions-nous pas représenter, même les plus petits numéros en quelque sorte?

Subnormale numéros de

Les ingénieurs ont rayé de leur tête pendant un moment, et revint, comme d'habitude, avec une autre bonne idée. Ce qui si nous créons une nouvelle règle:

Si l'exposant est égal à 0, alors:

• le bit de début devient 0
• l'exposant est fixé à -126 (pas -127 comme si nous n'avions pas cette exception)

Ces nombres sont appelés nombres dénormalisés (ou tout nombre dénormalisé qui est synonyme).

Cette règle implique immédiatement que le nombre tel que:

• exposant: 0
• fraction: 0

est 0.0, qui est une sorte de élégant que cela signifie une moins la règle à suivre.

Donc 0.0 est en fait un subnormale nombre, selon notre définition!

Avec cette nouvelle règle, le plus petit non-subnormale nombre est:

• exposant: 1 (0 serait subnormale)
• fraction: 0

qui représente:

1.0 * 2 ^ (-126)

Ensuite, la plus grande subnormale nombre est:

• exposant: 0
• fraction: 0x7FFFFF (23 bits 1)

égal à:

0.FFFFFE * 2 ^ (-126)

où .FFFFFE est une fois de plus de 23 bits vers la droite de la dot.

C'est assez proche de la plus petite à la non-subnormale nombre, ce qui semble sain d'esprit.

Et le plus petit non-zéro subnormale nombre est:

• exposant: 0
• fraction: 1

égal à:

0.000002 * 2 ^ (-126)

qui semble également assez proche de 0.0!

Incapable de trouver une façon sensée pour représenter les nombres plus petits que cela, les ingénieurs ont été heureux, et je suis rentré à la visualisation d'images de chat en ligne, ou peu importe ce qu'ils ont fait dans les années 70 à la place.

Comme vous pouvez le voir, subnormale numéros de faire un compromis entre la précision et de la représentation de la longueur.

Comme l'exemple le plus extrême, le plus petit non-zéro subnormale:

0.000002 * 2 ^ (-126)

a essentiellement une précision d'un seul bits au lieu de 32 bits. Par exemple, si on divise par deux:

0.000002 * 2 ^ (-126) / 2

nous fait atteindre 0.0 exactement!

Visualisation

C'est toujours une bonne idée d'avoir un géométriques intuition sur ce que nous apprenons, donc voilà.

Si nous traçons la norme IEEE 754 les nombres à virgule flottante sur une ligne pour chaque exposant, il ressemble à quelque chose comme ceci:

          +---+-------+---------------+-------------------------------+
exponent  |126|  127  |      128      |              129              |
          +---+-------+---------------+-------------------------------+
          |   |       |               |                               |
          v   v       v               v                               v
          -------------------------------------------------------------
floats    ***** * * * *   *   *   *   *       *       *       *       *
          -------------------------------------------------------------
          ^   ^       ^               ^                               ^
          |   |       |               |                               |
          0.5 1.0     2.0             4.0                             8.0

À partir de là on peut voir que pour chaque exposant:

• pour chaque exposant, il n'y a pas de chevauchement entre les nombres représentés
• pour chaque exposant, nous avons le même nombre 2^32 de nombres (ici représenté par 4 *)
• points sont équidistants pour un exposant
• plus grands exposants de couvrir de plus grandes gammes, mais avec des points plus étalé

Maintenant, laissez-nous arriver à tous le chemin de l'exposant 0.

Sans subnormals, il serait hypothétiquement ressembler à:

          +---+---+-------+---------------+-------------------------------+
exponent  | ? | 0 |   1   |       2       |               3               |
          +---+---+-------+---------------+-------------------------------+
          |   |   |       |               |                               |
          v   v   v       v               v                               v
          -----------------------------------------------------------------
floats    *   ***** * * * *   *   *   *   *       *       *       *       *
          -----------------------------------------------------------------
          ^   ^   ^       ^               ^                               ^
          |   |   |       |               |                               |
          0   |   2^-126  2^-125          2^-124                          2^-123
              |
              2^-127

Avec subnormals, il ressemble à ceci:

          +-------+-------+---------------+-------------------------------+
exponent  |   0   |   1   |       2       |               3               |
          +-------+-------+---------------+-------------------------------+
          |       |       |               |                               |
          v       v       v               v                               v
          -----------------------------------------------------------------
floats    * * * * * * * * *   *   *   *   *       *       *       *       *
          -----------------------------------------------------------------
          ^   ^   ^       ^               ^                               ^
          |   |   |       |               |                               |
          0   |   2^-126  2^-125          2^-124                          2^-123
              |
              2^-127

En comparant les deux graphiques, nous voyons que:

• subnormals le double de la longueur de la plage de l'exposant 0, de [2^-127, 2^-126) à [0, 2^-126)

  L'espace entre les flotteurs dans subnormale gamme est la même que pour [0, 2^-126).

• la gamme [2^-127, 2^-126) a la moitié du nombre de points qu'il aurait sans subnormals.

  De la moitié de ces points pour remplir l'autre moitié de la plage.

• la gamme [0, 2^-127) a certains points avec subnormals, mais aucun sans.

  Ce manque de points dans [0, 2^-127) n'est pas très élégant, et est la principale raison pour subnormals d'exister!

• depuis les points sont équidistants:

  • la gamme [2^-128, 2^-127) a que la moitié des points que [2^-127, 2^-126)
    -[2^-129, 2^-128) a que la moitié des points que [2^-128, 2^-127)
  • et ainsi de suite

  C'est ce que nous entendons pour dire que subnormals sont un compromis entre la taille et la précision.

Praticable C exemple

Maintenant, nous allons jouer avec un code afin de vérifier notre théorie.

Dans presque tous les actuels et les machines de bureau, C float représente simple précision IEEE 754 nombres en virgule flottante.

C'est en particulier le cas pour mon Ubuntu 18.04 amd64 Lenovo P51 ordinateur portable.

Avec cette hypothèse, toutes les affirmations passer sur le programme suivant:

subnormale.c

#if __STDC_VERSION__ < 201112L
#error C11 required
#endif
#ifndef __STDC_IEC_559__
#error IEEE 754 not implemented
#endif
#include <assert.h>
#include <float.h> /* FLT_HAS_SUBNORM */
#include <inttypes.h>
#include <math.h> /* isnormal */
#include <stdlib.h>
#include <stdio.h>
#if FLT_HAS_SUBNORM != 1
#error float does not have subnormal numbers
#endif
typedef struct {
uint32_t sign, exponent, fraction;
} Float32;
Float32 float32_from_float(float f) {
uint32_t bytes;
Float32 float32;
bytes = *(uint32_t*)&f;
float32.fraction = bytes & 0x007FFFFF;
bytes >>= 23;
float32.exponent = bytes & 0x000000FF;
bytes >>= 8;
float32.sign = bytes & 0x000000001;
bytes >>= 1;
return float32;
}
float float_from_bytes(
uint32_t sign,
uint32_t exponent,
uint32_t fraction
) {
uint32_t bytes;
bytes = 0;
bytes |= sign;
bytes <<= 8;
bytes |= exponent;
bytes <<= 23;
bytes |= fraction;
return *(float*)&bytes;
}
int float32_equal(
float f,
uint32_t sign,
uint32_t exponent,
uint32_t fraction
) {
Float32 float32;
float32 = float32_from_float(f);
return
(float32.sign     == sign) &&
(float32.exponent == exponent) &&
(float32.fraction == fraction)
;
}
void float32_print(float f) {
Float32 float32 = float32_from_float(f);
printf(
"%" PRIu32 " %" PRIu32 " %" PRIu32 "\n",
float32.sign, float32.exponent, float32.fraction
);
}
int main(void) {
/* Basic examples. */
assert(float32_equal(0.5f, 0, 126, 0));
assert(float32_equal(1.0f, 0, 127, 0));
assert(float32_equal(2.0f, 0, 128, 0));
assert(isnormal(0.5f));
assert(isnormal(1.0f));
assert(isnormal(2.0f));
/* Quick review of C hex floating point literals. */
assert(0.5f == 0x1.0p-1f);
assert(1.0f == 0x1.0p0f);
assert(2.0f == 0x1.0p1f);
/* Sign bit. */
assert(float32_equal(-0.5f, 1, 126, 0));
assert(float32_equal(-1.0f, 1, 127, 0));
assert(float32_equal(-2.0f, 1, 128, 0));
assert(isnormal(-0.5f));
assert(isnormal(-1.0f));
assert(isnormal(-2.0f));
/* The special case of 0.0 and -0.0. */
assert(float32_equal( 0.0f, 0, 0, 0));
assert(float32_equal(-0.0f, 1, 0, 0));
assert(!isnormal( 0.0f));
assert(!isnormal(-0.0f));
assert(0.0f == -0.0f);
/* ANSI C defines FLT_MIN as the smallest non-subnormal number. */
assert(FLT_MIN == 0x1.0p-126f);
assert(float32_equal(FLT_MIN, 0, 1, 0));
assert(isnormal(FLT_MIN));
/* The largest subnormal number. */
float largest_subnormal = float_from_bytes(0, 0, 0x7FFFFF);
assert(largest_subnormal == 0x0.FFFFFEp-126f);
assert(largest_subnormal < FLT_MIN);
assert(!isnormal(largest_subnormal));
/* The smallest non-zero subnormal number. */
float smallest_subnormal = float_from_bytes(0, 0, 1);
assert(smallest_subnormal == 0x0.000002p-126f);
assert(0.0f < smallest_subnormal);
assert(!isnormal(smallest_subnormal));
return EXIT_SUCCESS;
}

GitHub en amont.

Compiler et exécuter avec:

gcc -ggdb3 -O0 -std=c11 -Wall -Wextra -Wpedantic -Werror -o subnormal.out subnormal.c
./subnormal.out

C++

En plus d'exposer l'ensemble de C de l'Api C++ expose également quelques extra subnormale une fonctionnalité qui n'est pas aussi facilement disponibles dans C dans <limits>, par exemple:

• denorm_min: Renvoie le minimum positif subnormale valeur de type T

En C++ le trou de l'API est basée sur des modèles pour chaque type à virgule flottante, et est beaucoup plus agréable.

Implémentations

x86_64 et ARMv8 implemens IEEE 754 directement sur le matériel, dont le code C se traduit par.

Subnormals semblent être moins rapide que les normales dans certaines mises en œuvre: Pourquoi changer de 0,1 f 0 ralentir les performances en 10x? Cela est mentionné dans les BRAS de manuel, voir le "ARMv8 la section" détails de cette réponse.

ARMv8 détails

BRAS Manuel de Référence de l'Architecture ARMv8 DDI 0487C.un manuel A1.5.4 "Flush-à-zéro", décrit configurable mode où subnormals sont arrondis à zéro, afin d'améliorer les performances:

Les performances de traitement à virgule flottante peut être réduit en faisant des calculs impliquant les nombres dénormalisés et dépassement de capacité des exceptions. Dans de nombreux algorithmes, cette performance peut être récupéré, sans affecter de manière significative l'exactitude du résultat final, par le remplacement de la dénormalisée les opérandes et les résultats intermédiaires avec des zéros. Pour permettre cette optimisation, BRAS en virgule flottante implémentations permettent une Chasse d'eau-de-mode de zéro pour être utilisé pour différents virgule flottante formats comme suit:

• Pour AArch64:

  • Si FPCR.FZ==1, puis Rincer à Zéro mode est utilisé pour tous Unique de Précision et de Double Précision les entrées et les sorties de toutes les instructions.

  • Si FPCR.FZ16==1, puis Rincer à Zéro mode est utilisé pour tous les Demi-Précision des entrées et des sorties des instructions en virgule flottante, autres que:—les Conversions entre les Demi-Précision et nombres Simple Précision.—Les Conversions entre les Demi-Précision et nombres Double Précision.

A1.5.2 "Floating-point des normes et la terminologie" Tableau A1-3 "Floating-point de la terminologie" confirme que subnormals et denormals sont synonymes:

This manual                 IEEE 754-2008
-------------------------   -------------
[...]
Denormal, or denormalized   Subnormal

C5.2.7 "FPCR, virgule Flottante Registre de Contrôle" décrit comment ARMv8 peut éventuellement déclencher des exceptions ou définir un indicateur de bits à chaque fois que l'entrée d'une opération de virgule flottante est subnormale:

FPCR.IDE, peu [15] d'Entrée de nombres dénormalisés exception de virgule flottante piège de l'activer. Les valeurs possibles sont:

• 0b0 non interceptée le traitement d'exception sélectionnés. Si l'exception de virgule flottante se produit alors la FPSR.IDC bit est mis à 1.

• 0b1 pris au piège de gestion d'exception sélectionnés. Si l'exception de virgule flottante se produit, le PE n'a pas de mise à jour de la FPSR.IDC peu. Le piège de la manipulation de logiciel peut décider de créer le FPSR.IDC bits à 1.

D12.2.88 "MVFR1_EL1, AArch32 Médias et VFP Fonction Registre 1" montre que les nombres dénormalisés support est totalement facultatif en fait, et offre un peu de détecter si il y a du support:

FPFtZ, bits [3:0]

Ras le mode de Zéro. Indique si le floating-point de la mise en œuvre fournit un soutien uniquement pour la Chasse à Zéro mode de fonctionnement. Les valeurs définies sont:

• 0b0000 est Pas mise en œuvre ou le matériel prend en charge uniquement de la Chasse d'eau à Zéro mode de fonctionnement.

• 0b0001 de prise en charge Matérielle complète dénormalisée nombre arithmétique.

Toutes les autres valeurs sont réservées.

En ARMv8-A, les valeurs autorisées sont 0b0000 et 0b0001.

Ceci suggère que lorsque subnormals ne sont pas mises en œuvre, les implémentations juste revenir à rincer à zéro.

L'infini et NaN

Curieux? J'ai écrit un certain nombre de choses à l':

• l'infini: Les plages de la virgule flottante type de données en C?
• NaN: Quelle est la différence entre le calme de NaN et de signalisation NaN?