Java和Js的高精度计算

网上找的Java和Js的高精度计算文件，很有用。贴出来希望有人能搜到。在此特向代码原作者致敬！！！

Java:
[java] view plain copy

    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(); 
        } 
    } 


Js:
[javascript] view plain copy

    //除法函数，用来得到精确的除法结果  
    //说明：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);  
    } 
     
    //在你要用的地方包含这些函数，然后调用它来计算就可以了。  
    //比如你要计算：7*0.8 ，则改成 (7).mul(8)  
    //其它运算类似，就可以得到比较精确的结果。 
     
     
     
    //减法函数 
    function Subtr(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 ((arg1*m-arg2*m)/m).toFixed(n); 
    }