How to solve this rounding requirement?

Question

I have the following requirement to round amounts:

1.2448 -> 1.25
3.349  -> 3.35
0.474  -> 0.47

I have tried all the possible modes of the BigDecimal.setScale(2, RoundingMode.) method, without any success. Here is the result:

UP:        1.25,  3.35,  0.48
HALF_UP:   1.24,  3.35,  0.47
CEILING:   1.25,  3.35,  0.48
FLOOR:     1.24,  3.34,  0.47
DOWN:      1.24,  3.34,  0.47
HALF_DOWN: 1.24,  3.35,  0.47
HALF_EVEN: 1.24,  3.35,  0.47

I have also tried to use BigDecimal.round(), with not good result neither.

How can I round the amounts in the required way ?

Edit:

Why do I actually need to round in this seemingly bizarre way?

In a new software we are developing, we need to reproduce the rounding behavior or a legacy software (which is the way business wants rounding to be done)

Solution:

I absolutely want to stay with BigDecimals for all my calculations.

So, at the end I came up with this simple function to do the "progressive" rounding:

public static BigDecimal roundAmount(BigDecimal amount) {
    for (int i = amount.scale(); i >= 2; i--) {
        amount = amount.setScale(i, RoundingMode.HALF_UP);
    }
    return amount;
}

First example looks weird (esp. with third), what exactly do you need? — zch, Jan 14 '13 at 16:12
Are you sure about the 2nd row? Seems to me either the first value is not what you show or the rounding does not happen this way — Ivaylo Strandjev, Jan 14 '13 at 16:13
`1.2448 -> 1.25`: This makes no sense. Why would you want an asymmetrical rounding interval? — Mattias Buelens, Jan 14 '13 at 16:13
What will be the result in your case for 1.24448? Will it be 1.25 as well? — Swapnil, Jan 14 '13 at 16:15
What exactly are your rounding requirements? Your examples leave room for ambiguity. — Aaron Kurtzhals, Jan 14 '13 at 16:16
If the number is positive, add 0.0005 before applying the rounding. If it's negative, subtract 0.0005 before rounding. Then apply whichever rounding method you want, which isn't entirely clear (probably HALF_UP or HALF_DOWN). — David Duncan, Jan 14 '13 at 16:21

score 6 · Answer 1 · answered Jan 14 '13 at 16:12

Use HALF_UP but first round to three decimal places and then again to 2. The problem is that your desired rounding shows inconsistent logic, since 1.2448 is less than 1.245, so it would normally round down. But rounding first to 3 places will make it 1.245, which will then round to 1.25.

Peter Lawrey · Accepted Answer · 2013-01-14T16:38:30.677

What you are trying to do is round each digit progressively. 1.2448 -> 1.245 -> 1.25.

This means the smallest number needed to round up is .nn4444444444444445 which is close to adding 1/2 - 4/9 after scaling which is 1/18.

Whenever I have seen someone suggest this it has been incorrect, but it is easy to calculate.

for (double d : new double[]{1.2448, 3.349, 0.474}) {
    double rounded = Math.round(d * 1e2 + 1.0 / 18) / 1e2;
    System.out.printf("%s should be %.2f rounded half up and is %s%n", d, d, rounded);
}

prints

1.2448 should be 1.24 rounded half up and is 1.25
3.349 should be 3.35 rounded half up and is 3.35
0.474 should be 0.47 rounded half up and is 0.47

As you can see, the need to add 1/18th is an odd number but that is what you are effectively doing when you round each digit up progressively.

@guess_me I should have calculated the difference instead of guessing. ;) — Peter Lawrey, Jan 14 '13 at 16:38

score 1 · Answer 3 · edited May 23 '17 at 12:34

From here and there:

public static double iterativeRound(double d, int scale) {
    int currentScale = new BigDecimal(String.valueOf(d)).scale();
    while (currentScale >= scale) {
        double i = Math.pow(10, currentScale--);
        d = Math.round(d * i) / i;
    }
    return d;
}

For example:

System.out.println(iterativeRound(1.2448, 2));
System.out.println(iterativeRound(3.349, 2));
System.out.println(iterativeRound(0.474, 2));

Prints:

1.25
3.35
0.47

Achintya Jha · Answer 4 · 2013-01-14T16:53:28.330

0

public static void main(String[] args) {
    double a = 0.474;

    NumberFormat df = DecimalFormat.getInstance();
    df.setMinimumFractionDigits(2);
    df.setMaximumFractionDigits(3);
    df.setRoundingMode(RoundingMode.HALF_UP);

    double b = Double.valueOf(df.format(a));
    NumberFormat dff = DecimalFormat.getInstance();
    dff.setMaximumFractionDigits(2);
    dff.setRoundingMode(RoundingMode.HALF_UP);

    System.out.println(dff.format(b));

}

Try this.

edited Jan 14 '13 at 16:53

answered Jan 14 '13 at 16:20

Achintya Jha

12,735
2
27
39

1

`0.474` gives `0.48` whereas he wants `0.47`. – sp00m Jan 14 '13 at 16:39

How to solve this rounding requirement?

4 Answers4