Pourquoi les comparaisons à virgule flottante dans Go donnent-elles parfois des résultats inattendus ?

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

Dans Go, les littéraux et les constantes à virgule flottante conservent une précision arbitraire jusqu'à ce qu'ils soient attribués à un type spécifique. Cependant, certaines opérations et affectations introduisent des différences de précision qui peuvent être inattendues.

Considérez 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)
}

Ce code produit le résultat :

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

Pourquoi ces expressions ne sont-elles pas égales, malgré l'exécution de la même opération à virgule flottante ?

Constantes non typées et Variables

Les littéraux numériques et les constantes dans Go ne sont pas typés, avec une précision illimitée. Lors de l'affectation à une variable, telle que x := 10.1, le littéral est converti au type de la variable (float64 dans ce cas) et perd une certaine précision.

Constantes de pleine précision

En revanche, les expressions littérales comme 10.1*3.0 conservent une précision totale avant l'évaluation. Lorsqu'ils sont affectés à une variable, ils sont immédiatement convertis au type de variable, garantissant ainsi le maintien de la précision.

Considérations sur la précision

Comprendre les différences dans la manipulation de précision peut être crucial pour calculs précis en virgule flottante. Par exemple, lors de la comparaison de valeurs à une tolérance spécifiée, il est important d'utiliser des littéraux ou des expressions avec une précision totale pour éviter les faux positifs.

Documentation

Ce comportement est bien -documenté dans l'article du blog Go "Constantes" sous l'en-tête "Floats", qui explique que même si les constantes numériques ont une précision arbitraire, elles doivent s'adapter à la plage de la variable qu'elles sont attribués à.

Conclusion

La différence de précision entre les constantes à virgule flottante et les variables dans Go est intentionnelle, permettant une plus grande flexibilité et des compromis en termes de performances dans les opérations à virgule flottante. En comprenant ces différences de précision, les programmeurs peuvent optimiser leur code pour plus de précision et d'efficacité.

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!