Как бесконечность представлена ​​в C двойной?

Ответ 1

Во-первых, 0x7ff0000000000000 действительно является битовым представлением двойной бесконечности. Но приведение не устанавливает представление битов, оно преобразует логическое значение 0x7ff0000000000000, интерпретируемое как целое число 64 бит. Таким образом, вам нужно использовать другой способ установки битового шаблона.

Прямым способом установки битовой диаграммы будет

uint64_t bits = 0x7ff0000000000000;
double infinity = *(double*)&bits;

Однако это поведение undefined.. Стандарт C запрещает чтение значения, которое было сохранено в качестве одного фундаментального типа (uint64_t) в качестве другого фундаментального типа (double). Это известно как строгие правила псевдонимов и позволяет компилятору генерировать лучший код, потому что он может предположить, что порядок чтения одного типа и запись другого типа не имеет значения.

Единственным исключением из этого правила являются типы char: вам явно разрешено указывать любой указатель на char* и обратно. Поэтому вы можете попробовать использовать этот код:

char bits[] = {0x7f, 0xf0, 0, 0, 0, 0, 0, 0};
double infinity = *(double*)bits;

Несмотря на то, что это не поведение undefined больше, оно по-прежнему зависит от реализации: порядок байтов в double зависит от вашего устройства. Данный код работает на большой конечной машине, такой как ARM и семейство Power, но не на X86. Для X86 вам нужна эта версия:

char bits[] = {0, 0, 0, 0, 0, 0, 0xf0, 0x7f};
double infinity = *(double*)bits;

По-настоящему не существует способа реализации этой реализации, поскольку нет гарантии, что машина будет хранить значения с плавающей запятой в том же порядке, что и целочисленные. Есть даже машины, которые используют байтовые порядки следующим образом: < 1, 0, 3, 2 > Я даже не хочу знать, кто придумал эту блестящую идею, но она существует, и мы должны жить с ней.

К вашему последнему вопросу: арифметика с плавающей запятой по сути отличается от целочисленной арифметики. Биты имеют специальные значения, и блок с плавающей запятой учитывает это. Особенно специальные отношения, такие как бесконечности, NAN и денормализованные числа, рассматриваются особым образом. А так как +inf + -inf определен для получения NAN, ваш блок с плавающей запятой испускает битовый шаблон NAN. Целочисленная единица не знает о бесконечностях или NAN, поэтому она просто интерпретирует битовый шаблон как огромное целое число и с радостью выполняет целочисленное добавление (которое в этом случае происходит с переполнением). Результирующая битовая диаграмма не относится к NAN. Это, скорее всего, битовая диаграмма действительно огромного положительного числа с плавающей запятой (2^1023, если быть точным), но это не имеет никакого значения.

На самом деле существует способ установить битовые шаблоны всех значений, кроме NAN, переносимым образом: учитывая три переменные, содержащие биты знака, экспонента и мантиссы, вы можете сделать это:

uint64_t sign = ..., exponent = ..., mantissa = ...;
double result;
assert(!(exponent == 0x7ff && mantissa));    //Can't set the bits of a NAN in this way.
if(exponent) {
    //This code does not work for denormalized numbers. And it won't honor the value of mantissa when the exponent signals NAN or infinity.
    result = mantissa + (1ull << 52);    //Add the implicit bit.
    result /= (1ull << 52);    //This makes sure that the exponent is logically zero (equals the bias), so that the next operation will work as expected.
    result *= pow(2, (double)((signed)exponent - 0x3ff));    //This sets the exponent.
} else {
    //This code works for denormalized numbers.
    result = mantissa;    //No implicit bit.
    result /= (1ull << 51);    //This ensures that the next operation works as expected.
    result *= pow(2, -0x3ff);    //Scale down to the denormalized range.
}
result *= (sign ? -1.0 : 1.0);    //This sets the sign.

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

Ответ 2

Инициализация

double x1=(double)0x7ff0000000000000;

преобразует литерал целочисленного числа в double. Вероятно, вы захотите поделиться поразрядным представлением. Это специфическое исполнение (возможно неуказанное bahavior), но вы можете использовать union:

union { double x; long long n; } u;
u.n = 0x7ff0000000000000LL;

затем используйте u.x; Я предполагаю, что long long и double являются 64 бит на вашем компьютере. Также важны endianess и с плавающей запятой.

См. также http://floating-point-gui.de/

Обратите внимание, что не все процессоры x86, и не все реализации с плавающей запятой IEEE754 ( даже если в 2014 году большинство из них). Ваш код, вероятно, не будет работать на процессоре ARM, например. в планшете.

Ответ 3

Вы переносите значение в double, и это не будет работать, как вы ожидаете.

double x1=(double)0x7ff0000000000000; // Not setting the value directly

Чтобы избежать этой проблемы, вы можете интерпретировать это значение как двойной указатель и разыменовать его (хотя это ужасно не рекомендуется и будет работать только с unsigned long long == double size):

unsigned long long x1n = 0x7ff0000000000000ULL; // Inf
double x1 = *((double*)&x1n);
unsigned long long x2n = 0x7ff0000000000001ULL; // Signaling NaN
double x2 = *((double*)&x2n);

printf("\nx1=%f, x2=%f sizeof(double) = %d", x1, x2, sizeof(x2));
if (x1 == x2)
    printf("\nx1==x2");
else
    printf("\nx1!=x2"); // x1 != x2

Пример идеона

Ответ 4

Вы преобразовали константу 0x7ff00... в double. Это совсем не то же самое, что взять бит-представление этого значения и интерпретировать его как double.

Это также объясняет, почему x1==x2. Когда вы конвертируете в double, вы теряете точность; поэтому иногда для больших целых чисел double, в результате которого вы входите, одинаково в двух случаях. Это дает вам некоторые странные эффекты, когда для большого значения с плавающей запятой добавление 1 оставляет его неизменным.