Преобразование int до float/Float в int с помощью побитового

во-первых, статья, которую вы должны рассмотреть чтение, Если вы хотите лучше понять недостатки с плавающей запятой: "что каждый компьютерщик должен знать об арифметике с плавающей запятой",http://www.validlab.com/goldberg/paper.pdf

а теперь к мясу.

следующий код является голыми костями и пытается создать единый прецизионный поплавок IEEE-754 из unsigned int в диапазоне 0 24. Это формат, который вы больше всего вероятно, столкнется на современном оборудовании, и это формат, который вы, похоже, ссылаетесь в своем исходном вопросе.

поплавки IEEE-754 с одной точностью делятся на три поля: бит одного знака, 8 бит экспоненты и 23 бита сигнификации (иногда называемый мантиссой). IEEE-754 использует скрытые 1 significand, что означает, что significand на самом деле составляет 24 бита. Биты упакованы слева направо, со знаком бит в бит 31, экспонента в битах 30 .. 23, а мантисса в бит 22 .. 0. Следующая диаграмма из Википедии иллюстрирует:

показатель имеет смещение 127, что означает, что фактический показатель, связанный с числом с плавающей запятой, на 127 меньше значения, хранящегося в поле показателя. Таким образом, показатель 0 будет закодирован как 127.

(Примечание: Полная статья Википедии может быть вам интересна. Ссылка: http://en.wikipedia.org/wiki/Single_precision_floating-point_format )

таким образом, номер IEEE-754 0x40000000 интерпретируется следующим образом:

• бит 31 = 0: положительное значение
• биты 30 .. 23 = 0x80: показатель = 128-127 = 1 (он же. 2¹)
• биты 22 .. 0 - это все 0: Significand = 1.00000000_00000000_0000000. (Заметьте, я восстановил скрытые 1).

таким образом, значение равно 1.0 x 2¹ = 2.0.

преобразование unsigned int в ограниченном диапазоне, приведенном выше, затем к чему-то в формате IEEE-754 вы можете использовать функцию, подобную приведенной ниже. Он выполняет следующие шаги:

• выравнивает ведущий 1 целого числа в положение скрытый 1 в плавающее представление точки.
• выравнивая целое число, записывает общее количество сделанных сдвигов.
• маски от скрытое 1.
• используя количество сделанных сдвигов, вычисляет показатель и добавляет его к числу.
• используя reinterpret_cast, преобразует результирующий битовый шаблон в float. Эта часть является уродливым взломом, потому что она использует указатель типа. Вы также можете сделать это, злоупотребляя union. Некоторые платформы обеспечивают встроенную операцию (например,_itof), чтобы сделать это переосмысление уродиной.

есть гораздо более быстрые способы сделать это; это предназначенный быть педагогически полезным, если не супер эффективным:

float uint_to_float(unsigned int significand)
{
    // Only support 0 < significand < 1 << 24.
    if (significand == 0 || significand >= 1 << 24)
        return -1.0;  // or abort(); or whatever you'd like here.

    int shifts = 0;

    //  Align the leading 1 of the significand to the hidden-1 
    //  position.  Count the number of shifts required.
    while ((significand & (1 << 23)) == 0)
    {
        significand <<= 1;
        shifts++;
    }

    //  The number 1.0 has an exponent of 0, and would need to be
    //  shifted left 23 times.  The number 2.0, however, has an
    //  exponent of 1 and needs to be shifted left only 22 times.
    //  Therefore, the exponent should be (23 - shifts).  IEEE-754
    //  format requires a bias of 127, though, so the exponent field
    //  is given by the following expression:
    unsigned int exponent = 127 + 23 - shifts;

    //  Now merge significand and exponent.  Be sure to strip away
    //  the hidden 1 in the significand.
    unsigned int merged = (exponent << 23) | (significand & 0x7FFFFF);


    //  Reinterpret as a float and return.  This is an evil hack.
    return *reinterpret_cast< float* >( &merged );
}

вы можете сделать этот процесс более эффективным, используя функции, которые выявляют ведущий 1 в ряд. (Они иногда идут по именам, как clz для "подсчет нулей", или norm для "нормализации".)

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

для целых чисел >= 2²⁴, целое число не вписывается в поле significand 32-битного формата float. Вот почему вам нужно "округлить": вы теряете LSBs, чтобы сделать значение подходящим. Таким образом, несколько целых чисел в конечном итоге сопоставляются с одним и тем же шаблоном с плавающей запятой. Точное отображение зависит от режима округления (округление к бесконечности, округление до +инф, вокруг к нулю, округление до ближайшего четного). Но дело в том, что вы не можете засунуть 24 биты в меньше, чем 24 бита без потерь.

вы можете увидеть это с точки зрения кода выше. Он работает путем выравнивать ведущее 1 к спрятанному 1 положению. Если значение >= 2²⁴, код должен был бы shift право, а не левый, и это обязательно сдвигает LSBs прочь. Режимы округления просто расскажут вам, как обрабатывать смещенные биты.