Comment bien comparer les valeurs après la virgule en C#?

Je viens d'un milieu en C++, et je sais que vous ne pouvez pas comparer avec précision les flotteurs pour l'égalité. Pour le C#, j'ai simplement supposé la même politique s'applique à des valeurs décimales, ou toute valeur à virgule flottante en général.

En gros, j'ai deux valeurs décimales et si elles ne sont PAS égaux les uns aux autres, j'ai besoin d'effectuer une action. par exemple:

decimal value1, value2;
//Assume value1 and value2 are set somewhere to valid values.
if( value1 != value2 )
{
    //Do something
}

Si cela ne fonctionne pas comme prévu, je suis prêt à accepter une solution qui répond à une comparaison d'égalité avec une marge d'erreur, dire comme .00001 ou quelque chose comme ça. Quelle serait la solution recommandée pour ce problème?

  • Ce n'est pas exactement la même comme il se rapporte à double plutôt que de virgule mais jetez un oeil à stackoverflow.com/questions/485175/...
  • Bon point. Retirée.
  • Votre posté code est la bonne façon de comparer deux décimales. Si vous voulez comparer deux décimales avec une marge d'erreur, vous ne if (Math.Abs(value2 - value1) < 0.00001) { ... }.
  • Quand vous dites "décimal", tu parles de le decimal type utile pour les financiers et des calculs monétaires ou êtes-vous à l'aide de "virgule" comme un terme générique pour une variété de virgule flottante de formats, y compris double, float, et decimal (en lien ci-dessus)?
  • Je tiens à préciser que mon utilisation de la "virgule" dans mon post original. En gros, je fais référence à ce type réel 'virgule' (le mot clé). Je ne comprends pas vraiment ce que les données sous-jacentes ressemble pour types décimaux, j'ai simplement supposé qu'ils étaient des valeurs à virgule flottante, où pour les fractions de types qu'ils ne sont jamais exactement les mêmes (comme avec les chars & double en C++).
InformationsquelleAutor void.pointer | 2011-05-09
  1. 28

    Votre code fonctionne comme prévu. C# decimals sont optimisés pour être très précis à la représentation en base 10 des nombres, donc si c'est ce que vous êtes en comparant (argent, ...), tout devrait bien se passer.

    Voici un très explication claire quant à la précision des décimales par Jon Skeet:

    Différence entre décimal, float et double dans .NET?

    • Toutes les réponses fournies sont helplful. Je suis marquage ce un comme de ma réponse, surtout parce que j'ai réalisé que je n'arrivais pas à bien comprendre ce qu'est un décimal a été en C#. Les décimales ne semblent pas être les flotteurs car je pensais qu'ils étaient. Aussi le lien vers l'article expliquant les différences est très très utile pour moi.
    • les décimales sont des flotteurs dans le sens que la position de la virgule décimale "flotte autour de". Les décimales ne sont pas de "point fixe" des nombres, où il y a, disons, 15 places avant la virgule et 10 après. La différence entre la virgule et le double est un décimal est un nombre de la forme m x 10^e, et un double est un nombre de la forme m x 2^e.
    • Juste vu que 0.0000 != 0.0 renvoie la valeur true. Cependant !(0.000).Equals(0.0) renvoie la valeur false.
    InformationsquelleAutor fretje
  2. 5

    Que j'enquêtais sur quelque chose de similaire, mais avec une précision au lieu d'une marge d'erreur et a fini par écrire quelques extensions pour le Flotteur. Cela peut facilement être adapté pour tout type de bien. J'ai une série compliquée de comparaisons et de ce fait, il est agréable et lisible.

    ///<summary>
