对BigDecimal常用方法的归类

忘记了谁总结的 见谅。

import java.math.BigDecimal;

public class Arith {

/**
* 由于Java的简单类型不能够精确的对浮点数进行运算，这个工具类提供精
* 确的浮点数运算，包括加减乘除和四舍五入。
*/
//默认除法运算精度
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();  
   }  
 
    /** 
    * 求给定双精度数组中值的最大值 
    * @param inputData 输入数据数组 
    * @return 运算结果,如果输入值不合法，返回为-1 
    */ 
    public static double getMax(double[] inputData) {  
        if (inputData == null || inputData.length == 0)  
            return -1;  
        int len = inputData.length;  
        double max = inputData[0];  
        for (int i = 0; i < len; i++) {  
            if (max < inputData[i])  
                max = inputData[i];  
        }  
        return max;  
    }  
      
    /** 
    * 求求给定双精度数组中值的最小值 
    * @param inputData 输入数据数组 
    * @return 运算结果,如果输入值不合法，返回为-1 
    */ 
    public static double getMin(double[] inputData) {  
        if (inputData == null || inputData.length == 0)  
            return -1;  
        int len = inputData.length;  
        double min = inputData[0];  
        for (int i = 0; i < len; i++) {  
            if (min > inputData[i])  
                min = inputData[i];  
        }  
        return min;  
    }  
      
    /** 
    * 求给定双精度数组中值的和 
    * @param inputData 输入数据数组 
    * @return 运算结果 
    */ 
    public static double getSum(double[] inputData) {  
        if (inputData == null || inputData.length == 0)  
        return -1;  
        int len = inputData.length;  
        double sum = 0;  
        for (int i = 0; i < len; i++) {  
            sum = Arith.add(sum, inputData[i]);  
        }     
        return sum;   
    }
  /** 
   * 求给定双精度数组中值的数目 
   * @param input Data 输入数据数组 
   * @return 运算结果 
   */ 
   public static int getCount(double[] inputData) {  
       if (inputData == null)  
           return -1;  
       return inputData.length;  
    }  
      
    /** 
    * 求给定双精度数组中值的平均值 
    * @param inputData  输入数据数组 
    * @return 运算结果 
    */ 
    public static double getAverage(double[] inputData) {  
        if (inputData == null || inputData.length == 0)  
            return -1;  
        int len = inputData.length;  
        double result;  
        result = Arith.div(getSum(inputData),len, 3);  
        return result;  
    }  
      
    /** 
    * 求给定双精度数组中值的平方和 
    * @param inputData 输入数据数组 
    * @return 运算结果 
    */ 
    public static double getSquareSum(double[] inputData) {  
        if(inputData==null||inputData.length==0)  
            return -1;  
        int len=inputData.length;  
        double sqrsum = 0.0;  
        for (int i = 0; i <len; i++) {  
            sqrsum = Arith.add(sqrsum, Arith.mul(inputData[i], inputData[i]));   
        }  
        return sqrsum;  
    }  
      
    /** 
    * 求给定双精度数组中值的方差 
    * @param inputData 输入数据数组 
    * @return 运算结果 
    */ 
    public static double getVariance(double[] inputData) {  
        int count = getCount(inputData);  
        double sqrsum = getSquareSum(inputData);  
        double average = getAverage(inputData);  
        double result;  
        result = Arith.div(Arith.sub(sqrsum, Arith.mul(count, Arith.mul(average, average))), count, 5);  
        return result;   
    }  
      
    /** 
    * 求给定双精度数组中值的标准差 
    *  
    * @param inputData 输入数据数组 
    * @param scale     保留小数点位数 
    * @return 运算结果 
    */ 
    public static double getStandardDiviation(double[] inputData,int scale) {  
        double result;  
        //绝对值化很重要  
        result = Math.sqrt(Math.abs(getVariance(inputData)));  
        result = Arith.round(result, scale);  
        return result;  
    }  
      
    public static void main(String[] args){  
        double [] testData=new double[]{1,2,3,4,5,6,7,8,10};  
        System.out.println(Arith.getStandardDiviation(testData,3));  
    }