Maison > développement back-end > Golang > Pourquoi les comparaisons à virgule flottante dans Go donnent-elles parfois des résultats inattendus ?

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

Patricia Arquette
Libérer: 2024-12-04 11:33:09
original
777 Les gens l'ont consulté

Why Do Floating-Point Comparisons in Go Sometimes Yield Unexpected Results?

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)
}
Copier après la connexion

Ce code produit le résultat :

x == 10.1:         true
x*3.0 == 10.1*3.0: false
Copier après la connexion

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!

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
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal