当前位置:首页 > 开发 > 编程语言 > 编程 > 正文

BigDecimal的基本运算

发表于: 2012-05-23   作者:beisicao   来源:转载   浏览次数:
摘要: import java.math.BigDecimal;     public class Arith {            // 默认除法运算精度      private  static  final&
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));  
    }  
 
}

BigDecimal的基本运算

  • 0

    开心

    开心

  • 0

    板砖

    板砖

  • 0

    感动

    感动

  • 0

    有用

    有用

  • 0

    疑问

    疑问

  • 0

    难过

    难过

  • 0

    无聊

    无聊

  • 0

    震惊

    震惊

编辑推荐
比较算符 比较1.2^1.1与1.1^1.2的大小。 [>is(1.2^1.1>1.1^1.2); true [>evalb(1.2^1.1>
08-基本运算 本文目录 一、算术运算符 二、赋值运算符 三、自增运算符和自减运算符 四、sizeof 五、
  前言  在数学中,几何向量指具有大小(magnitude)和方向的几何对象,它在线性代数中经由抽象化
一、算术运算符 算术运算符非常地简单,就是小学数学里面的一些加减乘除操作。不过呢,还是有一些语
基本数据类型 int n = 7, m = 2; double d = 7; n = n/m; //3 d /= m; //3.5 n--; //2 int a = 2 * n
Java在java.math包中提供的API类BigDecimal,用来对超过16位有效位的数进行精确的运算。双精度浮点
运算符(operator)是用来检查,改变或合并值的一种特殊符号或短语。例如,加号运算符让两个数字相加(
树型结构的用途很广,其中二叉树尤为重要。 这里列出了几种基本的算法 (1)遍历二叉树。(先序遍历
public class Exerc01{ public static void main(String args[]){ boolean b = true; System.out.pr
原文: Swift语言指南(九)--基本运算符 运算符(operator)是用来检查,改变或合并值的一种特殊符号或短
版权所有 IT知识库 CopyRight © 2009-2015 IT知识库 IT610.com , All Rights Reserved. 京ICP备09083238号