float_浮点数存储结构

Posted 2023-05-16

参考技术A 进入正题：✨

        基本数据类型三要素：数据宽带，存储方式，作用范围。其中，float、double的浮点数数存储结构，分为两种情况。

        第一种：实数+小数（例如：9.25）;

        第二种：纯小数部分（0.25）;

        浮点数：根据IEEE存储规范  32bit  浮点数如下格式

        0      00000000      00000000000000000000000

        1bit_符号位     8bit_指数部分    23bit_尾数部分

                1）9.25    转成二进制：

                                A. 实数部分：9 : [ 1 0 0 1 ]

                                B. 小数部分转成二进制：

                                    0.25 *  2  =  0.5  --->  0

                                    0.5  *  2  =  1.0  --->  1

                                    从上往下合并：0.25 [ 0 1 ]  (注意：乘到小数是零为止，如果乘不到1.0就循环保留从上到下)

                                C.  9.25 : [ 1 0 0 1 . 0 1 ] 

                2)  1 0 0 1 . 0 1  用科学计算法表示：1 . 0 0 1 0 1  *  2^3  (将小数点移到最高有效位，向左移为3，向右移为-3)

                                A.    符号位：0 （是正数）

                                B.    尾数部分：0 0  1 0 1

                                C.    指数部分：3

                                方法一：（需要加上127，然后再转换成二进制：127+3=130，130转二进制为 [ 1 0 0 0 0 0 1 0 ] ）;

                                方法二：用3 - 1 = 2  [ 0 0 1 0 ] ，因为小数点向左，故8bit_最高位为1，即1 0 0 0 0 0 1 0  (指数部分) ;                                       

                3)  填充浮点数数IEEE存储格式：

                      根据上面的科学计算法表示后，将存储格式中需要的对应部分，对号入座

                      0    00000000   00000000000000000000000

                      0    10000010   00101000000000000000000

                      1bit_符号位          8bit_指数部分      23bit_尾数部分

                                                                            （ 尾数00101的后面全补0）

                      合并： 0100  0001  0001  0100  0000  0000  0000  0000

                      十六进制表示：0x 41140000

                即：9.25在计算机的IEEE存储为0x41140000，其中，尾数部分23bit可以看出，float可以精确到小数点后6位。

                1）0.25  转成二进制为：

                                0.25    *    2    =    0.5    --->    0

                                  0.5    *    2    =    1.0    --->    1

                                从上往下合并：0.25 [ 0 1 ]

                2）用科学计数法表示0 . 0  1 ，将小数点向右移动到最高有效位:  1.0    *    2^-2

                                A.    符号位：0 （是正数）

                                B.    尾数部分：0

                                C.    指数部分：-2 

                                方法一:（需要加上127，然后再转换成二进制：127+(-2)=125，125转二进制为 [ 0x7D=0 1 1 1 1 1 0 1 ] ）

                                方法二: (用-2 - 1 = -3  [ 0xFD = 11111101] ，因为小数点向左，故8bit_最高位为0，即0 1 1 1 1 1 0 1 )

              3)    根据上面的科学计算法表示后，将存储格式中需要的对应部分，对号入座

                     0    00000000   00000000000000000000000

                     0    01111101    00000000000000000000000（ 尾数0的后面全补0）

                     1bit_符号位        8bit_指数部分    23bit_尾数部分

                     合并： 0011  1110  1000  0000  0000  0000  0000 0000

                     十六进制表示：0x 3E800000

                即：0.25在计算机的IEEE存储为0x 3E800000，其中，尾数部分23bit可以看出，float可以精确到小数点后6位。

如 有 不 正 之 处 欢  迎 指 正，相 互 学 习  - - - - -

浮点数float累加误差解决方式总结

首先是float累加产生误差的原因，该部分转自：http://blog.csdn.net/zhrh0096/article/details/38589067

1.  浮点数IEEE 754表示方法

要搞清楚float累加为什么会产生误差，必须先大致理解float在机器里怎么存储的，具体的表示参考[1] 和 [2]， 这里只介绍一下组成

