Jak ustalić, czy liczba dziesiętna / podwójna jest liczbą całkowitą?

Jak sprawdzić, czy wartość dziesiętna czy podwójna jest liczbą całkowitą?

Na przykład:

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

lub

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

Powodem, dla którego chciałbym to wiedzieć, jest to, że mogę programowo określić, czy chcę wyprowadzić wartość za pomocą .ToString("N0")lub .ToString("N2"). Jeśli nie ma wartości dziesiętnej, nie chcę tego pokazywać.

W przypadku liczb zmiennoprzecinkowych n % 1 == 0 jest to zazwyczaj sposób sprawdzenia, czy coś znajduje się poza przecinkiem dziesiętnym.

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

Wynik:

False
True

Aktualizacja: Jak wspomniano poniżej @Adrian Lopez, porównanie z małą wartościąepsilonodrzuci błędne obliczenia obliczeń zmiennoprzecinkowych. Ponieważ pytanie dotyczydoublewartości, poniżej będzie bardziej zmiennoprzecinkowa odpowiedź na obliczenia :

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

Można to zrobić na wiele sposobów. Na przykład:

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

Możesz także użyć modulo.

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

Co powiesz na to?

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

Ten sam kod dla decimal .

Mark Byers miał rację: właściwie to może nie być to, czego naprawdę chcesz. Jeśli naprawdę zależy Ci na tym, czy liczba zaokrąglona do najbliższych dwóch miejsc po przecinku jest liczbą całkowitą , możesz to zrobić w zamian:

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

Chociaż proponowane rozwiązania wydają się sprawdzać w przypadku prostych przykładów, robienie tego ogólnie jest złym pomysłem. Liczba może nie być dokładnie liczbą całkowitą, ale podczas próby jej sformatowania jest wystarczająco blisko liczby całkowitej, którą otrzymujesz1.000000 . Może się to zdarzyć, jeśli wykonasz obliczenia, które teoretycznie powinny dać dokładnie 1, ale w praktyce daje liczbę bardzo zbliżoną, ale nie dokładnie taką samą, z powodu błędów zaokrąglania.

Zamiast tego sformatuj go najpierw, a jeśli ciąg zakończy się kropką, po której następuje zero, usuń je. Istnieje również kilka formatów, z których można automatycznie korzystać po końcowych zerach. To może być wystarczająco dobre dla twojego celu.

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

Wynik:

1
1.02

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

Problemo solvo.

Edycja: Pwned Mark Rushakoff.

Odpowiedź Marka Rushakoffa może być prostsza, ale poniższe również działają i mogą być bardziej wydajne, ponieważ nie istnieje niejawna operacja podziału:

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

i

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

Być może potrzebujesz jednego wyrażenia dla obu typów

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

Jeśli górna i dolna granica Int32spraw:

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;
}

Możesz użyć formatowania ciągu dla typu podwójnego. Oto przykład:

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"

Daj mi znać, jeśli to nie pomoże.

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

Napotkałem podobną sytuację, ale gdzie wartość jest łańcuchem. Użytkownik wpisuje wartość, która powinna być kwotą w dolarach, dlatego chcę sprawdzić, czy jest ona liczbowa i ma najwyżej dwa miejsca po przecinku.

Oto mój kod do zwrócenia true, jeśli ciąg „s” reprezentuje liczbę z co najwyżej dwoma miejscami dziesiętnymi, a false w przeciwnym razie. Pozwala to uniknąć problemów wynikających z niedokładności wartości zmiennoprzecinkowych.

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;
}

Omawiam to bardziej szczegółowo na stronie http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

Użycie int.TryParse przyniesie następujące wyniki:

        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();

Być może nie jest to najbardziej eleganckie rozwiązanie, ale działa, jeśli nie jesteś zbyt wybredny!

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

Możesz użyć metody „TryParse”.

int.TryParse()

To sprawdza, czy wartość można przekonwertować na wartość całkowitą liczby całkowitej. Wynik może następnie wskazywać flagę, której można użyć w innym miejscu w kodzie.

Spróbuj tego:

number == Convert.ToInt16(number);