Quelle est la meilleure façon de comparer Double et Int?

Question

Le code suivant dans C # ne fonctionne pas:

int iValue = 0;
double dValue = 0.0;

bool isEqual = iValue.Equals(dValue);

Alors, la question: quelle est la meilleure façon de comparer Double et Int?

Answer 1

Vous ne pouvez vraiment pas comparer les valeurs intégrales et à virgule flottante de manière naïve; en particulier, puisqu'il existe le classique point flottant défis de représentation . Ce que vous pouvez faire, c'est soustraire l'un de l'autre et voir si la différence entre eux est inférieure à une précision qui vous tient à coeur, comme ceci:

int iValue = 0;
double dValue = 0.0;

var diff = Math.Abs(dvalue - iValue);
if( diff < 0.0000001 ) // need some min threshold to compare floating points
   return true; // items equal

Vous devez vraiment définir vous-même ce que égalité signifie pour vous. Par exemple, vous pouvez souhaiter qu'une valeur en virgule flottante soit arrondie au nombre entier le plus proche, de sorte que 3.999999981 soit égal à "égal". 4. Vous pouvez également tronquer la valeur afin qu'elle soit effectivement 3. Tout dépend de ce que vous essayez d'atteindre.

MODIFIER: Notez que j'ai choisi 0.0000001 comme exemple de valeur de seuil ... vous devez décider vous-même quelle précision est suffisante pour la comparaison. Vous devez vous rendre compte que vous devez respecter les limites de représentation normales de double , ce qui, à mon avis, est défini comme Double.Epsilon .

Answer 2

C'est une très mauvaise idée de comparer des nombres entiers et des nombres à virgule flottante pour vérifier leur égalité dans toutes les langues. Cela fonctionne pour des cas très simples, mais une fois que vous avez fait des calculs, la probabilité que le programme fasse ce que vous voulez diminue considérablement.

Cela concerne la manière dont les nombres à virgule flottante sont stockés sur un système numérique binaire.

Si vous êtes vraiment sûr de vouloir l’utiliser, créez une classe pour créer votre propre nombre avec des fractions. utilisez un int pour maintenir le nombre entier et un autre pour maintenir la fraction.

Answer 3

Cela dépend vraiment de ce que vous considérez comme "égal". Si vous voulez que votre comparaison retourne vrai si et seulement si le double correspond avec précision à la valeur entière (c'est-à-dire sans composante décimale), vous devez convertir votre int en double pour effectuer la comparaison:

bool isEqual = (double)iValue == dValue;

Si quelque chose comme 1.1 serait considéré comme égal à 1, vous pouvez soit convertir le double en un entier (si vous voulez ignorer complètement le composant fractionnaire), soit arrondir le double si vous voulez que 1,9 soit égal à 2.

Answer 4

double val1 = 0;
double val2 = 0.0;
if((val1 - Double.Epsilon) < 0)
{
    // Put your code here
}

      OR

if((val2 - Double.Epsilon) < 0)
{
    // Put your code here
}

où Double.Epsilon est la valeur la plus basse possible pour Double.

Answer 5

De nos jours, à peu près le seul moment où l'on devrait comparer des valeurs de types double et soit entier ou long pour une égalité stricte, c'est quand, pour une raison quelconque, on est bloqué en train de stocker ou de transmettre des quantités intégrales sous forme de valeurs à virgule flottante, puis de les convertir ultérieurement. Dans la plupart des cas, une telle conversion peut être facilement réalisée en convertissant le type intégral en double , puis en comparant le résultat de cette conversion. Notez que la conversion de long en double peut être imprécise si le nombre est en dehors de la plage ± 2 ⁵² . Néanmoins, à l’époque précédant la mise à disposition de long 64 bits, double était un type de stockage pratique pour les quantités entières trop grandes pour un int <32 bits. / code> mais suffisamment petit pour être traité par double .

Notez que la conversion d'un long en double , puis la comparaison produisent un "égal". résultat si la valeur nominale du double ne correspond pas précisément à la valeur long , mais représente le double le plus proche possible de cette valeur. Ce comportement a du sens si l’on reconnaît que les types à virgule flottante ne représentent pas réellement une seule valeur précise, mais plutôt une plage de valeurs.