двоичная переносимость с плавающей запятой

Question

У меня есть библиотека, которая сохраняет в дисках нагрузки данных с плавающей запятой в текстовой форме. Кажется, они сделали это из-за важности переносимости, но из-за огромного использования диска из этого я написал функцию, чтобы сохранить двоичное представление плавающих точек непосредственно на диск. Я знаю, что это не гарантирует 100% -ную переносимость, но я буду запускать это только на x86 (_64) Linux/Windows PC (возможно, также в Mac и BSD).

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

Answer 1

Есть ли способ, по крайней мере, проверить, соответствует ли программа с плавающей запятой программа, хорошо ли она с системой?

Тест 1: размерof. Тест 2: сохраните волшебное значение с плавающей запятой в заголовке вашего файла на диске и проверьте, что программа имеет правильное значение после того, как вы прочитали двоичные данные с диска. Это должно быть достаточно безопасным.

И сколько я должен ожидать от несовместимости с данными с плавающей запятой в двоичной форме?

Очень мало. Если, как вы говорите, вы остаетесь с одной аппаратной архитектурой (x86), все будет в порядке. Если у вас ограниченный набор поддерживаемых архитектур - просто проверьте все из них. На x86 все будут использовать аппаратную плавающую точку, которая ограничивает их творческий подход (в значительной степени не совсем). Даже между архитектурами все, кого я знаю о том, кто использует IEEE 754 с плавающей запятой, имеют одно и то же двоичное представление для одной и той же сущности.

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

Answer 2

Вы можете посмотреть новые (C11) и старые макросы в заголовке <float.h>, page 46: 5.2.4.2.2 Characteristics of floating types.

Answer 3

В целом вам должно быть хорошо читать и записывать двоичные данные: бинарный формат обмена IEEE754 в значительной степени является стандартным за пределами нескольких областей ниши. Вы можете использовать макрос __STDC_IEC_559__ для проверки.

As noted in this question, то, что спецификация не указывает, является точное отображение битов в байты, поэтому существует потенциал для endianness issues (хотя, вероятно, нет, если вы используете исключительно x86/x86_64). Возможно, было бы неплохо включить значение проверки с плавающей запятой в начало вашего потока (обратите внимание, что недостаточно проверить консистенцию ваших целых чисел, так как технически возможно иметь различную ориентацию для целочисленной и с плавающей запятой).

Если вы пишете текст, одна из возможных альтернатив - hex float format, которая может быть намного быстрее для чтения/записи, чем десятичные (хотя и не так быстро, как формат необработанного двоичного обмена). К сожалению, хотя он является частью спецификации IEEE и C-99, он плохо поддерживается компилятором MSVC (хотя теперь это может измениться и является частью C++).

Answer 4

Посмотрите на сайт бинарной переносимости. https://github.com/MalcolmMcLean/ieee754

Функция записи порта IEEE 754 довольно длинна, но это всего лишь вырезать и вставлять задания. Существует также плавающая версия.

/* 
* write a double to a stream in ieee754 format regardless of host 
* encoding. 
* x - number to write 
* fp - the stream 
* bigendian - set to write big bytes first, elee write litle bytes 
*    first 
* Returns: 0 or EOF on error 
* Notes: different NaN types and negative zero not preserved. 
*   if the number is too big to represent it will become infinity 
*   if it is too small to represent it will become zero. 
*/ 
int fwriteieee754(double x, FILE *fp, int bigendian) 
{ 
    int shift; 
    unsigned long sign, exp, hibits, hilong, lowlong; 
    double fnorm, significand; 
    int expbits = 11; 
    int significandbits = 52; 

    /* zero (can't handle signed zero) */ 
    if (x == 0) 
    { 
     hilong = 0; 
     lowlong = 0; 
     goto writedata; 
    } 
    /* infinity */ 
    if (x > DBL_MAX) 
    { 
     hilong = 1024 + ((1 << (expbits - 1)) - 1); 
     hilong <<= (31 - expbits); 
     lowlong = 0; 
     goto writedata; 
    } 
    /* -infinity */ 
    if (x < -DBL_MAX) 
    { 
     hilong = 1024 + ((1 << (expbits - 1)) - 1); 
     hilong <<= (31 - expbits); 
     hilong |= (1 << 31); 
     lowlong = 0; 
     goto writedata; 
    } 
    /* NaN - dodgy because many compilers optimise out this test, but 
    *there is no portable isnan() */ 
    if (x != x) 
    { 
     hilong = 1024 + ((1 << (expbits - 1)) - 1); 
     hilong <<= (31 - expbits); 
     lowlong = 1234; 
     goto writedata; 
    } 

    /* get the sign */ 
    if (x < 0) { sign = 1; fnorm = -x; } 
    else { sign = 0; fnorm = x; } 

    /* get the normalized form of f and track the exponent */ 
    shift = 0; 
    while (fnorm >= 2.0) { fnorm /= 2.0; shift++; } 
    while (fnorm < 1.0) { fnorm *= 2.0; shift--; } 

    /* check for denormalized numbers */ 
    if (shift < -1022) 
    { 
     while (shift < -1022) { fnorm /= 2.0; shift++; } 
     shift = -1023; 
    } 
    /* out of range. Set to infinity */ 
    else if (shift > 1023) 
    { 
     hilong = 1024 + ((1 << (expbits - 1)) - 1); 
     hilong <<= (31 - expbits); 
     hilong |= (sign << 31); 
     lowlong = 0; 
     goto writedata; 
    } 
    else 
     fnorm = fnorm - 1.0; /* take the significant bit off mantissa */ 

    /* calculate the integer form of the significand */ 
    /* hold it in a double for now */ 

    significand = fnorm * ((1LL << significandbits) + 0.5f); 


    /* get the biased exponent */ 
    exp = shift + ((1 << (expbits - 1)) - 1); /* shift + bias */ 

    /* put the data into two longs (for convenience) */ 
    hibits = (long)(significand/4294967296); 
    hilong = (sign << 31) | (exp << (31 - expbits)) | hibits; 
    x = significand - hibits * 4294967296; 
    lowlong = (unsigned long)(significand - hibits * 4294967296); 

writedata: 
    /* write the bytes out to the stream */ 
    if (bigendian) 
    { 
     fputc((hilong >> 24) & 0xFF, fp); 
     fputc((hilong >> 16) & 0xFF, fp); 
     fputc((hilong >> 8) & 0xFF, fp); 
     fputc(hilong & 0xFF, fp); 

     fputc((lowlong >> 24) & 0xFF, fp); 
     fputc((lowlong >> 16) & 0xFF, fp); 
     fputc((lowlong >> 8) & 0xFF, fp); 
     fputc(lowlong & 0xFF, fp); 
    } 
    else 
    { 
     fputc(lowlong & 0xFF, fp); 
     fputc((lowlong >> 8) & 0xFF, fp); 
     fputc((lowlong >> 16) & 0xFF, fp); 
     fputc((lowlong >> 24) & 0xFF, fp); 

     fputc(hilong & 0xFF, fp); 
     fputc((hilong >> 8) & 0xFF, fp); 
     fputc((hilong >> 16) & 0xFF, fp); 
     fputc((hilong >> 24) & 0xFF, fp); 
    } 
    return ferror(fp); 
}