关于浮点运算

浮点运算是不精确的，对于这个，我最初的印象大致是来自c语言的这个代码

#define EPSILON 0.0000001 //根据精度需要
if(fabs(fa - fb) < EPSILON)
{
    printf("fa<fb\n");
}

那时候也只是会这么机械的去用，但是不清楚原理。而最近在使用浮点数运算的时候也遇到一些坑，就深入的看了一下。

首先是几个测试用例

0.7 + 0.1
81.6 * 100
0.7 - 0.43

用 Python 或者浏览器的 console 计算上面的这几个式子都不会得到正确的结果。
Python是使用双精度浮点数的，一个浮点数占用8个字节，也就是64位。第1 bit 位用来存储符号，决定这个数是正数还是负数，然后使用11 bit 来存储指数部分，剩下的52 bit 用来存储尾数。
浮点数能不能准确的显示和运算主要是和它转换为二进制后的数字位数有关。如果有位数小于64的二进制数，那么它肯定能准确的表示一个数字。相反，如果一个十进制数字需要超过64位的二进制来表示，那么肯定就是不准确的了，因为计算机只会存储64位二进制。比如说0.1的二进制形式其实是0.00011001100110011001100110011001100110011001100110011001100...

怎么算出来的？
十进制转换为二进制的原则是

• 整数部分对 2 取余然后逆序排列
• 小数部分乘 2 取整数部分, 然后顺序排列

2.25 的二进制表示是?
整数部分的二进制表示为 10, 小数部分我们逐步来算
0.25 * 2 = 0.5 整数部分取 0
0.5 * 2 = 1.0 整数部分取 1
所以 2.25 的二进制表示为 10.01

0.1 的表示是什么?
我们继续按照浮点数的二进制表示来计算
0.1 * 2 = 0.2 整数部分取 0
0.2 * 2 = 0.4 整数部分取 0
0.4 * 2 = 0.8 整数部分取 0
0.8 * 2 = 1.6 整数部分取 1
0.6 * 2 = 1.2 整数部分取 1
0.2 * 2 = 0.4 整数部分取 0
…
所以你会发现, 0.1 的二进制表示是 0.00011001100110011001100110011……0011
0011作为二进制小数的循环节不断的进行循环.

在 Python 中如果要进行浮点运算，一般使用 Decimal

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.7')
Decimal('0.8')
>>> Decimal('81.6') * Decimal('100')
Decimal('8160.0')
>>> Decimal('0.7') - Decimal('0.43')
Decimal('0.27')

而前几天在 js 中遇到的就只能自己去特殊处理一下了。

//除法函数，用来得到精确的除法结果
//说明：javascript的除法结果会有误差，在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。
//调用：accDiv(arg1,arg2)
//返回值：arg1除以arg2的精确结果
function accDiv(arg1, arg2) {
    var t1 = 0, t2 = 0, r1, r2;
    try {
        t1 = arg1.toString().split(".")[1].length
    } catch (e) {
    }
    try {
        t2 = arg2.toString().split(".")[1].length
    } catch (e) {
    }
    with (Math) {
        r1 = Number(arg1.toString().replace(".", ""));
        r2 = Number(arg2.toString().replace(".", ""));
        return (r1 / r2) * pow(10, t2 - t1);
    }
}

//给Number类型增加一个div方法，调用起来更加方便。
Number.prototype.div = function (arg) {
    return accDiv(this, arg);
};

//乘法函数，用来得到精确的乘法结果
//说明：javascript的乘法结果会有误差，在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。
//调用：accMul(arg1,arg2)
//返回值：arg1乘以arg2的精确结果
function accMul(arg1, arg2) {
    var m = 0, s1 = arg1.toString(), s2 = arg2.toString();
    try {
        m += s1.split(".")[1].length
    } catch (e) {
    }
    try {
        m += s2.split(".")[1].length
    } catch (e) {
    }
    return Number(s1.replace(".", "")) * Number(s2.replace(".", "")) / Math.pow(10, m);
}

//给Number类型增加一个mul方法，调用起来更加方便。
Number.prototype.mul = function (arg) {
    return accMul(arg, this);
};

//加法函数，用来得到精确的加法结果
//说明：javascript的加法结果会有误差，在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。
//调用：accAdd(arg1,arg2)
//返回值：arg1加上arg2的精确结果
function accAdd(arg1, arg2) {
    var r1, r2, m;
    try {
        r1 = arg1.toString().split(".")[1].length
    } catch (e) {
        r1 = 0
    }
    try {
        r2 = arg2.toString().split(".")[1].length
    } catch (e) {
        r2 = 0
    }
    m = Math.pow(10, Math.max(r1, r2));
    return (arg1 * m + arg2 * m) / m;
}
//给Number类型增加一个add方法，调用起来更加方便。
Number.prototype.add = function (arg) {
    return accAdd(arg, this);
};

//减法函数
function accSub(arg1, arg2) {
    var r1, r2, m, n;
    try {
        r1 = arg1.toString().split(".")[1].length
    } catch (e) {
        r1 = 0
    }
    try {
        r2 = arg2.toString().split(".")[1].length
    } catch (e) {
        r2 = 0
    }
    m = Math.pow(10, Math.max(r1, r2));
    //last modify by deeka
    //动态控制精度长度
    n = (r1 >= r2) ? r1 : r2;
    return ((arg2 * m - arg1 * m) / m).toFixed(n);
}

///给number类增加一个sub方法，调用起来更加方便
Number.prototype.sub = function (arg) {
    return accSub(arg, this);
};

其实还有一个地方没弄明白，就是二进制的加减乘除是怎么运算的，貌似在数字电路里面学过，但是全忘了~明天再看看

参考
http://www.darkof.com/2014/11/23/python-float/
http://www.programering.com/a/MDM3EzNwATE.html

FROM :strcpy.me | Author:strcpy