精确计算工具类，提供加减乘除的计算

package com.ljq.util;

import java.math.BigDecimal;

/**
 * 精确计算工具类，提供加减乘除的计算
 *
 * @author jqlin
 */
public class CompuUtils {
    /**小数点后保留的位数*/
    public final static int SCALE = 5;
    /** 0 */
    public final static int ZERO = 0;

    
    /**
     * BigDecimal大小比较
     * 
     * @param a
     * @param b
     * @return 返回1， 表示a大于b <br/> 
     *                  返回0 ，表示a等于b <br/> 
     *         返回-1，表示a小于b
     * @author jqlin
     */
    public static int compareTo(BigDecimal a, BigDecimal b){
        return a.compareTo(b);
    }

    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal add(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.add(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal add(BigDecimal a, BigDecimal b) {
        return  add(a, b, SCALE);
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double add(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return add(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 加法运算 
     * 
     * @param a 被加数
     * @param b 加数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double add(double a, double b) {
        return add(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal subtract(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.subtract(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal subtract(BigDecimal a, BigDecimal b) {
        return subtract(a, b, SCALE);
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double subtract(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return subtract(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 减法运算 
     * 
     * @param a 被减数
     * @param b 减数
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double subtract(double a, double b) {
        return subtract(new BigDecimal(a), new BigDecimal(b), SCALE).doubleValue();
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal multiply(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        return a.multiply(b).setScale(scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal multiply(BigDecimal a, BigDecimal b) {
        return multiply(a, b, SCALE); 
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @param scale 小数点后保留几位, 默认保留5位小数点
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double multiply(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return multiply(new BigDecimal(a), new BigDecimal(b), scale).doubleValue();
    }
    
    /**
     * 乘法运算 
     * 
     * @param a 被乘数
     * @param b 乘数
     * @return 四舍五入后的结果 
     * @author jqlin
     */
    public static double multiply(double a, double b) {
        return multiply(a, b, SCALE); 
    }
    
    
    /**
     * 除法运算 
     * 
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal divide(BigDecimal a, BigDecimal b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return a.divide(b, scale, BigDecimal.ROUND_HALF_UP);
    }
    
    /**
     * 除法运算，默认保留5位小数点
     * 
     * @param a 被除数
     * @param b 除数
     * @return    四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal divide(BigDecimal a, BigDecimal b) {
        return divide(a, b, SCALE);
    }
    
    /**
     * 除法运算 
     * 
     * @param a 被除数
     * @param b 除数
     * @param scale 保留小数点后多少位, 默认保留5位小数点
     * @return  四舍五入后的结果 
     * @author jqlin
     */
    public static BigDecimal divide(double a, double b, int scale) {
        if(scale < 0){
            scale = SCALE;
        }
        
        return divide(new BigDecimal(a), new BigDecimal(b), scale);
    }
    
    /**
     * 除法运算，默认保留5位小数点
     * 
     * @param a 被除数
     * @param b 除数
     * @return    四舍五入后的结果 
     * @author jqlin
     */
    public static double divide(double a, double b) {
        return divide(a, b, SCALE).doubleValue();
    }
  
}