32位浮点数

作者: 闪电的蓝熊猫 | 来源:发表于2019-10-10 11:29 被阅读0次

PHP浮点数精度问题
Python 入门演示
6-0. 混合类型数据格式化输入
3_浮点数的秘密
python中的数据类型和变量
Python基础知识点拾遗
1.2 浮点型运算
浮点数原理与精度损失问题
JavaScript 中的数字 Number 易于忽略点
高级综合工具StratusHLS学习笔记(4)

浮点数的计算方式
$float = (-1)^s*2^{(e-127)}*1.m$

其中s是符号位，e是指数位，m是有效数位组成的数。
m的计算方式是
$m = 1*2^{-1}+0 * 2^{-2}+1*2^{-3}+0*2^{-4}+...+0*2^{-23}=0.625$

所以上图表示的数字就是
$value = (-1)^{0}*2^{129-127}*1.625=6.5$

采用这种表示方式的结果是，两个浮点数之间的“间隔”是均匀的。
什么意思？
比如说，我想表示浮点数1的话，那么我的二进制位就是：
0 01111111 00000000000000000000000
我想表示2的话，二进制位就是
0 10000000 0000000000000000000000
1和2之间，我能表示的数是有限的，比1大的浮点数，最小的值我只能取到
0 01111111 00000000000000000000001
也就是上述的m是2的-23次方，这就是浮点数的“精度”！于是，你可以看到c++标准库中有一个这个函数：

std::numeric_limits<float>::epsilon()

这个值就是2的-23次方！

还有一点，很明显，用上面的式子，我们没法把值精确地表示0，这显然是无法接受的。于是浮点标准就对e=0的情况做了额外的规定，也就是说当e等于0的时候浮点值就不是乘以1.m，而是乘以0.m。也就是说，如果有效值m是0的话，那么浮点值表示的数字就是0，没有歧义！

接着，如果1.m的1没有的话，我们能表示的最小的值就是0.000...1(2进制)*2^{(-126)，也就是2}(-126) * 2^(-23)，大约是1.4012985 * 10 ^ (-45)。

我用下面的代码尝试做了输出：

    std::cout.precision(15);
    
    uint8_t array[4] = {0};
    array[3] = 0x3F; array[2] = 0x80;
    float* f = reinterpret_cast<float*>(array);
    std::cout << "f = " << *f <<std::endl;
    
    uint8_t array1[4] = {0};
    array1[3] = 0x3F; array1[2] = 0x80; array1[0] = 0x1;
    float* f1 = reinterpret_cast<float*>(array1);
    std::cout << "f1 = " << *f1 << std::endl;
    
    uint8_t array2[4] = {0};
    array2[2] = 0x7F; array2[1] = 0xFF; array2[0] = 0xFF;
    float* f2 = reinterpret_cast<float*>(array2);
    std::cout << "f2 = " << *f2 << std::endl;
    
    uint8_t array3[4] = {0};
    array3[0] = 0x1;
    float* f3 = reinterpret_cast<float*>(array3);
    std::cout << "f3 = " << *f3 << std::endl;

结果是：

与预想的一致。

最后，IEEE 754标准保证-0.0严格等于0.0！

如果e等于255，这种情况同样会被特殊处理。e=255，m=0的话，这就表示无限大，用cout输出就是inf。但如果e=255，m!=0的话，那么这就是一个无效值，输出的结果是nan，尝试代码和结果如下：

    uint8_t array4[4] = {0};
    array4[3] = 0x7F; array4[2] = 0x80;
    float* f4 = reinterpret_cast<float*>(array4);
    std::cout << "f4 = " << *f4 << std::endl;
    
    uint8_t array5[4] = {0};
    array5[3] = 0x7F; array5[2] = 0x80; array5[0] = 0x3F;
    float* f5 = reinterpret_cast<float*>(array5);
    std::cout << "f5 = " << *f5 << std::endl;

于是，我们能表示的最大有效值是1.1111111(二进制）* 2 ^ 127，也就是3.402823... * 10^38。测试代码和结果如下：

    uint8_t array6[4] = {0};
    array6[3] = 0x7F; array6[2] = 0x7F; array6[1] = 0xFF; array6[0] = 0xFF;
    float* f6 = reinterpret_cast<float*>(array6);
    std::cout << "f6 = " << *f6 << std::endl;