Этот код работает (С# 3)
double d;
if(d == (double)(int)d) ...;
Примечание. Несколько человек указали на (важную) точку, что == часто является проблематичным исправлением с плавающей запятой. В этом случае я ожидаю значения в диапазоне от 0 до нескольких сотен, и они должны быть целыми (не ints являются ошибками), поэтому, если эти точки "не должны" быть проблемой для меня.
d == Math.Floor(d)
делает то же самое другими словами.
NB: Надеюсь, вы осознаете, что вы должны быть очень осторожны при выполнении такого рода вещей; floats/doubles очень легко накапливают мелкие ошибки, которые делают точные сравнения (например, этот) неудачными без какой-либо очевидной причины.
Если ваш двойник является результатом другого вычисления, вы, вероятно, захотите что-то вроде:
d == Math.Floor(d + 0.00001);
Таким образом, если бы была небольшая ошибка округления, она все равно будет соответствовать.
Это сработает, я думаю:
if (d % 1 == 0) {
//...
}
Я не могу ответить на конкретную часть вопроса, относящуюся к С#, но я должен указать, что вам, вероятно, не хватает общей проблемы с числами с плавающей запятой.
Как правило, целочисленность не определена на поплавках. По той же причине, что равенство не определено на поплавках. Расчеты с плавающей запятой обычно включают ошибки округления и представления.
Например, 1.1 + 0.6 != 1.7.
Yup, это то, как работают числа с плавающей запятой.
Здесь 1.1 + 0.6 - 1.7 == 2.2204460492503131e-16.
Строго говоря, самое близкое к сопоставлению равенства, которое вы можете делать с поплавками, сравнивает их с выбранной точностью.
Если этого недостаточно, вы должны работать с представлением десятичного числа с представлением числа с плавающей запятой со встроенным диапазоном ошибок или с символическими вычислениями.
Вам не нужен дополнительный (двойной). Это работает:
if (d == (int)d) {
//...
}
Использовать Math.Truncate()
Если вы просто собираетесь его преобразовать, ответ Майка Ф/Хота хороший, но не совсем ответит на ваш вопрос. Если вы собираетесь фактически протестировать, и это действительно важно, я рекомендую вам внедрить что-то, что включает погрешность.
Например, если вы рассматриваете деньги и хотите проверить даже долларовые суммы, вы можете сказать (следуя схеме Хота):
если (Math.abs(d - Math.Floor(d + 0,001)) < 0,001)
Другими словами, возьмите абсолютное значение разности значения и целочисленного представления и убедитесь, что оно мало.
Простой тест, такой как "x == floor (x)", математически гарантирован для правильной работы для любого номера FP с фиксированной точностью.
Все законные FP-кодировки с фиксированной точностью представляют собой различные действительные числа, поэтому для каждого целого x существует не более одной FP-кодировки с фиксированной точностью, которая точно соответствует ей.
Следовательно, для любого целого x, который МОЖЕТ быть представлен таким образом, мы имеем x == floor (x) обязательно, так как floor (x) по определению возвращает наибольшее число FP y такое, что y <= x и y представляет собой целое число; поэтому floor (x) должен возвращать x.
Это позволит вам выбрать, какую точность вы ищете, плюс или минус половину галочки, для учета дрейфа с плавающей запятой. Сравнение также является целым.
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"));