Ondalık / çiftin bir tam sayı olup olmadığı nasıl belirlenir?

Ondalık veya çift değerin bir tam sayı olup olmadığını nasıl anlarım?

Örneğin:

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

veya

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

Bunu bilmek istememin nedeni, .ToString("N0")veya değerini kullanarak çıktı almak isteyip istemediğimi programsal olarak belirleyebilmemdir .ToString("N2"). Ondalık nokta değeri yoksa, bunu göstermek istemiyorum.

Kayan nokta sayıları için, n % 1 == 0genellikle ondalık noktadan sonra bir şey olup olmadığını kontrol etmenin bir yoludur.

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

Çıktı:

False
True

Güncelleme: @Adrian Lopez'in de belirttiği gibi, küçük bir değerle karşılaştırmaepsilonkayan nokta hesaplama yanlış hesaplamalarınısilecektir. Sorudoubledeğerlerile ilgili olduğundan, aşağıda daha kayan nokta hesaplama kanıtı yanıtı olacaktır:

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

Bunu yapmanın birçok yolu vardır. Örneğin:

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

Ayrıca modulo da kullanabilirsiniz.

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

Buna ne dersin?

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

İçin aynı kod decimal.

Mark Byers aslında iyi bir noktaya değindi: bu gerçekten istediğiniz şey olmayabilir . Ne olursa gerçekten umurumda olan bir sayı bir tamsayı en yakın iki ondalık basamağa yuvarlanır olsun , bunun yerine bunu:

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

Önerilen çözümler basit örnekler için işe yarıyor gibi görünse de, bunu genel olarak yapmak kötü bir fikirdir. Bir sayı tam olarak bir tamsayı olmayabilir, ancak biçimlendirmeye çalıştığınızda aldığınız bir tamsayıya yeterince yakındır 1.000000. Teoride tam olarak 1 vermesi gereken bir hesaplama yaparsanız, ancak pratikte yuvarlama hataları nedeniyle bire çok yakın ancak tam olarak eşit olmayan bir sayı verirse bu olabilir.

Bunun yerine, önce biçimlendirin ve dizeniz sıfırlar ve ardından sıfırlar ile bitiyorsa, bunları şeritleyin. Ayrıca, şerit sondaki sıfırları otomatik olarak kullanabileceğiniz bazı biçimler de vardır. Bu, amacınız için yeterince iyi olabilir.

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

Çıktı:

1
1.02

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

Problem çözücü.

Düzenleme: Mark Rushakoff tarafından tasarlandı.

Mark Rushakoff'un cevabı daha basit olabilir, ancak aşağıdakiler de işe yarar ve örtülü bölünme işlemi olmadığından daha verimli olabilir:

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

ve

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

Her iki tür için de tek bir ifade istiyorsanız, belki

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

Üst ve alt sınır Int32önemlidir:

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

Çift tip için Dize biçimlendirmesini kullanabilirsiniz. İşte bir örnek:

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"

Bu işe yaramıyorsa bana bildirin.

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

Benzer bir durumla karşı karşıya kaldım, ancak değer bir dize. Kullanıcı bir dolar tutarı olması gereken bir değer yazıyor, bu yüzden sayısal ve en fazla iki ondalık basamak olduğunu doğrulamak istiyorum.

"S" dizesi en fazla iki ondalık basamağa sahip bir sayıyı temsil ediyorsa true döndürmek için kodum, aksi takdirde false olur. Kayan nokta değerlerinin belirsizliğinden kaynaklanan herhangi bir sorunu önler.

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

Bunu daha ayrıntılı olarak http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html adresinde tartışacağım .

İnt.TryParse kullanıldığında şu sonuçlar elde edilir:

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

Belki de en zarif çözüm değil ama çok seçici değilseniz işe yarıyor!

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

'TryParse' yöntemini kullanabilirsiniz.

int.TryParse()

Bu, değerin bir tam sayı tam sayı değerine dönüştürülüp dönüştürülemeyeceğini kontrol eder. Sonuç, kodunuzun başka bir yerinde kullanılabilecek bir bayrağı gösterebilir.

Bunu dene:

number == Convert.ToInt16(number);