La bonne façon de comparer un Système.Double à '0' (un nombre, int?)

Désolé, ce peut être une simple question stupide, mais j'ai besoin de savoir pour être sûr.

J'ai cette if expression,

void Foo()
{
    System.Double something = GetSomething();
    if (something == 0) //Comparison of floating point numbers with equality 
                     //operator. Possible loss of precision while rounding value
        {}
}

Est que l'expression d'égal à égal avec

void Foo()
{
    System.Double something = GetSomething();
    if (something < 1)
        {}
}

? Parce que je pourrait avoir un problème, entrer dans le if avec, par exemple, une valeur de 0,9.

  • // Comparison of floating point numbers with equality // operator. Avez-vous vraiment besoin de préciser que? 🙂
  • Diable pas. Il y a un enfer de beaucoup de valeurs entre 0 et 1. Pourquoi ne pas simplement de le tester et de voir par vous-même?
  • Je viens d'écrire la même chose que Resharper fait, pour montrer d'où mon accent est mis.
  • Aussi, il y a beaucoup de nombres qui sont à moins de 0.
  • double possible de Comparer les valeurs double en C#
InformationsquelleAutor radbyx | 2011-07-06
  1. 103

    Bien, comment avez-vous besoin de la valeur à 0? Si vous passez par un grand nombre d'opérations en virgule flottante, qui dans "précision infinie" pourrait aboutir à 0, vous pourriez vous retrouver avec un résultat "très proche" de 0.

    Généralement dans cette situation, vous voulez fournir une sorte de epsilon, et vérifier que le résultat est juste à l'intérieur de cette epsilon:

    if (Math.Abs(something) < 0.001)

    L'epsilon vous devez utiliser est spécifique à l'application, ça dépend de ce que vous faites.

    Bien sûr, si le résultat doit être exactement zéro, alors qu'un simple contrôle d'égalité est très bien.

    • En fait, j'en ai besoin pour être exactement zéro, comment pourrait-il regarder? J'ai regardé pour le Double.Zéro, mais je sais la chance. Il y a une constante à droite? Btw, merci, j'ai l'epsilon partie maintenant 🙂
    • Utilisez simplement == 0. Vous avez un littéral c'est assez constante 🙂
    InformationsquelleAutor Jon Skeet
  2. 32

    Si something a été affecté par le résultat d'une opération autre qu' something = 0 alors il vaut mieux utiliser:

    if(Math.Abs(something) < Double.Epsilon)
{
//do something
}

    Modifier: Ce code n'est pas correct. Epsilon est le plus petit nombre, mais pas tout à fait nulle. Lorsque vous souhaitez comparer un nombre à un autre nombre, vous avez besoin de penser à ce qu'est la tolérance acceptable. Disons que rien au-delà de .00001 vous ne se soucient pas. C'est le nombre que vous souhaitez utiliser. La valeur dépend du domaine. Cependant, c'est surtout certainement jamais en Double.Epsilon.

    • Cela ne résout pas le problème d'arrondi, par exemple Math.Abs(0.1f - 0.1d) < double.Epsilon est false
    • Double.Epsilon est trop petit pour une telle comparaison. Double.Epsilon est le plus petit nombre positif que le double peut représenter.
    • Cela n'a aucun sens parce que c'est quasiment la même qu'en le comparant à 0. -1
    • L'objectif est de comparer l'encontre du concept de 0 sans avec == . Au moins il fait sens mathématique. Je suis en supposant que vous avez un double à la main et que vous voulez comparer à la notion de zéro, sans ==. Si votre double est différente de 0d pour une raison quelconque, y compris l'arrondissement, le test de remplissage de retour faux. Cette comparaison semble valable pour n'importe quel double et renvoie true si seulement cette double est plus petit que le plus petit nombre qui peut être représenté, ce qui me semble une bonne définition pour tester le concept de 0, non?
    • Rien ne peut être inférieure au Double.Epsilon cette expression est toujours faux.
    • vous avez tort: double d = Math.Sqrt(10100)*2; double a = Math.Sqrt(40400); if(Math.Abs(a - d) < double.Epsilon) { Console.WriteLine("true"); }
    • Les mathématiques.Abs(quelque chose) < Double.Epsilon est évaluée à true lorsque quelque chose est exactement zéro, auquel cas quelque chose == 0 serait également vrai, alors pourquoi ne pas l'utiliser?
    • "Parce que Epsilon définit l'expression minimale d'une valeur positive dont l'aire de répartition est proche de zéro, la marge de différence entre les deux valeurs doivent être supérieures à Epsilon. Généralement, il est plusieurs fois supérieure à Epsilon. Pour cette raison, nous vous recommandons de ne pas utiliser Epsilon lors de la comparaison des valeurs Doubles pour l'égalité." msdn.microsoft.com/en-us/library/ya2zha7s.aspx
    • Vous ne devez jamais utiliser des Doubles.Epsilon pour une double comparaison. stackoverflow.com/questions/2411392/...

    InformationsquelleAutor sonatique
  3. 23

    Votre something est un double, et vous avez correctement identifié que dans la ligne

    if (something == 0)

    nous avons un double sur le côté gauche (lhs) et un int sur la droite (rhs).

    Mais il semble maintenant que vous pensez que la gauche sera converti en int, puis le == signe de comparer deux nombres entiers. C'est pas ce qui se passe. La conversion de double à int est explicite et ne peut pas arriver "automatiquement".

    Plutôt l'inverse qui se produit. Le membre de droite est converti à double, puis le == signe devient un test d'égalité entre deux doubles. Cette conversion est implicite (automatique).

    Il est considéré comme le meilleur (par certains) pour écrire

    if (something == 0.0)

    ou

    if (something == 0d)

    car il est alors immédiat que vous comparez les deux doubles. Cependant, c'est juste une question de style et de lisibilité car le compilateur va faire la même chose en tout cas.

    Il est également pertinent, dans certains cas, de mettre en place une "tolérance" à la manière de Jon Skeet réponse, mais que la tolérance serait une double trop. Il pourrait bien sûr être 1.0 si vous le souhaitez, mais il n'a pas à être [le moins strictement positif] entier.

    InformationsquelleAutor Jeppe Stig Nielsen
  4. 15

    Si vous voulez simplement supprimer l'avertissement, faites ceci:

    if (something.Equals(0.0))

    Bien sûr, ce n'est qu'une solution valable si vous savez que la dérive n'est pas un sujet de préoccupation. Je le fais souvent pour vérifier si je suis sur le point de diviser par zéro.

    InformationsquelleAutor Russell Phillips
  5. 5

    Je ne pense que c'est égal, honnêtement. Considérer ses propres exemple: quelque chose = 0,9, ou 0.0004.
    Dans le premier cas, il sera FAUX, dans le second cas, il sera VRAI. Traitant de ce types j'ai l'habitude de définir, pour moi, de précision, de pourcentage et de les comparer à l'intérieur de cette précision.
    Dépend de vos besoins.
    quelque chose comme...

    if(((int)(something*100)) == 0) {


//do something
}

    Espère que cette aide.

    • quelque chose doit être exactement égale à zéro.
    • si vous avez de la chance mec, dans ce cas 🙂
    InformationsquelleAutor Tigran
  6. 3

    Voici l'exemple de la présentation du problème (en LinQPad - si vous n'avez pas, il suffit d'utiliser Console.Writeline au lieu de Dump méthode):

    void Main()
{
    double x = 0.000001 / 0.1;
    double y = 0.001 * 0.01; 

    double res = (x-y);
    res.Dump();
    (res == 0).Dump();
}

    À la fois x et y sont théoriquement identique et égale à: 0.00001 mais en raison du manque de "précision infinie" ces valeurs sont légèrement différentes. Malheureusement un peu assez de retour false si l'on compare à 0 dans la manière habituelle.

    InformationsquelleAutor Michał Mądrzyk