IEEE 754规则
1 今天有空和大家分享下IEEE 754标准,同时解释下我们所谓的”精度“表达
我会讲的很细,因为我觉得很多人都没有细究,哈哈。
我们先看一个例子,下面是十进制的 -10.25 在内存中的布局,当然这是IEEE754标准
什么是IEEE 754?
任意一个浮点数f可以表示为
f
=
(
−
1
)
s
∗
m
∗
b
e
f = (-1)^s*m*b^e
f=(−1)s∗m∗be。
通过公式和图的对比,可以知道
- s = 1(符号位,为1表示负数,为0表示正数)
- b = 2(基底,一般就是2,当然这里不讨论10进制哈)
- e = 3
- m = 1.100 1 2 m = 1.1001_2 m=1.10012
这个公式只是数学表达,怎么知道内存的布局呢?
2 内存中是如何布局的呢?
首先,必须肯定的几个预备知识
- 32位浮点数的移码E为8位,尾数T为23位,符号S位1位,因此E的取值范围是[0,255]
- 64位浮点数的移码E为11位,尾数T为52位,符号S位1位,因此E的取值范围是[0,2047]
- IEEE 754标准规定,在计算机内部保存尾数m时,默认该数的第一位总是1,这样的二进制浮点数称为规范浮点数(normalized float number),简称规范数。由于规范数的尾数m的第一位总是1,实现时可以舍去,只保存后面的小数部分,因此规范数的尾数m满足0.5≤m<1。(也就是上表的T)
第一步,计算T
从上面知道,
m
=
1.100
1
2
m = 1.1001_2
m=1.10012,取尾数
100
1
2
1001_2
10012,由于32位float的T是23位,需要补19个0
32位
T
=
1001000000000000000000
0
2
T = 10010000000000000000000_2
T=100100000000000000000002
64位double的T是52位,需要补48个0
64位
T
=
100100000000000000000000000000000000000000000000000
0
2
T = 1001000000000000000000000000000000000000000000000000_2
T=10010000000000000000000000000000000000000000000000002
第二步,计算E
需要简单的还算下,IEEE 754的另一个规则
上面提到,32位浮点数的E取值范围是[0,255],这是IEEE 754硬性规定,但是指数上的e是可以是负数的,因此真正的移码E是加上一个偏移的结果。
4. 32位浮点数, E = e + 127, 正如这里的E = 3+127 =130 =
1000001
0
2
10000010_2
100000102
5. 64位浮点数, E = e + 1023, 正如这里的E = 3+1023 =1026=
1000000001
0
2
10000000010_2
100000000102
因此,32位浮点数-10.25内存表示是:
−
10.2
5
10
=
1
S
1000001
0
S
1001000000000000000000
0
T
-10.25_{10} = 1_S10000010_S10010000000000000000000_T
−10.2510=1S10000010S10010000000000000000000T
因此,64位浮点数-10.25内存表示是:
−
10.2
5
10
=
1
S
1000000001
0
S
100100000000000000000000000000000000000000000000000
0
T
-10.25_{10} = 1_S10000000010_S1001000000000000000000000000000000000000000000000000_T
−10.2510=1S10000000010S1001000000000000000000000000000000000000000000000000T
3 验证结论
#include <bits/stdc++.h>
using namespace std;
void toReadable(const string& s)
{
if (s.size() == 32)
{
cout << " S = " << s.substr(0, 1); // 符号位
cout << " E = " << s.substr(1, 8); // E = 8
cout << " T = " << s.substr(9); // T = 23
}
else if (s.size() == 64)
{
cout << " S = " << s.substr(0, 1); // 符号位
cout << " E = " << s.substr(1, 11); // E = 11
cout << " T = " << s.substr(12); // T = 52
}
}
int main(int argc, char *argv[])
{
float f = -12.5;
// 将存储浮点数的四个字节解释为一个无符号整数
unsigned int *ui = (unsigned int *)(&f);
// 将无符号整数表示成二进制形式并输出,该二进制编码即为浮点数在内存中的编码
bitset<32> uis(*ui);
toReadable(uis.to_string()); // 将二进制转成字符串 to_string
cout << endl;
return 0;
}
// Output,和我们预期结果一致
S = 1 E = 10000010 T = 10010000000000000000000
4 一些解释
4.1 疑问1:为什么把32位浮点数转成unsigned int*呢?
答案很简单,因为这和float是32位,而unsigned int: 4B, 0 ~ 4294967295,也就是不管32位浮点数在内存是什么,unsigned int(4B)都能装下。
64位用什么呢?
unsigned long int: 8B, 0 ~ 18446744073709551615,8字节最大值都能装下,还怕谁?
4.2 疑问2:所谓的float有8位有效数字,怎么算的?
根据IEEE 754标准,float数据类型有23位(二进制)尾数,如果保存的是规范数,即小数点的左侧始终为1,那么可以节省1位存储空间,相当于使用23位的存储空间保存24位的尾数
。
我们算一个极限,按照整数算
2
24
−
1
=
16777215
2^{24}-1=16777215
224−1=16777215
数一下,一共有8位,也就是float有效数字是8位,而且是整数+小数,一行要注意这点!!!
举例,下面都是无法准确存取的,就32位为例
- f = 12345678.1,总共位数是9位,计算机内部可能存储为12345678.000000
- f = 1234567.81,总共位数是9位,计算机内部可能存储为1234567.750000(第八位不对)
- f = 1234567.9,总共位数是8位,但是计算机内部可能存储为1234567.875000(第八位不对)
你会发现,不是8位精度吗?为什么第8位不对呢,因为8位在整数下考虑,实际上,32位浮点前7位绝大部分是一样的,第八位整数可以,小数float第八位有偏差。
- f = 123456.1,总共位数是7位,计算机内部可能存储为123456.101562
可以看出,存入7位,在内存中确实保证了前7位不变,后面的是无法保证的哈
最后,给出理论公式
float数据类型的实际表示精度为
l
o
g
10
(
2
24
-
1
)
+
1
≈
8
log_{10}(2^{24}-1)+1≈8
log10(224-1)+1≈8位十进制数
double同理
2
53
−
1
=
9
,
007
,
199
,
254
,
740
,
991
2^{53}-1=9,007,199,254,740,991
253−1=9,007,199,254,740,991 ,也就是16位
double数据类型的实际表示精度为
l
o
g
10
(
2
53
-
1
)
+
1
≈
16
log_{10}(2^{53}-1)+1≈16
log10(253-1)+1≈16位十进制数
4.3 疑问3:所谓的float的小数位数是6位,怎么算的?
当使用float数据类型保存小数时,由于其尾数最大为23位,而 2 − 23 = 0.00000011920928955078125 2^{-23}=0.00000011920928955078125 2−23=0.00000011920928955078125,则对于小于0.0000001的小数部分,float数据类型无法精确表示,因此float数据类型在表示小数时的精度最多为7位
但是,绝大部分机器只能保证6位,因为考虑的最小极限值,实际上还有整数的0,一共7位。
- f = 0.0000011, 一共8位,是一条规则临界状态,第二条规则是小数后6位。计算机内部可能存储为0.000001。最后一个1直接截断
下面是OK的
2. f = 0.123456, 一共7位,小数后6位, 准确存储0.123456
double小数位数
2
−
52
=
2.2204460492503130808472633361816
e
−
16
2^{-52}=2.2204460492503130808472633361816e^{-16}
2−52=2.2204460492503130808472633361816e−16
哈哈,一般都没有考虑double的最小精度问题,实在太小了,但是受16位有效数字限制
举个例,double真的不用担心
3. f = 0.123456789123456789, 计算机内部可能存储为0.12345678912345678380
5 总结
相比double,float计算速度更快,耗用的资源更少,如果对这方面有要求的可以使用32位float,
保守的话,
32位float,最多7位有效数字,6位小数位数,不要挑战极限,因为你会失望的。嘿嘿,double的态度无所谓