Баг при умножении и делении fixed на fixed

В процессе реализации одного проекта мне понадобилась ( понял я это по Вашей же наводке из статьи) библиотека для использования натуральных чисел с фиксированной точкой. Так как о Bашей библиотеке я ничего не знал(или её тогда и не было), я начал писать свою. Позже, после написания своей, я обнаружил данную библиотеку. Объективно - Ваша библиотека наглядней, проще, и занимает меньше ресурсов, чем моя. (Одна, но не единственная из причин того - моё желание реализовать функцию to_string в обход использования float).

Однако при тесте Вашей библиотеки я нашёл некоторые ошибки:

• библиотека fixed некорректно считает операции умножения и деления fixed с fixed:

#include <fixed.h>
void setup() {
 Serial.begin(9600);
 fixed value (3, 10);            // 0.3
 fixed value2(5, 10);            // 0.5
 fixed value3;
 value3 = value * value2;        // 0.15
 Serial.println(value3.toFloat());
 value3 = value / value2;        // 0.6
 Serial.println(value3.toFloat());
 void loop() {
 }

Вывод на порт:
2457.50
0.00
Всё дело в том, что строчки:

 82: fixed& operator *= (fixed val) {fix *= val.fix; return *this;}
100: fixed& operator /= (fixed val) {fix /= val.fix; return *this;}

не учитывают, некоторых арифметических особенностей.
Представим значение fixed A, хранящее в поле fix значение X, мысленно поделённое на 2^N, где N=12.
Получим, что A = X/(2^N).
Тогда, для аддитивных операторов, при сложении A и B:
A+-B= Xa/(2^N)+-Xb/(2^N)=(Xa+-Xb)/(2^N)
Таким образом, для того, чтобы сложить A и B, необходимо просто сложить их поля fix (Xa+Xb)
Однако, при мультипликативных операторах:
A*B=(Xa/(2^N))*(Xb/(2^N))=(Xa*Xb)/((2^N)*(2^N))
То есть, при перемножении (Xa*Xb) мы получим не A*B, а A*B/(2^N), и, чтобы получить искомое, необходимо Xa*Xb поделить на (2^N)
Аналогично при делении:
A/B=(Xa/(2^N))/(Xb/(2^N))=(Xa*(2^N))/(Xb*(2^N))=Xa/Xb
Тут уже не хватает 2^N.
Следовательно, наша поправка:

  82: fixed& operator *= (fixed val) {fix =(fix * val.fix) / FIX_MUL; return *this;}
 100: fixed& operator /= (fixed val) {fix = FIX_INT(fix) / val.fix ; return *this;}

И на выходе мы имеем закономерные
0.15
0.60

А ещё я бы Вам предложил (это не совет, а просто предложение, так как скорее всего я знаю C++ хуже Вас) использовать шаблоны типа:
T template <class TYPE> для сокращения количества текста в исходном коде, т.е. приведя пример:

    fixed& operator += (fixed val) {fix += val.fix; return *this;}
    fixed& operator += (uint32_t val) {fix += FIX_UINT(val); return *this;}
    fixed& operator += (int32_t val) {fix += FIX_INT(val); return *this;}
    fixed& operator += (uint16_t val) {fix += FIX_UINT(val); return *this;}
    fixed& operator += (int16_t val) {fix += FIX_INT(val); return *this;}
    fixed& operator += (uint8_t val) {fix += FIX_UINT(val); return *this;}
    fixed& operator += (int8_t val) {fix += FIX_INT(val); return *this;}
    fixed& operator += (double val) {fix += FIX_FLOAT(val); return *this;}

заменяем на:

#define T template <class TYPE>
	fixed& operator += (fixed val) {fix += val.fix; return *this;}
T	fixed& operator += (TYPE val) {fix += FIX_INT(val); return *this;}

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

Кстати, объявление переменной, как volatile, при умножении fixed на fixed, возвращает ошибку:
error: binding reference of type 'fixed&' to 'volatile fixed' discards qualifiers
Как с этим бороться - я пока не понял.