c语言中实现定点数的问题

Question

我想做一个小的定点数学库。我的定点数是32位的，整数部分和小数部分各有16位。麻烦在于添加定点数，然后查看结果值。下面的函数fixed_from_parts取一个积分部分和分数部分，并且放出一个不动数，因此fixed_from_parts(5, 2)等于0000000000000101.0000000000000010。

当两个数相加时，如下面的main函数所示，似乎将整数部分相加为一个数，将小数部分相加为另一个数(5.2 + 3.9错误地变成了8.11，因为5 + 3 == 8,2 + 9 == 11)。我想我需要反转存储在小数部分的位的顺序，但我不太确定该怎么做。我过于复杂吗?如何使加法正确工作?

#include <stdint.h>
#include <stdio.h>
typedef int16_t integral_t;
typedef int32_t fixed_t;
fixed_t int_to_fixed(const integral_t x) {
return x << 16;
} 
integral_t fixed_to_int(const fixed_t x) {
return x >> 16;
}
// shifts right (clears integral bits), and then shifts back
integral_t get_fixed_fractional(const fixed_t x) {
return (integral_t) x << 16 >> 16;
}
// fixed_from_parts(5, 2) == 5.2
fixed_t fixed_from_parts(const integral_t integral, const integral_t fractional) {
return int_to_fixed(integral) + fractional;
}
void print_fixed_base_2(const fixed_t x) {
for (int i = (sizeof(fixed_t) << 3) - 1; i >= 0; i--) {
putchar((x & (1 << i)) ? '1' : '0');
if (i == sizeof(fixed_t) << 2) putchar('.');
}
putchar('n');
}
void print_fixed_base_10(const fixed_t x) {
printf("%d.%dn", fixed_to_int(x), get_fixed_fractional(x));
}
int main(void) {
// 5.2 + 3.9 = 9.1
const fixed_t a = fixed_from_parts(5, 2), b = fixed_from_parts(3, 9);
print_fixed_base_2(a);
print_fixed_base_2(b);
const fixed_t result = a + b;
print_fixed_base_2(result);
print_fixed_base_10(result); // why is the result 8.11?
}

Answer 1

你的一个不是固定点。

的例子:

#define MULT    (1 << 16)
#define MAKE_FIXED(d)  ((int32_t)(d * MULT))
#define MAKE_REAL(f)   (((double)(f)) / MULT)
int32_t mulf(int32_t a, int32_t b)
{
int64_t part = (int64_t)a * b;
return part/MULT;
}
int32_t divf(int32_t a, int32_t b)
{
int64_t part = ((int64_t)a * MULT) / b;
return part;
}

int main(void)
{
int32_t num1 = MAKE_FIXED(5.2);
int32_t num2 = MAKE_FIXED(3.9);

printf("%fn", MAKE_REAL(num1 + num2));
int32_t result = mulf(num1, num2);
printf("%fn", MAKE_REAL(result));
result = divf(num1,num2);
printf("%fn", MAKE_REAL(result));
}

Answer 2

你的代码中有多个问题:

• 函数get_fixed_fractional有未定义的行为:为了去掉积分部分，你用<< 16将其移出，这可能会导致算术溢出。此外，integral_t类型是有符号的，而小数部分应该是无符号的。您应该只屏蔽高位并返回fixed_t:

  // clear the integral bits
  fixed_t get_fixed_fractional(fixed_t x) { return x & 0xFFFF; }
  

• 你打印%d的小数部分,但它产生误导输出:fixed_from_parts(5, 2)打印5.2但5.000030517578125价值,你5.00003轮。打印fixed_t的代码应该是:

  void print_fixed_base_10(const fixed_t x) {
  printf("%d.%05lldn",
  fixed_to_int(x),
  (get_fixed_fractional(x) * 100000LL + 32768) / 65536);
  }
  

下面是修改后的版本:

#include <stdint.h>
#include <stdio.h>
typedef int16_t integral_t;
typedef int32_t fixed_t;
fixed_t int_to_fixed(integral_t x) {
return x << 16;
}
integral_t fixed_to_int(fixed_t x) {
return x >> 16;
}
// clear the integral bits
integral_t get_fixed_fractional(fixed_t x) {
return (integral_t)(x & 0xFFFF);
}
// fixed_from_parts(5, 2) == 5.2
fixed_t fixed_from_parts(integral_t integral, integral_t fractional) {
return int_to_fixed(integral) + fractional;
}
void print_fixed_base_2(fixed_t x) {
for (int i = 32; i-- > 0;) {
putchar((x & ((uint32_t)1 << i)) ? '1' : '0');
if (i == 16)
putchar('.');
}
putchar('n');
}
void print_fixed_base_10(fixed_t x) {
printf("%d.%05lldn",
fixed_to_int(x),
(get_fixed_fractional(x) * 100000LL + 32768) / 65536);
}
int main(void) {
// 5.2 + 3.9 = 9.1 (not really)
const fixed_t a = fixed_from_parts(5, 2), b = fixed_from_parts(3, 9);
const fixed_t result = a + b;
print_fixed_base_2(a);
print_fixed_base_2(b);
print_fixed_base_2(result);
print_fixed_base_10(a);
print_fixed_base_10(b);
print_fixed_base_10(result);
return 0;
}

输出:

0000000000000101.0000000000000010
0000000000000011.0000000000001001
0000000000001000.0000000000001011
5.00003
3.00014
8.00017

你可能想传递第三个参数给fixed_from_parts来指定分母:

// fixed_from_parts(5, 2, 10) == 5.2
fixed_t fixed_from_parts(integral_t integral, unsigned int fractional, unsigned int denominator) {
return int_to_fixed(integral) + (fixed_t)((fractional * 65536LL + denominator / 2) / denominator);
}