保持最大精度水平

Question

我正在研究业务逻辑，我需要对BigDecimal变量进行除法和乘法以产生业务结果，但是我面临着保持准确性的问题。

实际的业务我不能放在这里，所以我创建了一个示例程序并包含在此处。我只需要使用BigDecimal，所以我对此非常严格，但是我愿意使用任何比例尺，模式或任何有助于我获得最大精度的东西。

总是欢迎提出建议。

样例代码

public class Test {
    public static void main(String[] args) {
        BigDecimal hoursInADay = new BigDecimal("24");
        BigDecimal fraction = BigDecimal.ONE.divide(hoursInADay, 3,
                RoundingMode.HALF_UP);
        BigDecimal count = BigDecimal.ZERO;

        for (int i = 1; i <= 24; i++) {
            count = count.add(fraction);
        }

        if (BigDecimal.ONE.equals(count)) {
            // accuracy level 100%
        }
    }
}

Answer 1

只是一个实验（并且为了好玩），我尝试实现这个Fraction类，它包装BigDecimal但避免除法，直到需要最终结果。

该方法的实现基于：

• 添加：a/b + c/d = (ad + bc)/bd
• 乘：(a/b) * (c/d) = ac/bd
• 划分：(a/b)/(c/d) = ad/bc

不使用它是因为BigDecimal精度不够，但因为过早除法在非终止值的情况下必然会导致舍入错误。

代码：

class Fraction {

    private final BigDecimal numerator;
    private final BigDecimal denominator;

    public Fraction(BigDecimal numerator, BigDecimal denumerator) {
        this.numerator = numerator;
        this.denominator = denumerator;
    }

    public static final Fraction ZERO = new Fraction(BigDecimal.ZERO, 
                            BigDecimal.ONE);
    public static final Fraction ONE = new Fraction(BigDecimal.ONE, 
                            BigDecimal.ONE);

    public static Fraction of(BigDecimal numerator) {
        return new Fraction(numerator, BigDecimal.ONE);
    }

    public static Fraction of(BigDecimal numerator, BigDecimal denominator) {
        return new Fraction(numerator, denominator);
    }

    public Fraction add(Fraction other) {
        return Fraction.of(other.denominator.multiply(this.numerator)
                                .add(other.numerator.multiply(this.denominator)),
                           this.denominator.multiply(other.denominator));
    }

    public Fraction multiply(Fraction other) {
        return new Fraction(this.numerator.multiply(other.numerator), 
                            this.denominator.multiply(other.denominator));
    }

    public Fraction divide(Fraction other) {
        return new Fraction(this.numerator.multiply(other.denominator), 
                            this.denominator.multiply(other.numerator));
    }

    public BigDecimal value() {
        try {
            return this.numerator.divide(this.denominator);
        } catch (ArithmeticException ae) {
            return this.numerator.divide(this.denominator, 6, 
                        RoundingMode.HALF_UP);
        }
    }

    @Override
    public String toString() {
        return String.format("%s/%s", this.numerator, this.denominator);
    }
}

并用它来执行您的原始计算：

public static void main(String[] args) {
    Fraction twentyFour = Fraction.of(BigDecimal.valueOf(24));
    Fraction fraction = Fraction.ONE.divide(twentyFour);
    System.out.println("Fraction = " + fraction);

    Fraction count = new Fraction(BigDecimal.ZERO, BigDecimal.ONE);
    for (int i = 1; i <= 24; i++) {
        count = count.add(fraction);
    }

    if (BigDecimal.ONE.equals(count.value())) {
        System.out.println("100%");
    } else {
        System.out.println(count);
    }
}

输出：

Fraction = 1/24
100%

值得注意的是，这根本没有经过优化。例如，分数没有被简化（1/24 + 1/24将被存储为48/576而不是1/12，并且可能具有不可忽略的存储和计算成本）