Maison > développement back-end > Golang > Précision en virgule flottante de Go : pourquoi « float32 » provoque-t-il des boucles infinies alors que « float64 » ne le fait pas ?

Précision en virgule flottante de Go : pourquoi « float32 » provoque-t-il des boucles infinies alors que « float64 » ne le fait pas ?

DDD
Libérer: 2024-12-24 14:56:11
original
467 Les gens l'ont consulté

Go's Floating-Point Precision: Why Does `float32` Cause Infinite Loops While `float64` Doesn't?

Précision de la virgule flottante dans Go : float32 vs float64

Dans Go, les nombres à virgule flottante sont représentés à l'aide du format binaire IEEE 754. Ce format offre différents niveaux de précision en fonction du type de données utilisé, float32 offrant moins de précision que float64.

Considérez l'extrait de code suivant, qui démontre浮点数误差:

package main

import "fmt"

func main() {
    a := float64(0.2)
    a += 0.1
    a -= 0.3
    var i int
    for i = 0; a < 1.0; i++ {
        a += a
    }
    fmt.Printf("After %d iterations, a = %e\n", i, a)
}
Copier après la connexion

Quand en utilisant float64, le programme affiche correctement :

After 54 iterations, a = 1.000000e+00
Copier après la connexion

Cependant, si float32 est utilisé à la place, le programme entre dans une boucle infinie. En effet, float32 ne peut pas représenter exactement la valeur décimale 0,1, ce qui donne une valeur légèrement arrondie. Cette valeur arrondie empêche la boucle de se terminer.

Pour comprendre cette différence, examinez la représentation binaire des valeurs à virgule flottante impliquées :

float32(0.1): 00111101110011001100110011001101
float32(0.2): 00111110010011001100110011001101
float32(0.3): 00111110100110011001100110011010
float64(0.1): 0011111110111001100110011001100110011001100110011001100110011010
float64(0.2): 0011111111001001100110011001100110011001100110011001100110011010
float64(0.3): 0011111111010011001100110011001100110011001100110011001100110011
Copier après la connexion

Notez que la représentation binaire de 0,1 dans float32 est légèrement différent de celui de float64. Cette légère différence entraîne une interprétation différente de la valeur par le type float32, entraînant le comportement observé.

En résumé, lors de l'utilisation de float32, la valeur approximative de 0,1 est stockée en mémoire, ce qui affecte la précision et précision des opérations en virgule flottante. En revanche, float64 peut représenter plus précisément la valeur décimale 0,1, permettant des calculs plus précis.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal