Làm thế nào để xác định nếu một số thập phân / gấp đôi là một số nguyên?

Làm thế nào để tôi biết nếu một giá trị thập phân hoặc gấp đôi là một số nguyên?

Ví dụ:

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

hoặc là

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

Lý do tôi muốn biết điều này là để tôi có thể xác định theo chương trình nếu tôi muốn xuất giá trị bằng cách sử dụng .ToString("N0")hoặc .ToString("N2"). Nếu không có giá trị dấu thập phân, thì tôi không muốn hiển thị điều đó.

Đối với số dấu phẩy động, n % 1 == 0thường là cách để kiểm tra xem có bất kỳ thứ gì vượt quá dấu thập phân không.

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

Đầu ra:

False
True

Cập nhật: Như @Adrian Lopez đã đề cập dưới đây, so sánh với một giá trị nhỏepsilonsẽ loại bỏ các phép tính sai tính toán dấu phẩy động. Vì câu hỏi là vềdoublecác giá trị, bên dưới sẽ làcâu trả lời bằng chứng tính toán dấu phẩy động hơn:

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

Có bất kỳ số cách để làm điều này. Ví dụ:

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

Bạn cũng có thể sử dụng modulo.

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

Còn cái này thì sao?

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

Cùng mã cho decimal.

Mark Byers đã đưa ra một quan điểm tốt, thực sự: đây có thể không phải là điều bạn thực sự muốn. Nếu điều bạn thực sự quan tâm là liệu một số được làm tròn đến hai chữ số thập phân gần nhất có phải là số nguyên hay không , bạn có thể thực hiện việc này thay thế:

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

Trong khi các giải pháp được đề xuất dường như hoạt động cho các ví dụ đơn giản, thì việc làm này nói chung là một ý tưởng tồi. Một số có thể không chính xác là một số nguyên nhưng khi bạn cố gắng định dạng nó, nó đủ gần với một số nguyên mà bạn nhận được 1.000000. Điều này có thể xảy ra nếu bạn thực hiện một phép tính mà trên lý thuyết sẽ đưa ra chính xác 1, nhưng trong thực tế, đưa ra một con số rất gần nhưng không chính xác bằng một do sai số làm tròn.

Thay vào đó, định dạng nó trước và nếu chuỗi của bạn kết thúc trong một khoảng thời gian theo sau là số không thì hãy loại bỏ chúng. Ngoài ra còn có một số định dạng mà bạn có thể sử dụng các số 0 ở đó. Điều này có thể đủ tốt cho mục đích của bạn.

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

Đầu ra:

1
1.02

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

Vấn đề solvo.

Chỉnh sửa: Được viết bởi Mark Rushakoff.

Câu trả lời của Mark Rushakoff có thể đơn giản hơn, nhưng những điều sau đây cũng hoạt động và có thể hiệu quả hơn vì không có hoạt động phân chia ngầm định:

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

và

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

Nếu bạn muốn một biểu thức cho cả hai loại, có lẽ

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

Nếu giới hạn trên và dưới của Int32vấn đề:

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

Bạn có thể sử dụng định dạng chuỗi cho loại kép. Đây là một ví dụ:

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"

Hãy cho tôi biết nếu điều này không giúp đỡ.

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

Tôi đã phải đối mặt với một tình huống tương tự, nhưng trong đó giá trị là một chuỗi. Người dùng nhập vào một giá trị được coi là số tiền, vì vậy tôi muốn xác thực rằng đó là số và có nhiều nhất là hai chữ số thập phân.

Đây là mã của tôi để trả về true nếu chuỗi "s" đại diện cho một số có nhiều nhất hai chữ số thập phân và ngược lại là sai. Nó tránh mọi vấn đề có thể xảy ra do sự thiếu chính xác của các giá trị dấu phẩy động.

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

Tôi thảo luận chi tiết hơn tại http://progblog10.blogspot.com/2011/04/determining-whether-numeric-value-has.html .

Sử dụng int.TryPude sẽ mang lại những kết quả sau:

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

Có lẽ không phải là giải pháp thanh lịch nhất nhưng nó hoạt động nếu bạn không quá cầu kỳ!

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

Bạn có thể sử dụng phương pháp 'TryPude'.

int.TryParse()

Điều này kiểm tra xem giá trị có thể được chuyển đổi thành giá trị số nguyên không. Kết quả sau đó có thể chỉ ra một cờ có thể được sử dụng ở nơi khác trong mã của bạn.

Thử cái này:

number == Convert.ToInt16(number);