Сдвиг бит для арифметики с фиксированной запятой для чисел с плавающей запятой в C

Если вы хотите использовать фиксированную точку, не используйте тип «float» или «double», потому что они имеют внутреннюю структуру. Поплавки и двойники имеют специальный бит для знака; некоторые биты для экспоненты, некоторые для мантиссы (см. цветное изображение здесь) ; поэтому они по своей сути являются числами с плавающей запятой.

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

Существует описание расширений с плавающей запятой, реализованных в GCC: http://gcc.gnu.org/onlinedocs/gcc/Fixed_002dPoint.html

Существует некоторая ручная реализация фиксированной точки для C на основе MACRO: http://www.eetimes.com/discussion/other/4024639/Fixed-point-math-in-C

То, что вы делаете, жестоко обращается с числами.

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

x = 2.0 = 1 * 2^1   : sign = 0, mantissa = 1,   exponent = 1 -> 0 10000000 00000000000000000000000 = 0x40000000
y = 3.0 = 1.5 * 2^1 : sign = 0, mantissa = 1.5, exponent = 1 -> 0 10000000 10000000000000000000000 = 0x40400000
z = 1.0 = 1 * 2^0   : sign = 0, mantissa = 1,   exponent = 0 -> 0 01111111 00000000000000000000000 = 0x3F800000

Если вы выполните несколько операций сдвига битов с этими числами, вы перепутаете границы между знаком, экспонентой и мантиссой, и все может, может и произойдет.

В твоем случае:

• ваш 2.0 становится 0x80000000, что приводит к -0.0,
• ваш 3.0 становится 0x80800000, что приводит к -1.1754943508222875e-38,
• ваш 1.0 становится 0x7F000000, в результате чего 1.7014118346046923e + 38.

Последнее вы потеряете, добавив -0.0 и -1.1754943508222875e-38, что станет последним, а именно 0x80800000, который должен быть после >> увеличения на 1 снова на 3,0. Не знаю, почему это не так, наверное, потому, что я здесь ошибся.

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

Я бы подумал о том, чтобы преобразовать их в целое число или другую фиксированную точку на ARM и отправить их по линии, как они есть.

Вероятно, ваш компилятор использует формат IEEE 754 для floats, который в битовых терминах выглядит так:

SEEEEEEEEFFFFFFFFFFFFFFFFFFFFFFF
^ bit 31                       ^ bit 0

S - это знаковый бит. S = 1 означает, что число отрицательное.

E бит - это показатель степени. Имеется 8 битов экспоненты, дающих диапазон от 0 до 255 , но показатель степени смещен - вам нужно вычесть 127, чтобы получить истинный показатель степени.

F бит - это дробная часть, однако вам нужно представить невидимую единицу спереди, чтобы дробь всегда была 1. что-то, а все, что вы видите, - это цифры двоичной дроби.

Число 2 равно 1 x 2 ¹ = 1 x 2 ^128–127, поэтому кодируется как

01000000000000000000000000000000

Итак, если вы используете небольшой сдвиг, чтобы сдвинуть его вправо, вы получите

10000000000000000000000000000000

который по соглашению равен -0 в IEEE754, поэтому вместо умножения вашего числа на 2 ваш сдвиг сделал его нулевым.

Число 3 равно [1 + 0,5] x 2 ^128–127.

который представлен как

01000000010000000000000000000000

Сдвиг влево дает вам

10000000100000000000000000000000

что составляет -1 x 2 ^-126 или какое-то очень маленькое число.

Вы можете сделать то же самое для z, но вы, вероятно, поняли, что сдвиг просто портит числа с плавающей запятой.

Фиксированная точка не работает. Вы хотите сделать что-то вроде этого:

void main(){
    // initing 8bit fixed point numbers
    unsigned int x = 2 << 8;
    unsigned int y = 3 << 8;
    unsigned int z = 1 << 8;

    // adding two numbers
    unsigned int a = x + y;

    // multiplying two numbers with fixed point adjustment
    unsigned int b = (x * y) >> 8;

    // use numbers
    printf("%d %d\n", a >> 8, b >> 8);
  }