浮点数精度上误差

　　在我刚接触编程的时候, 那时候面试小题目很喜欢问下面这几类问题 

               1'  浮点数如何和零比较大小?

               2'  浮点数如何转为整型?

然后过了七八年后这类问题应该很少出现在面试中了吧.  刚好最近我遇到线上 bug,  同大家交流科普下

 

问题最小现场

#include <stdio.h>

int main(void) {
    float a = 2.01f;
    double b = 2.01;

    printf("a1 : 2.01 * 1000 = %f\n", a * 1000);             // a1 : 2.01 * 1000      = 2010.000000
    printf("a2 : int(2.01 * 1000) = %d\n", (int)(a * 1000)); // a2 : int(2.01 * 1000) = 2010

    printf("b1 : 2.01 * 1000 = %lf\n", b * 1000);            // b1 : 2.01 * 1000      = 2010.000000
    printf("b2 : int(2.01 * 1000) = %d\n", (int)(b * 1000)); // b2 : int(2.01 * 1000) = 2009
}

(用 go java 效果是一样的, 绝大部分实现都是严格遵循 ieee754 标准

 

问题解答

其中 a1 和 b1 在 c 中 等价于下面的代码

float a = 2.01f;
double b = 2.01;

printf("a1 : 2.01 * 1000 = %f\n", (double)(a * 1000));

printf("b1 : 2.01 * 1000 = %f\n", b * 1000);

其中 printf float 其实相当于 printf (double) 去处理的. 具体可以看这类源码 

#define parse_float_va_arg(info)                          \
  do                                          \
    {                                          \
      info.is_binary128 = 0;                              \
      if (is_long_double)                              \
    the_arg.pa_long_double = va_arg (ap, long double);              \
      else                                      \
    the_arg.pa_double = va_arg (ap, double);                  \
    }                                          \
  while (0)

其次二者输出打印的数据内容一样. 本质原因是, double 尾数的高23位和float的尾数23位一样.

如果你用 %.8f 可能就不一样了.  

(float : 1 + 8 +23, 小数点后精度 6-7)

(double : 1 + 11 + 52, 小数点后精度 15-16)

简单的, 我们可以用下面代码去验证 

#include <stdio.h>

static void print_byte(unsigned char byte) {
    printf("%d%d%d%d%d%d%d%d"
        , ((byte >> 7) & 1) 
        , ((byte >> 6) & 1)
        , ((byte >> 5) & 1)
        , ((byte >> 4) & 1)
        , ((byte >> 3) & 1)
        , ((byte >> 2) & 1)
        , ((byte >> 1) & 1)
        , ((byte >> 0) & 1)
    );
}

static void print_number(const void * data, size_t n) {
    const unsigned char * bytes = data;

# if __byte_order__ == __order_little_endian__
    for (size_t i = n; i > 0; i--) {
        print_byte(bytes[i-1]);
    }
# else
    for (size_t i = 0; i < n; i++) {
        print_byte(bytes[i]);
    }
# endif
}

static void print_float(float num) {
    printf(" float = ");
    print_number(&num, sizeof num);
    printf("\n");
}

static void print_double(double num) {
    printf("double = ");
    print_number(&num, sizeof num);
    printf("\n");
}

int main(void) {
    float a = 2.01f;
    double b = 2.01;

    print_float(a);
    print_double(b);

    printf(" float 2.01f + %%.%df = %.*f\n",  8, 8, a);
    printf("double 2.01  + %%.%df = %.*lf\n", 8, 8, b);
}

 

在 window 和 ubuntu 得到的测试数据如下 

/*
  float = 01000000000000001010001111010111
 double = 0100000000000000000101000111101011100001010001111010111000010100

 float  2.01f = 0 10000000    00000001010001111010111
 double 2.01  = 0 10000000000 00000001010001111010111 00001010001111010111000010100

  float 2.01f + %.6f = 2.010000
 double 2.01  + %.6f = 2.010000

 float 2.01f + %.7f = 2.0100000
double 2.01  + %.7f = 2.0100000

 float 2.01f + %.8f = 2.00999999
double 2.01  + %.8f = 2.01000000

 float 2.01f + %.10f = 2.0099999905
double 2.01  + %.10f = 2.0100000000

 float 2.01f + %.15f = 2.009999990463257
double 2.01  + %.15f = 2.010000000000000

 float 2.01f + %.16f = 2.0099999904632568
double 2.01  + %.16f = 2.0099999999999998

 float 2.01f + %.17f = 2.00999999046325684
double 2.01  + %.17f = 2.00999999999999979
 */

明显可以看出来 a = 2.01f 和 b = 2.01 在内存中二者是不一样的. 即 a != b, a * 1000 != b * 1000. 有兴趣的可以自行去实验. 

 

问题解答继续

这里说说 a2 和 b2 case 造成的原因.

printf("a2 : int(2.01 * 1000) = %d\n", (int)(a * 1000)); // a2 : int(2.01 * 1000) = 2010

printf("b2 : int(2.01 * 1000) = %d\n", (int)(b * 1000)); // b2 : int(2.01 * 1000) = 2009

 

我们首先获取其内存布局 

 float 2010.0f = 0 10001001    11110110100000000000000
double 2010.0  = 0 10000001001 1111011001111111111111111111111111111111111111111111

 

随后借助场外信息, 引述 <<深入理解计算机系统-第三版>> 部分舍入概念

 误差来自浮点数无法精确表示和转换过程中舍入起的效果. 

 

问题反思

这类问题, 或多或少遇到过, 希望我们这里对这类问题做个了结 ~  

此刻不知道有心人会不会着急下结论,

那以后的业务中还是别用 float 了, 或者直接用 double, 或者定点小数, 或者整数替代 float 等等 ...

这么考虑很不错, 在大多数领域是完全没有问题的. 也是值得推荐的. 

补充下, 也有些领域例如嵌入式, 他们还是会用 float, 因为对他们而言 double 有的时候太浪费内存了,

还存在着地址对齐等问题. 

虽然不同领域(场景)会有不同方式方法,  但有一点需要大家一块遵守, 没有特殊情况别混着用 ~ 

希望以上能帮助朋友们对这类问题知其所以然 ~

 

后记 - 再见, 祝好运 ~

　　错误是难免的, 欢迎交流指正, 当找个乐子 ~ 哈哈哈 ~

 

summer