C # Arithmétique à virgule flottante: Pièges de précision et de comparaison
L'arithmétique à virgule flottanteC #, bien que pratique, souffre d'une imprécision inhérente en raison de sa représentation finie. Cela peut conduire à des résultats inattendus lors de la comparaison des valeurs apparemment égales.
Considérez cet exemple:
<code class="language-csharp">class Program { static void Main(string[] args) { float f1 = 0.09f * 100f; float f2 = 0.09f * 99.999999f; Console.WriteLine(f1 > f2); // Outputs "false" } }</code>
La sortie est contre-intuitive. Pourquoi? Parce que les flotteurs 32 bits en C # ont une précision limitée (environ 23 bits significatifs). Les calculs impliquant 0.09f
introduisent des erreurs d'arrondi. Alors que f1
et f2
apparaissent près, leurs représentations à virgule flottante arrondi diffèrent légèrement, ce qui rend la comparaison f1 > f2
retour false
.
Cela met en évidence une limitation critique: l'égalité directe ou les comparaisons d'inégalité des nombres à virgule flottante ne sont pas fiables. Des différences infimes, imperceptibles pour l'observation humaine, peuvent faire échouer les comparaisons.
Pour éviter ces problèmes, évitez les vérifications directes de l'égalité. Au lieu de cela, utilisez une comparaison basée sur la tolérance:
<code class="language-csharp">bool AreApproximatelyEqual(float a, float b, float tolerance) { return Math.Abs(a - b) < tolerance; }</code>
Cette fonction vérifie si la différence absolue entre deux flotteurs est inférieure à un tolerance
prédéfini. Le choix d'un tolerance
approprié dépend du contexte et du niveau de précision attendu. Pour une précision plus élevée, envisagez d'utiliser double
au lieu de float
. Cependant, même double
est soumis à des limitations similaires, mais avec une plus grande précision.
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!