zoukankan      html  css  js  c++  java
  • 解决浮点数问题

    1. https://github.com/iriscouch/bigdecimal.js  解决浮点数的网址后端前端通用
    2. http://developer.51cto.com/art/201512/499429.htm 
    3. 十进制       二进制 
    4. 0.1              0.0001 1001 1001 1001 … 
    5. 0.2              0.0011 0011 0011 0011 … 
    6. 0.3              0.0100 1100 1100 1100 … 
    7. 0.4              0.0110 0110 0110 0110 … 
    8. 0.5              0.1 
    9. 0.6              0.1001 1001 1001 1001 … 

    所以比如 1.1,其程序实际上无法真正的表示 ‘1.1′,而只能做到一定程度上的准确,这是无法避免的精度丢失:1.09999999999999999

    在JavaScript中问题还要复杂些,这里只给一些在Chrome中测试数据:

    1. console.log(1.0-0.9 == 0.1)    //false 
    2. console.log(1.0-0.8 == 0.2)    //false 
    3. console.log(1.0-0.7 == 0.3)    //false 
    4. console.log(1.0-0.6 == 0.4)    //true 
    5. console.log(1.0-0.5 == 0.5)    //true 
    6. console.log(1.0-0.4 == 0.6)    //true 
    7. console.log(1.0-0.3 == 0.7)    //true 
    8. console.log(1.0-0.2 == 0.8)    //true 
    9. console.log(1.0-0.1 == 0.9)    //true 

    那如何来避免这类 1.0-0.9 != 0.1 的非bug型问题发生呢?下面给出一种目前用的比较多的解决方案, 在判断浮点运算结果前对计算结果进行精度缩小,因为在精度缩小的过程总会自动四舍五入:

    1. (1.0-0.9).toFixed(digits)  // toFixed() 精度参数digits须在0与20之间 
    2. console.log(parseFloat((1.0-0.9).toFixed(10)) === 0.1)   //true 
    3. console.log(parseFloat((1.0-0.8).toFixed(10)) === 0.2)    //true 
    4. console.log(parseFloat((1.0-0.7).toFixed(10)) === 0.3)    //true 
    5. console.log(parseFloat((11.0-11.8).toFixed(10)) === -0.8)   //true 

    写成一个方法:

    1. //通过isEqual工具方法判断数值是否相等 
    2. function isEqual(number1, number2, digits){ 
    3.   digits = digits == undefined? 10: digits; // 默认精度为10 
    4.   return number1.toFixed(digits) === number2.toFixed(digits); 
    5. console.log(isEqual(1.0-0.7, 0.3));  //true 
    6. //原型扩展方式,更喜欢面向对象的风格 
    7. Number.prototype.isEqual = function(number, digits){ 
    8.   digits = digits == undefined? 10: digits; // 默认精度为10 
    9.   return this.toFixed(digits) === number.toFixed(digits); 
    10. console.log((1.0-0.7).isEqual(0.3)); //true 

    接下来,再来试试浮点数的运算,

    1. console.log(1.79+0.12)  //1.9100000000000001 
    2. console.log(2.01-0.12)   //1.8899999999999997 
    3. console.log(1.01*1.3)    //1.3130000000000002 
    4. console.log(0.69/10)     //0.06899999999999999 

    解决方案:

    1. //加法函数,用来得到精确的加法结果 
    2. //说明:javascript的加法结果会有误差,在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。 
    3. //调用:accAdd(arg1,arg2) 
    4. //返回值:arg1加上arg2的精确结果 
    5. function accAdd(arg1,arg2){ 
    6.   var r1,r2,m; 
    7.   try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0} 
    8.   try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0} 
    9.   m=Math.pow(10,Math.max(r1,r2)) 
    10.   return (arg1*m+arg2*m)/m 
    11. //给Number类型增加一个add方法,调用起来更加方便。 
    12. Number.prototype.add = function (arg){ 
    13.   return accAdd(arg,this); 
    14.  
    15. //减法函数,用来得到精确的减法结果 
    16. //说明:javascript的加法结果会有误差,在两个浮点数相加的时候会比较明显。这个函数返回较为精确的减法结果。 
    17. //调用:accSub(arg1,arg2) 
    18. //返回值:arg1减去arg2的精确结果 
    19. function accSub(arg1,arg2){ 
    20.   var r1,r2,m,n; 
    21.   try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0} 
    22.   try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0} 
    23.   m=Math.pow(10,Math.max(r1,r2)); 
    24.   //last modify by deeka 
    25.   //动态控制精度长度 
    26.   n=(r1>=r2)?r1:r2; 
    27.   return ((arg1*m-arg2*m)/m).toFixed(n); 
    1. //除法函数,用来得到精确的除法结果 
    2. //说明:javascript的除法结果会有误差,在两个浮点数相除的时候会比较明显。这个函数返回较为精确的除法结果。 
    3. //调用:accDiv(arg1,arg2) 
    4. //返回值:arg1除以arg2的精确结果 
    5. function accDiv(arg1,arg2){ 
    6.   var t1=0,t2=0,r1,r2; 
    7.   try{t1=arg1.toString().split(".")[1].length}catch(e){} 
    8.   try{t2=arg2.toString().split(".")[1].length}catch(e){} 
    9.   with(Math){ 
    10.     r1=Number(arg1.toString().replace(".","")) 
    11.     r2=Number(arg2.toString().replace(".","")) 
    12.     return (r1/r2)*pow(10,t2-t1); 
    13.   } 
    14. //给Number类型增加一个div方法,调用起来更加方便。 
    15. Number.prototype.div = function (arg){ 
    16.   return accDiv(this, arg); 
    17.  
    18. //乘法函数,用来得到精确的乘法结果 
    19. //说明:javascript的乘法结果会有误差,在两个浮点数相乘的时候会比较明显。这个函数返回较为精确的乘法结果。 
    20. //调用:accMul(arg1,arg2) 
    21. //返回值:arg1乘以arg2的精确结果 
    22. function accMul(arg1,arg2) { 
    23.   var m=0,s1=arg1.toString(),s2=arg2.toString(); 
    24.   try{m+=s1.split(".")[1].length}catch(e){} 
    25.   try{m+=s2.split(".")[1].length}catch(e){} 
    26.   return  Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m) 
    27. //给Number类型增加一个mul方法,调用起来更加方便。 
    28. Number.prototype.mul = function (arg){ 
    29.   return accMul(arg, this); 
    30. <br>//验证一下: 
    31. console.log(accAdd(1.79, 0.12));  //1.91 
    32. console.log(accSub(2.01, 0.12));  //1.89 
    33. console.log(accDiv(0.69, 10));    //0.069<br>console.log(accMul(1.01, 1.3));   //1.313
  • 相关阅读:
    Security and Cryptography in Python
    Security and Cryptography in Python
    Security and Cryptography in Python
    Security and Cryptography in Python
    Security and Cryptography in Python
    Security and Cryptography in Python
    基于分布式锁解决定时任务重复问题
    基于Redis的Setnx实现分布式锁
    基于数据库悲观锁的分布式锁
    使用锁解决电商中的超卖
  • 原文地址:https://www.cnblogs.com/chaoyuehedy/p/6052287.html
Copyright © 2011-2022 走看看