js,java,浮点数运算错误及应对方法解析

访客 阅读:375 2021-02-04 14:34:30 评论:0

js,java浮点数运算错误及应对方法

一,浮点数为什么会有运算错误

IEEE 754 标准规定了计算机程序设计环境中的二进制和十进制的浮点数自述的交换、算术格式以及方法.

 

现有存储介质都是2进制。2进制的进制基数是2,那么一个数字只要被因素包含大于2的质数的数除,都会产生无限循环小数。无限循环小数和无理数都无法,和非无限循环的有理数一起用同一种方式存储到存储介质上的同时还保持计算的兼容性。
对于无限循环小数,可以设计一种格式存储到介质上,但是同时又要和非无限循环的有理数能够计算,效率应该会变得非常低下。 对于无理数,小数位的数字没有规律可循,所以根本无法保存精确值,只能保存近似值。
高精度计算,一般可以将数字转发成string, 去掉小数点,按位计算再保存回string,再加回小数点。

 

二,错误举例

document.write (0.01 + 0.05);  //输出结果为0.060000000000000005

document.write (0.09 + 0.01);  //输出结果为0.09999999999999999

document.write(11*22.9);     //输出结果为251.89999999999998

 

三,js如何应对

扩大倍数法:有多少位小数就扩大10的n次方

document.write((0.01*100+0.09*100)/100); //输出结果为0.1

四舍五入法:

document.write((0.01+0.09).toFixed(2)); //保留2位小数,输出结果为0.10

document.write(Math.round((0.01+0.09)*100)/100); //输出结果为0.1

 

四,java如何应对

扩大倍数法:有多少位小数就扩大10的n次方

System.out.println((0.01*100+0.09*100)/100); //输出结果为0.1

四舍五入法:

System.out.println(Math.rint(0.01*100+0.09*100)/100); //输出结果为0.1

System.out.println(Math.round(0.01*100+0.09*100)/100); //输出结果为0.1

System.out.println(new  BigDecimal(0.099).setScale(2,  RoundingMode.HALF_UP).doubleValue());  //输出结果为0.10

 


备注: Java支持7中舍入法

1、 ROUND_UP:远离零方向舍入。向绝对值最大的方向舍入,只要舍弃位非0即进位。

2、 ROUND_DOWN:趋向零方向舍入。向绝对值最小的方向输入,所有的位都要舍弃,不存在进位情况。

3、 ROUND_CEILING:向正无穷方向舍入。向正最大方向靠拢。若是正数,舍入行为类似于ROUND_UP,若为负数,舍入行为类似于ROUND_DOWN。Math.round()方法就是使用的此模式。

4、 ROUND_FLOOR:向负无穷方向舍入。向负无穷方向靠拢。若是正数,舍入行为类似于ROUND_DOWN;若为负数,舍入行为类似于ROUND_UP。

5、 HALF_UP:最近数字舍入(5进)。这是我们最经典的四舍五入。

6、 HALF_DOWN:最近数字舍入(5舍)。在这里5是要舍弃的。

7、 HALF_EVEN:银行家舍入法。银行家舍入法.

 

 


附录一: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);  
}  
 
//减法函数,用来得到精确的减法结果  
//说明:javascript的减法结果会有误差,在两个浮点数相加的时候会比较明显。这个函数返回较为精确的减法结果。  
//调用:accSubtr(arg1,arg2)  
//返回值:arg1减去arg2的精确结果  
function accSubtr(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)); 
//动态控制精度长度 
n=(r1>=r2)?r1:r2; 
return ((arg1*m-arg2*m)/m).toFixed(n); 
}  
//给Number类型增加一个subtr 方法,调用起来更加方便。  
Number.prototype.subtr = function (arg){  
return accSubtr(arg,this);  
} 

 

附录二:java工具类Arith

工具类Arith来简化操作。它提供以下静态方法,包括加减乘除和四舍五入: 
public static double add(double v1,double v2) 
public static double sub(double v1,double v2) 
public static double mul(double v1,double v2) 
public static double div(double v1,double v2) 
public static double div(double v1,double v2,int scale) 
public static double round(double v,int scale) 
 
源文件Arith.java: 
import java.math.BigDecimal; 
/** 
 * 由于Java的简单类型不能够精确的对浮点数进行运算,这个工具类提供精 
 * 确的浮点数运算,包括加减乘除和四舍五入。 
 */ 
public class Arith{ 
    //默认除法运算精度 
    private static final int DEF_DIV_SCALE = 10; 
    //这个类不能实例化 
    private Arith(){ 
    } 
  
    /** 
     * 提供精确的加法运算。 
     * @param v1 被加数 
     * @param v2 加数 
     * @return 两个参数的和 
     */ 
    public static double add(double v1,double v2){ 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.add(b2).doubleValue(); 
    } 
    /** 
     * 提供精确的减法运算。 
     * @param v1 被减数 
     * @param v2 减数 
     * @return 两个参数的差 
     */ 
    public static double sub(double v1,double v2){ 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.subtract(b2).doubleValue(); 
    }  
    /** 
     * 提供精确的乘法运算。 
     * @param v1 被乘数 
     * @param v2 乘数 
     * @return 两个参数的积 
     */ 
    public static double mul(double v1,double v2){ 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.multiply(b2).doubleValue(); 
    } 
  
    /** 
     * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到 
     * 小数点以后10位,以后的数字四舍五入。 
     * @param v1 被除数 
     * @param v2 除数 
     * @return 两个参数的商 
     */ 
    public static double div(double v1,double v2){ 
        return div(v1,v2,DEF_DIV_SCALE); 
    } 
  
    /** 
     * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指 
     * 定精度,以后的数字四舍五入。 
     * @param v1 被除数 
     * @param v2 除数 
     * @param scale 表示表示需要精确到小数点以后几位。 
     * @return 两个参数的商 
     */ 
    public static double div(double v1,double v2,int scale){ 
        if(scale<0){ 
            throw new IllegalArgumentException( 
                "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b1 = new BigDecimal(Double.toString(v1)); 
        BigDecimal b2 = new BigDecimal(Double.toString(v2)); 
        return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
  
    /** 
     * 提供精确的小数位四舍五入处理。 
     * @param v 需要四舍五入的数字 
     * @param scale 小数点后保留几位 
     * @return 四舍五入后的结果 
     */ 
    public static double round(double v,int scale){ 
        if(scale<0){ 
            throw new IllegalArgumentException( 
                "The scale must be a positive integer or zero"); 
        } 
        BigDecimal b = new BigDecimal(Double.toString(v)); 
        BigDecimal one = new BigDecimal("1"); 
        return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue(); 
    } 
}; 

 

 

声明

1.本站遵循行业规范,任何转载的稿件都会明确标注作者和来源;2.本站的原创文章,请转载时务必注明文章作者和来源,不尊重原创的行为我们将追究责任;3.作者投稿可能会经我们编辑修改或补充。

发表评论
搜索
排行榜
KIKK导航

KIKK导航

关注我们