Comment déterminer si une décimale / double est un entier?

Comment savoir si une valeur décimale ou double est un entier?

Par exemple:

decimal d = 5.0; // Would be true
decimal f = 5.5; // Would be false

ou

double d = 5.0; // Would be true
double f = 5.5; // Would be false

La raison pour laquelle j'aimerais le savoir est que je puisse déterminer par programme si je veux sortir la valeur à l'aide de .ToString("N0")ou .ToString("N2"). S'il n'y a pas de valeur décimale, je ne veux pas le montrer.

Pour les nombres à virgule flottante, n % 1 == 0c'est généralement le moyen de vérifier s'il y a quelque chose après le point décimal.

public static void Main (string[] args)
{
    decimal d = 3.1M;
    Console.WriteLine((d % 1) == 0);
    d = 3.0M;
    Console.WriteLine((d % 1) == 0);
}

Production:

False
True

Mise à jour: Comme @Adrian Lopez l'a mentionné ci-dessous, la comparaison avec une petite valeurepsilonéliminera les erreurs de calcul en virgule flottante. Étant donné que la question concerne lesdoublevaleurs, voici uneréponse à l' épreuve des calculs en virgule flottante :

Math.Abs(d % 1) <= (Double.Epsilon * 100)

Il existe plusieurs façons de procéder. Par exemple:

double d = 5.0;
bool isInt = d == (int)d;

Vous pouvez également utiliser modulo.

double d = 5.0;
bool isInt = d % 1 == 0;

Que dis-tu de ça?

public static bool IsInteger(double number) {
    return number == Math.Truncate(number);
}

Même code pour decimal.

Mark Byers a fait un bon argument, en fait: ce n'est peut-être pas ce que vous voulez vraiment . Si vous vous souciez vraiment de savoir si un nombre arrondi aux deux décimales les plus proches est un entier , vous pouvez le faire à la place:

public static bool IsNearlyInteger(double number) {
    return Math.Round(number, 2) == Math.Round(number);
}

Alors que les solutions proposées semblent fonctionner pour des exemples simples, faire cela en général est une mauvaise idée. Un nombre peut ne pas être exactement un entier, mais lorsque vous essayez de le formater, il est suffisamment proche d'un entier que vous obtenez 1.000000. Cela peut se produire si vous effectuez un calcul qui, en théorie, devrait donner exactement 1, mais en pratique, donne un nombre très proche mais pas exactement égal à un en raison d'erreurs d'arrondi.

Au lieu de cela, formatez-le d'abord et si votre chaîne se termine par un point suivi de zéros, puis supprimez-les. Il existe également certains formats que vous pouvez utiliser pour supprimer automatiquement les zéros de fin. Cela pourrait être suffisant pour votre objectif.

double d = 1.0002;
Console.WriteLine(d.ToString("0.##"));
d = 1.02;
Console.WriteLine(d.ToString("0.##"));

Production:

1
1.02

bool IsInteger(double num) {
    if (ceil(num) == num && floor(num) == num)
        return true;
    else
        return false;
}

Problemo solvo.

Edit: Pwned par Mark Rushakoff.

La réponse de Mark Rushakoff peut être plus simple, mais les éléments suivants fonctionnent également et peuvent être plus efficaces car il n'y a pas d'opération de division implicite:

     bool isInteger = (double)((int)f) == f ;

et

     bool isInteger = (decimal)((int)d) == d ;

Si vous voulez une seule expression pour les deux types, peut-être

     bool isInteger = (double)((int)val) == (double)val ;

Si limite supérieure et inférieure des Int32matières:

public bool IsInt32(double value)
{
    return  value >= int.MinValue && value <= int.MaxValue && value == (int)value;
}

static bool IsWholeNumber(double x) 
{
    return Math.Abs(x % 1) < double.Epsilon;
}

Vous pouvez utiliser la mise en forme de chaîne pour le type double. Voici un exemple:

double val = 58.6547;
String.Format("{0:0.##}", val);      
//Output: "58.65"

double val = 58.6;
String.Format("{0:0.##}", val);      
//Output: "58.6"

double val = 58.0;
String.Format("{0:0.##}", val);      
//Output: "58"

Faites-moi savoir si cela n'aide pas.

    public static bool isInteger(decimal n)
    {
        return n - (Int64)n == 0;
    }

J'ai fait face à une situation similaire, mais où la valeur est une chaîne. L'utilisateur saisit une valeur qui est censée être un montant en dollars, je veux donc valider qu'il est numérique et comporte au plus deux décimales.

Voici mon code pour retourner vrai si la chaîne "s" représente un numérique avec au plus deux décimales et faux sinon. Il évite tout problème qui résulterait de l'imprécision des valeurs à virgule flottante.

try
{
    // must be numeric value
    double d = double.Parse(s);
    // max of two decimal places
    if (s.IndexOf(".") >= 0)
    {
        if (s.Length > s.IndexOf(".") + 3)
            return false;
    }
    return true;
catch
{
    return false;
}

J'en discute plus en détail sur http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

L'utilisation de int.TryParse donnera ces résultats:

        var shouldBeInt = 3;

        var shouldntBeInt = 3.1415;

        var iDontWantThisToBeInt = 3.000f;

        Console.WriteLine(int.TryParse(shouldBeInt.ToString(), out int parser)); // true

        Console.WriteLine(int.TryParse(shouldntBeInt.ToString(), out parser)); // false

        Console.WriteLine(int.TryParse(iDontWantThisToBeInt.ToString(), out parser)); // true, even if I don't want this to be int

        Console.WriteLine(int.TryParse("3.1415", out  parser)); // false

        Console.WriteLine(int.TryParse("3.0000", out parser)); // false

        Console.WriteLine(int.TryParse("3", out parser)); // true

        Console.ReadKey();

Ce n'est peut-être pas la solution la plus élégante mais ça marche si vous n'êtes pas trop pointilleux!

bool IsInteger(double num) {
    return !num.ToString("0.################").Contains(".");
}

Vous pouvez utiliser la méthode «TryParse».

int.TryParse()

Cela vérifie si la valeur peut être convertie en une valeur entière entière. Le résultat peut alors indiquer un indicateur qui peut être utilisé ailleurs dans votre code.

Essaye ça:

number == Convert.ToInt16(number);