Go's float32 vs float64 : de quelle précision avez-vous vraiment besoin ?

La précision des nombres à virgule flottante en Go : float32 vs float64

En Go, les nombres à virgule flottante sont représentés à l'aide de l'IEEE Format binaire 754 en base 2. La précision d'un nombre à virgule flottante fait référence au nombre de bits utilisés pour représenter sa mantisse, qui détermine la précision du nombre. Go propose deux types à virgule flottante courants : float32 et float64.

La différence entre ces types réside dans leur précision. Alors que float32 a une mantisse de 23 bits, float64 a une mantisse de 52 bits. Cette précision plus élevée permet à float64 de représenter une plage de valeurs plus large et avec une plus grande précision par rapport à float32.

Pour illustrer cela, considérons l'exemple fourni :

func main() {
    a := float64(0.2) // Initializing a float64 variable
    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)
}

Ce programme démontre l'accumulation d'erreurs en virgule flottante lors de l'exécution d'opérations répétitives sur une valeur. Dans ce cas, la variable « a » est initialisée avec une valeur de 0,2, puis les opérations d'addition et de soustraction sont effectuées avec 0,1 et 0,3, respectivement. Ceci est répété jusqu'à ce que « a » devienne supérieur ou égal à 1,0.

Lorsque vous exécutez ce programme avec float32 au lieu de float64, il entre dans une boucle infinie. En effet, la représentation binaire de 0,1 dans float32 est légèrement différente de sa valeur décimale réelle, ce qui entraîne une erreur d'arrondi. Par conséquent, la valeur de « a » ne s'accumule pas avec précision et la boucle continue indéfiniment.

D'un autre côté, float64 a une plus grande précision et peut représenter les valeurs avec plus de précision. En tant que tel, le même programme utilisant float64 termine finalement la boucle lorsque « a » atteint 1.000000e 00.

Pour mieux comprendre la différence de précision, vous pouvez utiliser les fonctions math.Float32bits et math.Float64bits pour convertir les valeurs flottantes. -pointez les valeurs vers leurs représentations binaires. Cela permet d'examiner la répartition des bits et d'identifier les sources des différences de précision entre float32 et float64.

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!