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

}