Проверить, является ли число с плавающей запятой целым числом

d == Math.Floor(d)

делает то же самое другими словами.

NB: Надеюсь, вы знаете, что нужно быть очень осторожным, делая такие вещи; float/double очень легко накапливают незначительные ошибки, из-за которых точные сравнения (такие как это) терпят неудачу без очевидной причины.

Это сработает, я думаю:

if (d % 1 == 0) {
  //...
}

Если ваш двойной результат другого вычисления, вы, вероятно, хотите что-то вроде:

d == Math.Floor(d + 0.00001);

Таким образом, если была небольшая ошибка округления, она все равно будет совпадать.

Я не могу ответить на часть вопроса, относящуюся к С#, но я должен указать, что вы, вероятно, упускаете из виду общую проблему с числами с плавающей запятой.

Как правило, целочисленность плохо определена для чисел с плавающей запятой. По той же причине, по которой равенство плохо определено для поплавков. Вычисления с плавающей запятой обычно включают как ошибки округления, так и ошибки представления.

Например, 1.1 + 0.6 != 1.7.

Да, именно так работают числа с плавающей запятой.

Вот, 1.1 + 0.6 - 1.7 == 2.2204460492503131e-16.

Строго говоря, самое близкое к сравнению на равенство, которое вы можете сделать с числами с плавающей запятой, — это сравнить их с точностью до выбранной точности.

Если этого недостаточно, вы должны работать с представлением десятичных чисел, с представлением чисел с плавающей запятой со встроенным диапазоном ошибок или с символьными вычислениями.

Простая проверка, такая как «x == floor(x)», математически гарантирует правильную работу для любого числа FP с фиксированной точностью.

Все допустимые кодировки FP с фиксированной точностью представляют разные действительные числа, поэтому для каждого целого числа x существует не более одного кодирования FP с фиксированной точностью, которое точно ему соответствует.

Следовательно, для каждого целого числа x, которое МОЖЕТ быть представлено таким образом, мы обязательно имеем x == floor(x), поскольку floor(x) по определению возвращает наибольшее число FP y, такое что y ‹= x и y представляет целое число; поэтому floor(x) должен возвращать x.

Если вы просто собираетесь преобразовать его, ответ Майка Ф / Хота хорош, но не совсем отвечает на ваш вопрос. Если вы собираетесь тестировать, и это действительно важно, я рекомендую вам реализовать что-то, что включает погрешность.

Например, если вы рассматриваете деньги и хотите проверить четные суммы в долларах, вы можете сказать (следуя шаблону Хота):

if( Math.abs(d - Math.Floor(d + 0.001)) < 0.001)

Другими словами, возьмите абсолютное значение разницы значения и его целочисленного представления и убедитесь, что оно мало.

Вам не нужен дополнительный (двойной) там. Это работает:

if (d == (int)d) {
 //...
}

Используйте Math.Truncate()

Это позволит вам выбрать, какую точность вы ищете, плюс или минус половина тика, чтобы учесть дрейф с плавающей запятой. Сравнение также является интегральным, что приятно.

static void Main(string[] args)
{
    const int precision = 10000;

    foreach (var d in new[] { 2, 2.9, 2.001, 1.999, 1.99999999, 2.00000001 })
    {
        if ((int) (d*precision + .5)%precision == 0)
        {
            Console.WriteLine("{0} is an int", d);
        }
    }
}

и выход

2 is an int
1.99999999 is an int
2.00000001 is an int

Что-то вроде этого

double d = 4.0;
int i = 4;

bool equal = d.CompareTo(i) == 0; // true

Не могли бы вы использовать это

    bool IsInt(double x)
    {
        try
        {
            int y = Int16.Parse(x.ToString());
            return true;
        }
        catch 
        {
            return false;
        }
    }

Чтобы справиться с точностью двойного...

Math.Abs(d - Math.Floor(d)) <= double.Epsilon

Рассмотрим следующий случай, когда значение меньше чем double.Epsilon не может сравниться с нулем.

// number of possible rounds
const int rounds = 1;

// precision causes rounding up to double.Epsilon
double d = double.Epsilon*.75;

// due to the rounding this comparison fails
Console.WriteLine(d == Math.Floor(d));

// this comparison succeeds by accounting for the rounding
Console.WriteLine(Math.Abs(d - Math.Floor(d)) <= rounds*double.Epsilon);

// The difference is double.Epsilon, 4.940656458412465E-324
Console.WriteLine(Math.Abs(d - Math.Floor(d)).ToString("E15"));