Je pense que je devrais ajouter le point de vue d'un concepteur de matériel, puisque je conçois et construis du matériel à virgule flottante. Connaître la source de l'erreur peut aider à comprendre ce qui se passe dans le logiciel et, en fin de compte, j'espère que cela aidera à expliquer pourquoi les erreurs en virgule flottante se produisent et semblent s'accumuler au fil du temps.
1. Aperçu
D'un point de vue technique, la plupart des opérations en virgule flottante comporteront des erreurs, car le matériel effectuant les calculs en virgule flottante n'a besoin que d'une erreur inférieure à la moitié d'une unité dans le dernier bit. Par conséquent, de nombreux matériels s'arrêteront à une précision qui ne nécessite qu'une erreur inférieure à une unité sur le dernier bit d'une seule opération, ce qui est particulièrement problématique dans la division en virgule flottante. Ce qui constitue une opération unique dépend du nombre d’opérandes requis pour cette unité. Pour la plupart, c'est deux, mais certaines unités nécessitent 3 opérandes ou plus. Par conséquent, il n’y a aucune garantie que des opérations répétées entraîneront l’erreur souhaitée, car les erreurs s’accumulent au fil du temps.
2. Norme
La plupart des processeurs suivent la norme
Dans la norme IEEE-754, les concepteurs de matériel sont autorisés à utiliser n'importe quelle valeur d'erreur/epsilon à condition qu'elle soit inférieure à la moitié d'une unité du dernier chiffre, et le résultat ne doit être que inférieur à la moitié de une unité à utiliser immédiatement. La dernière position de l'opération. Ceci explique pourquoi les erreurs s'accumulent lorsque les opérations sont répétées. Pour la double précision IEEE-754, il s'agit du bit 54 car le bit 53 est utilisé pour représenter la partie numérique (normalisée) du nombre à virgule flottante, également connue sous le nom de mantisse (par exemple 5.3 en 5.3e5). Les sections suivantes expliquent plus en détail les causes des erreurs matérielles dans diverses opérations en virgule flottante.
3. Causes des erreurs de division et d'arrondi
La principale cause des erreurs de division en virgule flottante est l'algorithme de division utilisé pour calculer le quotient. La plupart des systèmes informatiques utilisent la multiplication inverse pour calculer la division, principalement
bits (plus quelques bits facultatifs).Z=X/Y、Z = X * (1/Y)。除法是迭代计算的，即每个周期计算商的一些位，直到达到所需的精度，对于 IEEE-754 来说，精度是最后一位误差小于一个单位的任何值。 Y（1/Y）的倒数表在慢除法中被称为商选择表（QST），商选择表的大小（以位为单位）通常是基数的宽度，或者是基数的位数。每次迭代中计算的商，加上一些保护位。对于 IEEE-754 标准，双精度（64 位），它是除法器基数的大小，加上一些保护位 k，其中k>=2。例如，一次计算 2 位商（基数 4）的除法器的典型商选择表将是2+2= 4
3.1 Erreur d'arrondi de division : approximation de l'inverse
Les réciproques dans le tableau de sélection des quotients dépendent de ladivision: division lente comme la division SRT, ou division rapide comme la division Goldschmidt ; chaque entrée est modifiée selon l'algorithme de division pour essayer de produire la plus petite erreur possible ; Quoi qu’il en soit, toutes les réciproques sont des approximations des réciproques réelles et introduiront un élément d’erreur. La division lente et la division rapide calculent le quotient de manière itérative, c'est-à-dire que chaque étape calcule un nombre de chiffres dans le quotient puis soustrait le résultat du dividende. Le diviseur répète ces étapes jusqu'à ce que l'erreur soit inférieure à une demi-unité en dernier lieu. . Les méthodes de division lente calculent le quotient d'un nombre fixe de chiffres à chaque étape et sont généralement moins coûteuses à construire, tandis que les méthodes de division rapide calculent un nombre variable de chiffres à chaque étape et sont généralement plus coûteuses à construire. La partie la plus importante concernant la division est que la plupart d'entre elles reposent sur des multiplications répétées de l'approximationde l'inverse, il est donc facile de faire des erreurs.
4. Erreurs d'arrondi dans d'autres opérations : troncature
Une autre raison des erreurs d'arrondi dans toutes les opérations réside dans les différents modes de troncature de la réponse finale autorisés par IEEE-754. Il y a tronqué, arrondi vers zéro,arrondi au plus proche (par défaut),arrondi vers le bas, arrondi vers le haut. Pour une seule opération, toutes les méthodes introduisent un élément d’erreur inférieur à une unité à la fin. La troncature augmente également de manière cumulative l'erreur finale au fil du temps et avec des opérations répétées. Cette erreur de troncature est particulièrement problématique lorsque l'exponentiation implique une forme de multiplication répétée.
5. Répéter l'opération
Étant donné que le matériel qui effectue les calculs en virgule flottante n'a besoin que de produire un résultat avec une erreur inférieure à la moitié sur le dernier bit en une seule opération, si vous n'y faites pas attention, l'erreur augmentera avec les opérations répétées. C'est pourquoi, dans les calculs qui nécessitent des erreurs limitées, les mathématiciens utilisent des méthodes telles que l'arrondi auArithmétique d'intervalleest combinée avec une variante duMode d'arrondi IEEE 754pour prédire les erreurs d'arrondi et les corriger. L'arrondi au chiffre pair le plus proche (dernier chiffre) est le mode d'arrondi par défaut pour IEEE-754 en raison de l'erreur relative plus faible par rapport aux autres modes d'arrondi.
En bref, la cause première des erreurs dans les opérations en virgule flottante est une combinaison de troncature matérielle et de troncature réciproque lors de la division. Étant donné que la norme IEEE-754 exige uniquement que l'erreur dans le dernier bit d'une opération unique soit inférieure à la moitié, les erreurs en virgule flottante provenant d'opérations répétées s'accumuleront à moins qu'elles ne soient corrigées.
BinairePoint flottantLes mathématiques sont comme ça. Dans la plupart des langages de programmation, il est basé sur lanorme IEEE 754. Le nœud du problème est que les nombres sont représentés dans ce format comme des nombres entiers multipliés par des puissances de 2 ; les nombres rationnels dont les dénominateurs ne sont pas des puissances de 2 (comme0.1，即1/10) ne peuvent pas être représentés exactement.
Pour le standardbinary64格式的0.1, sa représentation peut s'écrire exactement comme
0.10000000000000000055511151231257827021181583404541015625(décimal), ou
En revanche, les nombres rationnels0.1，即1/10peuvent s'écrire exactement comme
0.1(décimal), ou
0x1.99999999999999...p-4类似于 C99 十六进制浮点表示法，其中...signifie une séquence infinie de 9.
Les constantes0.2et0.3dans le programme seront également des approximations de leurs vraies valeurs. Il se trouve que ledoublele plus proche de0.2est plus grand que le nombre rationnel0.2, mais le plus proche dedoublecode>0.3 Inférieur à un nombre rationnel0.3. La somme de0.2和0.3也将是其真实值的近似值。碰巧，最接近0.2的double大于有理数0.2，但最接近doublecode>0.3 小于有理数0.3。0.1和0.2的总和最终大于有理数0.3et0,2finit par être supérieure au nombre rationnel0,3et est donc incompatible avec la constante du code.
Les vieux nombres décimaux (base 10) ont le même problème, c'est pourquoi un nombre comme 1/3 finit par être 0,333333333...
Vous venez de tomber sur un nombre (3/10) qui est facilement représenté en décimal, mais pas en binaire. Cela va aussi dans les deux sens (dans une certaine mesure) : 1/16 est un nombre laid en décimal (0,0625), mais en binaire, il ressemble au 10 000e décimal (0,0001)** - si nous sommes en retard, nous avons un l'habitude d'utiliser un système numérique de base 2 dans notre vie quotidienne, et vous verrez même le nombre et comprendrez instinctivement que vous pouvez atteindre ce nombre en divisant par deux quelque chose, et en le divisant par deux encore, encore et encore.
Bien sûr, ce n'est pas exactement ainsi que les nombres à virgule flottante sont stockés en mémoire (ils utilisent la notation scientifique). Cependant, cela illustre que des erreurs de précision binaires à virgule flottante ont tendance à se produire parce que les nombres du « monde réel » qui nous intéressent habituellement sont généralement des puissances de dix – mais c'est uniquement parce que nous utilisons le système de nombres décimaux à l'époque – aujourd'hui. C'est pourquoi nous disons 71 % au lieu de « 5 sur 7 » (71 % est une approximation car 5/7 ne peut être représenté exactement par aucun nombre décimal).
Donc non : les nombres binaires à virgule flottante ne sont pas cassés, ils sont simplement imparfaits comme tous les autres systèmes numériques basés sur N :)
En pratique, ce problème de précision signifie que vous devez utiliser une fonction d'arrondi pour arrondir les nombres à virgule flottante au nombre de décimales qui vous intéresse avant de les afficher.
Il faut également remplacer le test d'égalité par une comparaison qui autorise un certain degré de tolérance, ce qui signifie :
Ne pasne pasfaireif (x == y) { ... }
Exécutez plutôtif (abs(x - y) .
Lequelabs是绝对值。myToleranceValuedoit être choisi en fonction de votre application spécifique - cela a beaucoup à voir avec la "marge de manœuvre" que vous êtes prêt à accorder, et quel sera probablement le plus grand nombre que vous comparez (en raison de problèmes de perte de précision) . Notez les constantes de style "epsilon" dans la langue de votre choix. Celles-cipeuventêtre utilisées comme valeurs de tolérance, mais leur efficacité dépend de la taille (taille) des nombres avec lesquels vous travaillez, car les calculs sur de grands nombres peuvent dépasser le seuil epsilon.
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
Point de vue du concepteur de matériel
Je pense que je devrais ajouter le point de vue d'un concepteur de matériel, puisque je conçois et construis du matériel à virgule flottante. Connaître la source de l'erreur peut aider à comprendre ce qui se passe dans le logiciel et, en fin de compte, j'espère que cela aidera à expliquer pourquoi les erreurs en virgule flottante se produisent et semblent s'accumuler au fil du temps.
1. Aperçu
D'un point de vue technique, la plupart des opérations en virgule flottante comporteront des erreurs, car le matériel effectuant les calculs en virgule flottante n'a besoin que d'une erreur inférieure à la moitié d'une unité dans le dernier bit. Par conséquent, de nombreux matériels s'arrêteront à une précision qui ne nécessite qu'une erreur inférieure à une unité sur le dernier bit d'une seule opération, ce qui est particulièrement problématique dans la division en virgule flottante. Ce qui constitue une opération unique dépend du nombre d’opérandes requis pour cette unité. Pour la plupart, c'est deux, mais certaines unités nécessitent 3 opérandes ou plus. Par conséquent, il n’y a aucune garantie que des opérations répétées entraîneront l’erreur souhaitée, car les erreurs s’accumulent au fil du temps.
2. Norme La plupart des processeurs suivent la normeIEEE-754, mais certains utilisent des normes dénormalisées ou différentes . Par exemple, il existe un mode de dénormalisation dans IEEE-754 qui permet de représenter de très petits nombres à virgule flottante au détriment de la précision. Cependant, le mode standardisé IEEE-754 est décrit ci-dessous, qui constitue le mode de fonctionnement typique.
Dans la norme IEEE-754, les concepteurs de matériel sont autorisés à utiliser n'importe quelle valeur d'erreur/epsilon à condition qu'elle soit inférieure à la moitié d'une unité du dernier chiffre, et le résultat ne doit être que inférieur à la moitié de une unité à utiliser immédiatement. La dernière position de l'opération. Ceci explique pourquoi les erreurs s'accumulent lorsque les opérations sont répétées. Pour la double précision IEEE-754, il s'agit du bit 54 car le bit 53 est utilisé pour représenter la partie numérique (normalisée) du nombre à virgule flottante, également connue sous le nom de mantisse (par exemple 5.3 en 5.3e5). Les sections suivantes expliquent plus en détail les causes des erreurs matérielles dans diverses opérations en virgule flottante. 3. Causes des erreurs de division et d'arrondi La principale cause des erreurs de division en virgule flottante est l'algorithme de division utilisé pour calculer le quotient. La plupart des systèmes informatiques utilisent la multiplication inverse pour calculer la division, principalementbits (plus quelques bits facultatifs).
Z=X/Y、Z = X * (1/Y)。除法是迭代计算的，即每个周期计算商的一些位，直到达到所需的精度，对于 IEEE-754 来说，精度是最后一位误差小于一个单位的任何值。 Y（1/Y）的倒数表在慢除法中被称为商选择表（QST），商选择表的大小（以位为单位）通常是基数的宽度，或者是基数的位数。每次迭代中计算的商，加上一些保护位。对于 IEEE-754 标准，双精度（64 位），它是除法器基数的大小，加上一些保护位 k，其中k>=2。例如，一次计算 2 位商（基数 4）的除法器的典型商选择表将是2+2= 43.1 Erreur d'arrondi de division : approximation de l'inverse
Les réciproques dans le tableau de sélection des quotients dépendent de ladivision: division lente comme la division SRT, ou division rapide comme la division Goldschmidt ; chaque entrée est modifiée selon l'algorithme de division pour essayer de produire la plus petite erreur possible ; Quoi qu’il en soit, toutes les réciproques sont des approximations des réciproques réelles et introduiront un élément d’erreur. La division lente et la division rapide calculent le quotient de manière itérative, c'est-à-dire que chaque étape calcule un nombre de chiffres dans le quotient puis soustrait le résultat du dividende. Le diviseur répète ces étapes jusqu'à ce que l'erreur soit inférieure à une demi-unité en dernier lieu. . Les méthodes de division lente calculent le quotient d'un nombre fixe de chiffres à chaque étape et sont généralement moins coûteuses à construire, tandis que les méthodes de division rapide calculent un nombre variable de chiffres à chaque étape et sont généralement plus coûteuses à construire. La partie la plus importante concernant la division est que la plupart d'entre elles reposent sur des multiplications répétées de l'approximationde l'inverse, il est donc facile de faire des erreurs.
4. Erreurs d'arrondi dans d'autres opérations : troncature
Une autre raison des erreurs d'arrondi dans toutes les opérations réside dans les différents modes de troncature de la réponse finale autorisés par IEEE-754. Il y a tronqué, arrondi vers zéro,arrondi au plus proche (par défaut),arrondi vers le bas, arrondi vers le haut. Pour une seule opération, toutes les méthodes introduisent un élément d’erreur inférieur à une unité à la fin. La troncature augmente également de manière cumulative l'erreur finale au fil du temps et avec des opérations répétées. Cette erreur de troncature est particulièrement problématique lorsque l'exponentiation implique une forme de multiplication répétée.
5. Répéter l'opération
Étant donné que le matériel qui effectue les calculs en virgule flottante n'a besoin que de produire un résultat avec une erreur inférieure à la moitié sur le dernier bit en une seule opération, si vous n'y faites pas attention, l'erreur augmentera avec les opérations répétées. C'est pourquoi, dans les calculs qui nécessitent des erreurs limitées, les mathématiciens utilisent des méthodes telles que l'arrondi auArithmétique d'intervalleest combinée avec une variante duMode d'arrondi IEEE 754pour prédire les erreurs d'arrondi et les corriger. L'arrondi au chiffre pair le plus proche (dernier chiffre) est le mode d'arrondi par défaut pour IEEE-754 en raison de l'erreur relative plus faible par rapport aux autres modes d'arrondi.
Veuillez noter que le mode d'arrondi par défaut arrondit aunombre pair a> le plus proche du dernier chiffre, garantissant ainsi que l'erreur du dernier chiffre en une opération est inférieure à la moitié. La troncature, l'arrondi vers le haut et l'arrondi vers le bas seuls peuvent entraîner des erreurs supérieures à la moitié du dernier chiffre mais inférieures à une unité du dernier chiffre. Ces modes ne sont donc pas recommandés, sauf pour l'arithmétique des intervalles.
6. Résumé
En bref, la cause première des erreurs dans les opérations en virgule flottante est une combinaison de troncature matérielle et de troncature réciproque lors de la division. Étant donné que la norme IEEE-754 exige uniquement que l'erreur dans le dernier bit d'une opération unique soit inférieure à la moitié, les erreurs en virgule flottante provenant d'opérations répétées s'accumuleront à moins qu'elles ne soient corrigées.
BinairePoint flottantLes mathématiques sont comme ça. Dans la plupart des langages de programmation, il est basé sur lanorme IEEE 754. Le nœud du problème est que les nombres sont représentés dans ce format comme des nombres entiers multipliés par des puissances de 2 ; les nombres rationnels dont les dénominateurs ne sont pas des puissances de 2 (comme
0.1，即1/10) ne peuvent pas être représentés exactement.Pour le standard
binary64格式的0.1, sa représentation peut s'écrire exactement comme0.10000000000000000055511151231257827021181583404541015625(décimal), ou0x1.999999999999ap-4Représentation hexadécimale à virgule flottante C99.En revanche, les nombres rationnels
0.1，即1/10peuvent s'écrire exactement comme0.1(décimal), ou0x1.99999999999999...p-4类似于 C99 十六进制浮点表示法，其中...signifie une séquence infinie de 9.Les constantes
0.2et0.3dans le programme seront également des approximations de leurs vraies valeurs. Il se trouve que ledoublele plus proche de0.2est plus grand que le nombre rationnel0.2, mais le plus proche dedoublecode>0.3 Inférieur à un nombre rationnel0.3. La somme de0.2和0.3也将是其真实值的近似值。碰巧，最接近0.2的double大于有理数0.2，但最接近doublecode>0.3 小于有理数0.3。0.1和0.2的总和最终大于有理数0.3et0,2finit par être supérieure au nombre rationnel0,3et est donc incompatible avec la constante du code.Un traitement assez complet des problèmes d'arithmétique à virgule flottante estTout informaticien devrait connaître l'arithmétique à virgule flottante. Pour une explication plus compréhensible, voirfloating-point-gui.de.
Les vieux nombres décimaux (base 10) ont le même problème, c'est pourquoi un nombre comme 1/3 finit par être 0,333333333...
Vous venez de tomber sur un nombre (3/10) qui est facilement représenté en décimal, mais pas en binaire. Cela va aussi dans les deux sens (dans une certaine mesure) : 1/16 est un nombre laid en décimal (0,0625), mais en binaire, il ressemble au 10 000e décimal (0,0001)** - si nous sommes en retard, nous avons un l'habitude d'utiliser un système numérique de base 2 dans notre vie quotidienne, et vous verrez même le nombre et comprendrez instinctivement que vous pouvez atteindre ce nombre en divisant par deux quelque chose, et en le divisant par deux encore, encore et encore.
Bien sûr, ce n'est pas exactement ainsi que les nombres à virgule flottante sont stockés en mémoire (ils utilisent la notation scientifique). Cependant, cela illustre que des erreurs de précision binaires à virgule flottante ont tendance à se produire parce que les nombres du « monde réel » qui nous intéressent habituellement sont généralement des puissances de dix – mais c'est uniquement parce que nous utilisons le système de nombres décimaux à l'époque – aujourd'hui. C'est pourquoi nous disons 71 % au lieu de « 5 sur 7 » (71 % est une approximation car 5/7 ne peut être représenté exactement par aucun nombre décimal).
Donc non : les nombres binaires à virgule flottante ne sont pas cassés, ils sont simplement imparfaits comme tous les autres systèmes numériques basés sur N :)
En pratique, ce problème de précision signifie que vous devez utiliser une fonction d'arrondi pour arrondir les nombres à virgule flottante au nombre de décimales qui vous intéresse avant de les afficher.
Il faut également remplacer le test d'égalité par une comparaison qui autorise un certain degré de tolérance, ce qui signifie :
Ne pasne pasfaire
if (x == y) { ... }Exécutez plutôt
if (abs(x - y) .Lequel
abs是绝对值。myToleranceValuedoit être choisi en fonction de votre application spécifique - cela a beaucoup à voir avec la "marge de manœuvre" que vous êtes prêt à accorder, et quel sera probablement le plus grand nombre que vous comparez (en raison de problèmes de perte de précision) . Notez les constantes de style "epsilon" dans la langue de votre choix. Celles-cipeuventêtre utilisées comme valeurs de tolérance, mais leur efficacité dépend de la taille (taille) des nombres avec lesquels vous travaillez, car les calculs sur de grands nombres peuvent dépasser le seuil epsilon.