Pourquoi les comparaisons à virgule flottante dans Go donnent-elles des résultats différents pour les littéraux et les variables ?

Différences de précision à virgule flottante dans Go : littéraux et variables

Dans Go, le comportement de l'arithmétique à virgule flottante peut sembler contradictoire lors de la comparaison opérations impliquant des littéraux et des variables. Examinons le code suivant :

package main

import (
    "fmt"
)

func main() {
    x := 10.1

    fmt.Println("x == 10.1:        ", x == 10.1)
    fmt.Println("x*3.0 == 10.1*3.0:", x*3.0 == 10.1*3.0)
    fmt.Println("x*3.0:            ", x*3.0)
    fmt.Println("10.1*3.0:         ", 10.1*3.0)
}

Une fois exécuté, ce code affiche le résultat suivant :

x == 10.1:         true
x*3.0 == 10.1*3.0: false
x*3.0:             30.299999999999997
10.1*3.0:          30.3

Comme le montre le résultat, la comparaison de x*3.0 et 10.1*3.0 est évalué de manière inattendue à faux. Cela soulève la question de savoir pourquoi cet écart se produit et s'il est intentionnel ou s'il s'agit d'un bug.

Comprendre la conception

Dans Go, les littéraux et les constantes à virgule flottante ont une précision illimitée . Cependant, lorsqu'ils sont affectés à des variables typées, leur précision est limitée par les limites du type cible. Dans l'exemple ci-dessus, x := 10.1 stocke le littéral 10.1 dans une variable float64. Cette conversion introduit une certaine perte de précision en raison des limitations du type float64.

En revanche, l'expression 10.1*3.0 effectue une multiplication en virgule flottante directement sur les littéraux, préservant toute leur précision. Cela se traduit par une valeur légèrement différente par rapport à x*3,0, où la précision réduite de x affecte le calcul.

Documentation et ressources

La documentation officielle de Go le reconnaît comportement dans la section "Flotteurs" de l'article Constantes. Il explique que même si les constantes numériques ont une précision arbitraire, elles doivent correspondre au type de destination lorsqu'elles sont attribuées. Des valeurs élevées comme 1e1000 peuvent être utilisées dans des expressions avec d'autres constantes, mais leur précision peut être affectée lorsque le résultat est stocké dans un type plus étroit.

Bien que l'article ne mentionne pas explicitement le comportement spécifique observé dans notre exemple (x*3.0 contre 10.1*3.0), il fournit une compréhension générale de la façon dont les limitations de précision s'appliquent aux constantes et aux variables typées.

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!