由上图可知(摘在[2])， 浮点数由： 符号位 + 指数位 + 尾数部分， 三部分组成。由于机器中都是由二进制存储的，那么一个10进制的小数如何表示成二进制。例如: 8.25转成二进制为1000.01, 这是因为 1000.01 = 1*2^3 + 0*2^2 + 0*2^1 + 0*2^0 + 0*2^-1 + 2*2^-2 = 1000.01.

（2）float的有效位数是6-7位，这是为什么呢？因为位数部分只有23位，所以最小的精度为1*2^-23 在10^-6和10^-7之间，接近10^-7,[3]中也有解释

那么为什么float累加会产生误差呢，主要原因在于两个浮点数累加的过程。

2. 两个浮点数相加的过程

两浮点数X，Y进行加减运算时，必须按以下几步执行（可参考 [4] 中插图）：
（1）对阶，使两数的小数点位置对齐，小的阶码向大的阶码看齐。
（2）尾数求和，将对阶后的两尾数按定点加减运算规则求和(差)。
（3）规格化，为增加有效数字的位数，提高运算精度，必须将求和(差)后的尾数规格化。
（4）舍入，为提高精度，要考虑尾数右移时丢失的数值位。
（5）判断结果，即判断结果是否溢出。

关键就在与对阶这一步骤，由于float的有效位数只有7位有效数字，如果一个大数和一个小数相加时，会产生很大的误差，因为尾数得截掉好多位。例如：

123 + 0.00023456 = 1.23*10^2 + 0.000002 * 10^2 = 123.0002

那么此时就会产生0.00003456的误差，如果累加多次，则误差就会进一步加大。

 

解决方式有几种，但都不是最佳方式，参考：http://bbs.csdn.net/topics/390549664

3.解决方法

方法一

Kahan summation算法

https://en.wikipedia.org/wiki/Kahan_summation_algorithm

function KahanSum(input)
    var sum = 0.0
    var c = 0.0                 // A running compensation for lost low-order bits.
    for i = 1 to input.length do
        var y = input[i] - c    // So far, so good: c is zero.
        var t = sum + y         // Alas, sum is big, y small, so low-order digits of y are lost.
        c = (t - sum) - y       // (t - sum) cancels the high-order part of y; subtracting y recovers negative (low part of y)
        sum = t                 // Algebraically, c should always be zero. Beware overly-aggressive optimizing compilers!
    next i                      // Next time around, the lost low part will be added to y in a fresh attempt.
    return sum

伪代码如上

解决方法就是把多余的误差部分算出来(c)，再在下一次循环减去这个误差

方法二

int main()
{
float f = 0.1;
float sum = 0;
sum+=add(f,4000000);
cout<<sum<<endl;
return 0;
}
 
float add(float f,int count)
{
    if(count==1)
    return f;
    else
        return add(f,count/2)+add(f,count-count/2);
}

二分法递归计算加法，这样会没有误差，但是函数调用消耗大（尤其是多次）

方法三

使用double，精度更高，但是本来是没有必要用这么高精度的

方法四

ieee浮点数,为了规格化,精度每超过2的整数次幂,精度要下降一位,
你的f是0.1,float位数是23,当sum足够大的时候,会出现 sum+f==sum 的情况,这个是ieee标准,
和C++没关系,事实上编译器应该已经做了浮点精度调整了,你这结果误差算小的了.
避免这种误差的方法就是浮点数,永远不要让一个很大的数去加上一个很小的数.不知你这段代码的目的是

什么,但如果你改成这样,误差会小很多:

float f = 0.1;
float sum = 0;
for( i=0; i<100; i++)
{
int sumEachBig=0;
for(....k<400....)
{
int sumEachSmall=0;
for(....j<100.....)
    sumEachSmall += f;

sumEachBig+=sumEachSmall;

}

sum += sumEachBig;

}

 

来自manzi11的回答。多次用多次循环，小循环的计算结果加上大循环的运算结果 

by wolf96 2017/7/10