为什么浮点精度运算会有问题

为什么浮点精度运算会有问题

我们平常使用的编程语言大多都有一个问题——浮点型精度运算会不准确。比如

1.  double num = 0.1 + 0.1 + 0.1;
    
2.  // 输出结果为 0.30000000000000004
    
3.  double num2 = 0.65 - 0.6;
    
4.  // 输出结果为 0.05000000000000004

 

笔者在测试的时候发现 C/C++ 竟然不会出现这种问题，我最初以为是编译器优化，把这个问题解决了。但是 C/C++ 如果能解决其他语言为什么不跟进？根据这个问题的产生原因来看，编译器优化解决这个问题逻辑不通。后来发现是打印的方法有问题，打印输出方法会四舍五入。使用 printf("%0.17fn", num); 以及 cout << setprecision(17) << num2 << endl; 多打印几位小数即可看到精度运算不准确的问题。

那么精度运算不准确这是为什么呢？我们接下来就需要从计算机所有数据的表现形式二进制说起了。如果大家很了解二进制与十进制的相互转换，那么就能轻易的知道精度运算不准确的问题原因是什么了。如果不知道就让我们一起回顾一下十进制与二进制的相互转换流程。一般情况下二进制转为十进制我们所使用的是按权相加法。十进制转二进制是除2取余，逆序排列法。很熟的同学可以略过。

1.  // 二进制到十进制
    
2.  10010 = 0 * 2^0 + 1 * 2^1 + 0 * 2^2 + 0 * 2^3 + 1 * 2^4 = 18  
    

4.  // 十进制到二进制
    
5.  18 / 2 = 9 .... 0 
    
6.  9 / 2 = 4 .... 1 
    
7.  4 / 2 = 2 .... 0 
    
8.  2 / 2 = 1 .... 0 
    
9.  1 / 2 = 0 .... 1
    

11.  10010

 

那么，问题来了十进制小数和二进制小数是如何相互转换的呢？十进制小数到二进制小数一般是整数部分除 2 取余，逆序排列，小数部分使用乘 2 取整数位，顺序排列。二进制小数到十进制小数还是使用按权相加法。

1.  // 二进制到十进制
    
2.  10.01 = 1 * 2^-2 + 0 * 2^-1 + 0 * 2^0 + 1 * 2^1 = 2.25
    

4.  // 十进制到二进制
    
5.  // 整数部分
    
6.  2 / 2 = 1 .... 0
    
7.  1 / 2 = 0 .... 1
    
8.  // 小数部分
    
9.  0.25 * 2 = 0.5 .... 0 
    
10.  0.5 * 2 = 1 .... 1 
    

12.  // 结果 10.01

 

转小数我们也了解了，接下来我们回归正题，为什么浮点运算会有精度不准确的问题。接下来我们看一个简单的例子 2.1 这个十进制数转成二进制是什么样子的。

1.  2.1 分成两部分
    
2.  // 整数部分
    
3.  2 / 2 = 1 .... 0
    
4.  1 / 2 = 0 .... 1
    

6.  // 小数部分
    
7.  0.1 * 2 = 0.2 .... 0
    
8.  0.2 * 2 = 0.4 .... 0
    
9.  0.4 * 2 = 0.8 .... 0
    
10.  0.8 * 2 = 1.6 .... 1
    
11.  0.6 * 2 = 1.2 .... 1
    
12.  0.2 * 2 = 0.4 .... 0
    
13.  0.4 * 2 = 0.8 .... 0
    
14.  0.8 * 2 = 1.6 .... 1
    
15.  0.6 * 2 = 1.2 .... 1
    
16.  0.2 * 2 = 0.4 .... 0
    
17.  0.4 * 2 = 0.8 .... 0
    
18.  0.8 * 2 = 1.6 .... 1
    
19.  0.6 * 2 = 1.2 .... 1
    
20.  ............

 

落入无限循环结果为 10.0001100110011........ ， 我们的计算机在存储小数时肯定是有长度限制的，所以会进行截取部分小数进行存储，从而导致计算机存储的数值只能是个大概的值，而不是精确的值。从这里看出来我们的计算机根本就无法使用二进制来精确的表示 2.1 这个十进制数字的值，连表示都无法精确表示出来，计算肯定是会出现问题的。

精度运算丢失的解决办法

现有有三种办法

1. 如果业务不是必须非常精确的要求可以采取四舍五入的方法来忽略这个问题。
2. 转成整型再进行计算。
3. 使用 BCD 码存储和运算二进制小数(感兴趣的同学可自行搜索学习)。

一般每种语言都用高精度运算的解决方法（比一般运算耗费性能），比如 Python 的 decimal 模块，Java 的 BigDecimal，但是一定要把小数转成字符串传入构造，不然还是有坑，其他语言大家可以自行寻找一下。

1.  # Python 示例
    
2.  from decimal import Decimal
    

4.  num = Decimal('0.1') + Decimal('0.1') + Decimal('0.1')
    
5.  print(num)
    



1.  // Java 示例
    
2.  import java.math.BigDecimal;
    

4.  BigDecimal add = new BigDecimal("0.1").add(new BigDecimal("0.1")).add(new BigDecimal("0.1"));
    
5.  System.out.println(add);

拓展：详解浮点型

上面既然提到了浮点型的存储是有限制，那么我们看一下我们的计算机是如何存储浮点型的，是不是真的正如我们上面提到的有小数长度的限制。
那我们就以 Float 的数据存储结构来说，根据 IEEE 标准浮点型分为符号位，指数位和尾数位三部分（各部分大小详情见下图）。

IEEE 754 标准

一般情况下我们表示一个很大或很小的数通常使用科学记数法，例如：1000.00001 我们一般表示为 1.00000001 10^3，或者 0.0001001 一般表示为 1.001 10^-4。

符号位

0 是正数，1 是负数

指数位

指数很有意思因为它需要表示正负，所以人们创造了一个叫 EXCESS 的系统。这个系统是什么意思呢？它规定 最大值 / 2 - 1 表示指数为 0。我们使用单精度浮点型举个例子，单精度浮点型指数位一共有八位，表示的十进制数最大就是 255。那么 255 / 2 - 1 = 127，127 就代表指数为 0。如果指数位存储的十进制数据为 128 那么指数就是 128 - 127 = 1，如果存储的为 126，那么指数就是 126 - 127 = -1。

尾数位

比如上述例子中 1.00000001 以及 1.001 就属于尾数，但是为什么叫尾数呢？因为在二进制中比如 1.xx 这个小数，小数点前面的 1 是永远存在的，存了也是浪费空间不如多存一位小数，所以尾数位只会存储小数部分。也就是上述例子中的 00000001 以及 001 存储这样的数据。

IEEE 754 标准

通过上述程序我们得到的存储 1.25 的 float 二进制结构的具体值为 00111111101000000000000000000000 ，我们拆分一下 0 为符号位他是个正值。01111111 为指数位，01000000000000000000000 是尾数。接下来我们验证一下 01111111 转为十进制是 127，那么经过计算指数为 0。尾数是 01000000000000000000000 加上默认省略的 1 为 1.01（省略后面多余的 0），转换为十进制小数就是 1.25。