Est-il sûr de vérifier les valeurs à virgule flottante pour l'égalité à 0?

Je sais que vous ne pouvez pas compter sur l'égalité entre les valeurs de type double ou décimal normalement, mais je me demande si 0 est un cas particulier.

Bien que je puisse comprendre les imprécisions entre 0,0000000000000001 et 0,0000000000000002, 0 lui-même semble assez difficile à gâcher car ce n'est rien. Si vous n'êtes imprécis sur rien, ce n'est plus rien.

Mais je ne connais pas grand-chose à ce sujet donc ce n'est pas à moi de le dire.

double x = 0.0;
return (x == 0.0) ? true : false;

Cela reviendra-t-il toujours vrai?

Il est prudent de s'attendre à ce que la comparaison retourne truesi et seulement si la variable double a une valeur de exactement 0.0(ce qui dans votre extrait de code d'origine est, bien sûr, le cas). Ceci est cohérent avec la sémantique de l' ==opérateur. a == bsignifie " aest égal à b".

Il n'est pas sûr (car ce n'est pas correct ) de s'attendre à ce que le résultat d'un calcul soit nul en arithmétique double (ou plus généralement en virgule flottante) chaque fois que le résultat du même calcul en mathématiques pures est nul. En effet, lorsque les calculs entrent dans le sol, une erreur de précision en virgule flottante apparaît - un concept qui n'existe pas dans l'arithmétique des nombres réels en mathématiques.

Si vous avez besoin de faire beaucoup de comparaisons "d'égalité", il peut être judicieux d'écrire une petite fonction d'aide ou une méthode d'extension dans .NET 3.5 pour comparer:

public static bool AlmostEquals(this double double1, double double2, double precision)
{
    return (Math.Abs(double1 - double2) <= precision);
}

Cela pourrait être utilisé de la manière suivante:

double d1 = 10.0 * .1;
bool equals = d1.AlmostEquals(0.0, 0.0000001);

Pour votre échantillon simple, ce test est correct. Mais qu'en est-il de ceci:

bool b = ( 10.0 * .1 - 1.0 == 0.0 );

N'oubliez pas que .1 est une décimale répétitive en binaire et ne peut pas être représenté exactement. Ensuite, comparez cela à ce code:

double d1 = 10.0 * .1; // make sure the compiler hasn't optimized the .1 issue away
bool b = ( d1 - 1.0 == 0.0 );

Je vous laisse faire un test pour voir les résultats réels: vous aurez plus de chances de vous en souvenir de cette façon.

À partir de l'entrée MSDN pour Double.Equals :

Précision dans les comparaisons

La méthode Equals doit être utilisée avec prudence, car deux valeurs apparemment équivalentes peuvent être inégales en raison de la précision différente des deux valeurs. L'exemple suivant indique que la valeur Double .3333 et le Double renvoyé en divisant 1 par 3 sont inégaux.

...

Plutôt que de comparer pour l'égalité, une technique recommandée consiste à définir une marge de différence acceptable entre deux valeurs (comme 0,01% de l'une des valeurs). Si la valeur absolue de la différence entre les deux valeurs est inférieure ou égale à cette marge, la différence est probablement due à des différences de précision et, par conséquent, les valeurs sont susceptibles d'être égales. L'exemple suivant utilise cette technique pour comparer 0,33333 et 1/3, les deux valeurs Double que l'exemple de code précédent a trouvé inégales.

Voir également Double.Epsilon .

Le problème vient lorsque vous comparez différents types d'implémentation de valeur en virgule flottante, par exemple en comparant float avec double. Mais avec le même type, cela ne devrait pas être un problème.

float f = 0.1F;
bool b1 = (f == 0.1); //returns false
bool b2 = (f == 0.1F); //returns true

Le problème est que le programmeur oublie parfois que le cast de type implicite (double en float) se produit pour la comparaison et cela entraîne un bogue.

Si le nombre a été directement attribué au flottant ou au double, il est alors sûr de tester par rapport à zéro ou à tout nombre entier pouvant être représenté en 53 bits pour un double ou 24 bits pour un flottant.

Ou pour le dire autrement, vous pouvez toujours attribuer une valeur entière à un double, puis comparer le double au même entier et être assuré qu'il sera égal.

Vous pouvez également commencer par attribuer un nombre entier et faire en sorte que les comparaisons simples continuent de fonctionner en vous contentant d'ajouter, de soustraire ou de multiplier par des nombres entiers (en supposant que le résultat est inférieur à 24 bits pour un flottant et 53 bits pour un double). Ainsi, vous pouvez traiter les flottants et les doubles comme des entiers dans certaines conditions contrôlées.

Non, ce n'est pas OK. Les valeurs dites dénormalisées (sous-normales), lorsqu'elles sont comparées à 0,0, seraient comparées comme fausses (non nulles), mais lorsqu'elles sont utilisées dans une équation, elles seraient normalisées (devenant 0,0). Ainsi, l'utiliser comme mécanisme pour éviter une division par zéro n'est pas sûr. Au lieu de cela, ajoutez 1.0 et comparez à 1.0. Cela garantira que toutes les sous-normales sont traitées comme nulles.

Essayez ceci, et vous constaterez que == n'est pas fiable pour double / float.
double d = 0.1 + 0.2; bool b = d == 0.3;

Voici la réponse de Quora.

En fait, je pense qu'il est préférable d'utiliser les codes suivants pour comparer une valeur double à 0,0:

double x = 0.0;
return (Math.Abs(x) < double.Epsilon) ? true : false;

Idem pour le flotteur:

float x = 0.0f;
return (Math.Abs(x) < float.Epsilon) ? true : false;