import java.math.BigDecimal;

import java.math.BigDecimal;  
 
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();  
   }  
 
    /** 
    * 求给定双精度数组中值的最大值 
    * @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));  
    }  
 
}