///A set of extensions to allow the convenient comparison of float values based on a given precision.
///</summary>
public static class FloatingPointExtensions
{
///<summary>
///Determines if the float value is less than or equal to the float parameter according to the defined precision.
///</summary>
///<param name="float1">The float1.</param>
///<param name="float2">The float2.</param>
///<param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
///<returns></returns>
public static bool LessThan(this float float1, float float2, int precision)
{
return (System.Math.Round(float1 - float2, precision) < 0);
}
///<summary>
///Determines if the float value is less than or equal to the float parameter according to the defined precision.
///</summary>
///<param name="float1">The float1.</param>
///<param name="float2">The float2.</param>
///<param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
///<returns></returns>
public static bool LessThanOrEqualTo(this float float1, float float2, int precision)
{
return (System.Math.Round(float1 - float2, precision) <= 0);
}
///<summary>
///Determines if the float value is greater than (>) the float parameter according to the defined precision.
///</summary>
///<param name="float1">The float1.</param>
///<param name="float2">The float2.</param>
///<param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
///<returns></returns>
public static bool GreaterThan(this float float1, float float2, int precision)
{
return (System.Math.Round(float1 - float2, precision) > 0);
}
///<summary>
///Determines if the float value is greater than or equal to (>=) the float parameter according to the defined precision.
///</summary>
///<param name="float1">The float1.</param>
///<param name="float2">The float2.</param>
///<param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
///<returns></returns>
public static bool GreaterThanOrEqualTo(this float float1, float float2, int precision)
{
return (System.Math.Round(float1 - float2, precision) >= 0);
}
///<summary>
///Determines if the float value is equal to (==) the float parameter according to the defined precision.
///</summary>
///<param name="float1">The float1.</param>
///<param name="float2">The float2.</param>
///<param name="precision">The precision.  The number of digits after the decimal that will be considered when comparing.</param>
///<returns></returns>
public static bool AlmostEquals(this float float1, float float2, int precision)
{
return (System.Math.Round(float1 - float2, precision) == 0);
} 
}
    InformationsquelleAutor Kim
  3. 4

    Je suis d'accord avec les autres réponses, mais je rencontre un problème où l'on "authentique" côté serveur décimal obtient en comparaison avec celle provenant du JSON/navigateur (et doit avoir été un flotteur à un certain point).

    J'ai fini avec ce code de arrondir à 2 chiffres après le point décimal, qui a été assez précis dans mon cas:

    if (Decimal.Round(serverTotalPrice, 2) != Decimal.Round(request.TotalPrice, 2)) {
throw new ArgumentException("The submitted Total Price is not valid");
}
    • à l'aide de ronde pour une telle tâche peut provoquer des problèmes, parce que 1.116 sera arrondi à 1,12 et 1.113 sera arrondi à 1,11, donc ils seraient pas égaux selon votre code, où il semble que vous voulez qu'ils considèrent l'égalité.
    • vrai, j'ai pensé à moi-même, mais dans mon cas, la virgule flottante version en js est basé sur le fixe, la valeur décimale à côté serveur .net, et donc de mon côté serveur 1.12 serait en js, soit quelque chose comme 1.11999999 ou 1.12000001 qui fonctionne toujours OK pour moi.
    InformationsquelleAutor Ekus
  4. 2

    Je pense que cette permettra de résoudre votre problème.

    Fondamentalement, il ya un nombre décimal.la méthode de comparaison.

    EDIT: C'est peut-être la meilleure méthode:

    Décimal.Est égal à

    EDIT2: Si vous pouvez comparer directement comme suggéré ci-dessus, qui pourraient être plus efficaces. Je vais laisser cela comme il peut être d'intérêt.

    • Je pense que c'est vraiment plus pour le tri...
    • Vous avez peut-être droit. Il y a une virgule.est égal à là. Je n'ai pas l'habitude que je me souviens, mais il semble être approprié. Si quelqu'un sait différemment, je serais curieux aussi.
    • Cela a le même problème que x == y, où x est une variable point genre. (Le fait que les décimales ont une précision fixe est seulement un peu pertinents, comme c'est le calcul qui est là, c'est problématique.)
    InformationsquelleAutor nycdan