float 浮点数转成定点数计算其加法和乘法

需要注意的是，以下的程序是建立在下述条件为真的情况下的：

1. (sizeof(float) == 4 && sizeof(long long) == 8 && sizeof(int) == 4) == ture

也就是说，一定要保证float和int是占4个字节(32bits)，long long是占8个字节(64bits)的。

1， 浮点数转定点乘法

1. void FixedPointMul(float&a, float& b, float& res)
2. {
3. int ia = *(int*)(&a);
4. int ib = *(int*)(&b);
5. //正负0的情况下，直接返回
6. if (ia == 0x80000000 || ia == 0x0 || ib == 0x80000000 || ib == 0x0)
7. {
8. res = 0.0f;
9. return;
10. }
11. //实际尾数还要加上最前面的1,这里用Long long的原因是两个24位数的乘法，最多是48位，已超出int
12. long long ma = (ia & 0x7fffff) | 0x800000;
13. long long mb = (ib & 0x7fffff) | 0x800000;
14. //码位
15. int ea = ((ia >> 23) & 0xff) - 0x7f;
16. int eb = ((ib >> 23) & 0xff) - 0x7f;
17. //mul
18. long long mc = ma * mb;//相当于a<< (23-ea) a<<(23-eb)
19. //计算阶码
20. //先计算最高有效位
21. int i = 0;
22. long long tmp = mc;
23. while (tmp != 0)
24. {
25. tmp >>= 1;
26. i++;//得到MSB的位置
27. }
29. int ec = i - 1 - (23 - ea + 23 - eb) + 0x7f;
30. //再右移mc MSB 到第24位
31. //把MSB移位到第24位
32. //把MSB移位到第24位
33. if (i < 24)
34. mc = (mc << (24 - i)) & 0xffffff;
35. else
36. mc = (mc >> (i - 24)) & 0xffffff;
37. //
38. //标记两个数的正负
39. int sa = 0;
40. if ((ia & 0x80000000) ^ (ib & 0x80000000))//xor
41. sa = 1;//negative
42. //float
43. //拼接成float
44. int rc = 0x00000000;
45. rc = rc | (mc & 0x7fffff);
46. rc = rc | ((ec << 23) & 0x7fffffff);
47. //判断正负
48. if (sa == 1)
49. rc = rc | 0x80000000;
50. res = *(float*)(&rc);
51. return;
52. }

2, 浮点转定点加法（减法可以认为是加上一个负数）

1. #ifndef MAX
2. #define MAX(X,Y) ((X)>(Y) ? (X) : (Y))
3. #endif
4. void FixedPointAdd(float& a, float& b, float& res)
5. {
6. int ia = *(int*)(&a);
7. int ib = *(int*)(&b);
8. //考虑正负0的情况
9. if (ia == 0)
10. {
11. res = b;
12. if(ib == 0x80000000)
13. res = 0.0f;
15. return;
16. }
17. if (ib == 0)
18. {
19. res = a;
20. if (ia == 0x80000000)
21. res = 0.0f;
22. return;
23. }
24. //if ((ia & 0x7f800000 == 0x7f800000) | (ib & 0x7f800000 == 0x7f800000));
25. //实际尾数还要加上最前面的1
26. long long ma = (ia & 0x7fffff) | 0x800000;
27. long long mb = (ib & 0x7fffff) | 0x800000;
28. //码位
29. int ea = ((ia >> 23) & 0xff) - 0x7f;
30. int eb = ((ib >> 23) & 0xff) - 0x7f;
31. //正负
32. int sa = ia & 0x80000000;
33. int sb = ib & 0x80000000;
34. //移动到48位并加上符号运算
35. if (ea > eb)
36. {
    //让较大的数的MSB移动到第48位，较小的数对应的移动
37. //这样的话，小数点对齐在哪里？
38. ma <<= 24;
39. //mb如何移动？//mb少移动:ea与eb的绝对值的差
40. mb <<= (24 - std::abs(ea - eb));
41. }
42. else
43. {
44. mb <<= 24;
45. ma <<= (24 - std::abs(ea - eb));
46. }
47. //考虑符号
48. ma = (sa == 0 ? ma : -ma);
49. mb = (sb == 0 ? mb : -mb);
50. long long mc = ma + mb;
51. int i = 0;
52. long long tmp = 0;
53. //结果符号
54. tmp = 0x8000000000000000;
55. int sc = ((mc & tmp) == 0 ? 0 : 1);
56. if (sc == 1)//说明结果是负数
57. {
58. mc = -mc;
59. }
60. //计算阶码
61. //先计算最高有效位
62. tmp = mc;
63. while (tmp != 0)
64. {
65. tmp >>= 1;
66. i++;//得到MSB的位置
67. }
68. //code
69. int ec = 0x7f;
70. if (ea > eb)
71. ec += ea + (i - 48);
72. else
73. ec += eb + (i - 48);
74. //把MSB移位到第24位
75. if (i < 24)
76. mc = (mc << (24 - i)) & 0xffffff;
77. else
78. mc = (mc >> (i - 24)) & 0xffffff;
79. //
80. //float
81. //拼接成float
82. int rc = 0x00000000;
83. rc = rc | (mc & 0x7fffff);
84. rc = rc | ((ec << 23) & 0x7fffffff);
85. //判断正负
86. if (sc == 1)
87. rc = rc | 0x80000000;
88. res = *(float*)(&rc);
89. return;
90. }

最后需要注意的是，float占4个字节的情况下，在二进制情况下，共有24bit数字是精确数字，转换到十进制数， 只有6位有效数字是绝对精确的，所以在两个float数字比较其误差时，应注意，第7位及以后的数字是无意义的。

比如说：12345.67888和12345.6999其实对于float的内存来说是一样的，但是它们之间的绝对误差是：0.02111，达到了2%。

再比如：123456.000和123456.9999，在float的内存上是一样的，但是，其绝对差为0.9999。

所以用绝对差来表示两个float数是否相近，是不合理的。