наибольшее целое число, которое может быть сохранено в двойном

Наибольшее / наибольшее целое число, которое может быть сохранено в double без потери точности, совпадает с наибольшим возможным значением double. То есть DBL_MAX или примерно 1,8 × 10 ³⁰⁸ (если ваш дубль является 64-битным двойником IEEE 754). Это целое число. Он представлен точно. Что вы еще хотите?

Продолжайте, спросите меня, какое наибольшее целое число, чтобы его и все меньшие целые числа можно было сохранить в 64-битных числах IEEE с двойной точностью без потери точности. 64-битный двойной IEEE имеет 52 бита мантиссы, поэтому я думаю, что это 2 ⁵³:

• 2 ⁵³ + 1 не может быть сохранен, потому что 1 в начале и 1 в конце имеют слишком много нулей между ними.
• Все, что меньше 2 ⁵³, может быть сохранено с 52 битами, явно сохраненными в мантиссе, а затем действительный показатель степени дает вам еще один.
• 2 ⁵³, очевидно, можно сохранить, так как это малая степень двойки.

Или другой способ взглянуть на это: после того, как смещение было снято с экспоненты и игнорируя знаковый бит как не имеющий отношения к вопросу, значение, сохраненное двойным, является степенью 2 плюс 52-битное целое число, умноженное на 2 ^{показатель степени - 52}. Таким образом, с показателем 52 вы можете сохранить все значения от 2 ⁵² до 2 ⁵³ - 1. Затем с показателем 53 следующее число, которое вы можете сохранить после 2 ⁵³ равно 2 ⁵³ + 1 × 2 ^53–52. Итак, потеря точности сначала происходит с 2 ⁵³ + 1.

9007199254740992 (это 9 007 199 254 740 992 или 2 ^ 53) без каких-либо гарантий :)

Программа

#include <math.h>
#include <stdio.h>

int main(void) {
  double dbl = 0; /* I started with 9007199254000000, a little less than 2^53 */
  while (dbl + 1 != dbl) dbl++;
  printf("%.0f\n", dbl - 1);
  printf("%.0f\n", dbl);
  printf("%.0f\n", dbl + 1);
  return 0;
}

Результат

9007199254740991
9007199254740992
9007199254740992

В Википедии это говорится в том же контексте со ссылкой на IEEE 754:

В типичной компьютерной системе двоичное число с плавающей запятой «двойной точности» (64-битное) имеет коэффициент 53 бита (один из которых подразумевается), показатель степени 11 бит и один бит знака.

2 ^ 53 чуть больше 9 * 10 ^ 15.

Наибольшее целое число, которое может быть представлено в IEEE 754 double (64-битное), совпадает с наибольшим значением, которое может представлять тип, поскольку это значение само является целым числом.

Он представлен как 0x7FEFFFFFFFFFFFFF, который состоит из:

• Знаковый бит 0 (положительный), а не 1 (отрицательный)
• Максимальный показатель степени 0x7FE (2046, который представляет 1023 после вычитания смещения), а не 0x7FF (2047, который указывает NaN или бесконечность).
• Максимальная мантисса 0xFFFFFFFFFFFFF, которая составляет 52 бита, все 1.

В двоичном формате значение - это неявная 1, за которой следуют еще 52 единицы из мантиссы, затем 971 ноль (1023 - 52 = 971) из экспоненты.

Точное десятичное значение:

179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368

Это примерно 1,8 x 10 ³⁰⁸.

Нужно смотреть на размер мантиссы. 64-битное число с плавающей запятой IEEE 754 (которое имеет 52 бита, плюс подразумевается 1) может точно представлять целые числа с абсолютным значением, меньшим или равным 2 ^ 53.

1.7976931348623157 × 10^308

http://en.wikipedia.org/wiki/Double_precision_floating-point_format

Это правда, что для 64-битного IEEE754 double все целые числа до 9007199254740992 == 2 ^ 53 могут быть точно представлены.

Однако стоит также отметить, что все представимые числа за пределами 4503599627370496 == 2 ^ 52 являются целыми числами. За пределами 2 ^ 52 становится бессмысленным проверять, являются ли они целыми числами, потому что все они неявно округляются до ближайшего представимого значения.

В диапазоне от 2 ^ 51 до 2 ^ 52 единственными нецелыми значениями являются средние точки, оканчивающиеся на 0,5, что означает, что любой целочисленный тест после вычисления должен дать как минимум 50% ложных ответов.

Ниже 2 ^ 51 у нас также есть 0,25 и 0,75, поэтому сравнение числа с его округленным эквивалентом, чтобы определить, может ли оно быть целым или нет, начинает иметь некоторый смысл.

TL; DR: если вы хотите проверить, может ли вычисленный результат быть целым числом, избегайте чисел больше 2251799813685248 == 2 ^ 51

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

Вы можете использовать FLT_MANT_DIG и DBL_MANT_DIG, определенные в float.h, чтобы не полагаться на явные значения (например, 53):

#include <stdio.h>
#include <float.h>

int main(void)
{
    printf("%d, %.1f\n", FLT_MANT_DIG, (float)(1L << FLT_MANT_DIG));
    printf("%d, %.1lf\n", DBL_MANT_DIG, (double)(1L << DBL_MANT_DIG));
}

выходы:

24, 16777216.0
53, 9007199254740992.0