Need clarification regarding decimalPlacesRounding

[Andre601]

I would like to have a bit of clarification regarding a specific method.

In Precision, Scale and Rounding do the docs show an example using decimalPlacesRounding.
However, the text before the code block mentions automatic scaling, so my mind imediatally assumes the section after it is about scaling and not decimal points...

Am I right to assume that this assumption is wrong and that decimalPlacesRounding actually sets the decimal points of a number to display?

[uklimaschewski]

The scale of a BigDecimal is the number of decimal digits. So this is the same, isn't it?

[Andre601]

Idk... Docs refer to scale as the whole number... Like that a scale of 6 is for both 123.456 and 1234.56...
That's why I'm a bit confused here.
But from my testing is the method what I need to use here.

[uklimaschewski]

No, that is the precision. 123.456 and 1234.56 have both a precision of 6 and a scale of 3, resp. 2.

[Andre601]

I'm back with an issue that I think may be related to this entire thing.

A user reported to me that math equations 261*0.9 and 261*1.1 return 234.9 and 287.1 respectively when applying a decimalPlacesRounding of 1, which by my own checks should be right. However, the value returned for a precision of 0 is 261 in both cases.

I cannot say why exactly this is happening. All I do is create a new ExpressionConfiguration with the Builder and give it a MathContex(68, mode) (mode being a RoundingMode) and the decimalPlacesRounding value mentioned earlier.

For full context, the Code I'm using:

public String getResult(String expression, int scale, String roundingMode){
    RoundingMode mode = createRoundingMode(roundingMode);
    
    ExpressionConfiguration config = ExpressionConfiguration.builder()
        .mathContext(new MathContext(68, mode) // 68 is default precision (not scale) according to EvalEx docs
        .decimalPlacesRounding(scale)
        .build();
    
    try{
        return new Expression(expression, config).evaluate().getStringValue();
    }catch(EvaluationException | ParseException ex){
        System.out.println("Encountered issue while parsing expression " + expression);
        ex.printStackTrace();
        
        return null;
    }
 }

// I have this because input for rounding mode can't have underscores in my use-case.
private RoundingMode createRoundingMode(String roundingMode){
    return switch(roundingMode.toLowerCase(Locale.ROOT)){
        case "up" -> RoundingMode.UP;
        case "down" -> RoundingMode.DOWN;
        case "ceiling" -> RoundingMode.CEILING;
        case "floor" -> RoundingMode.FLOOR;
        case "half-down" -> RoundingMode.HALF_DOWN;
        case "half-even" -> RoundingMode.HALF_EVEN;
        default -> RoundingMode.HALF_UP;
    };
}

[uklimaschewski]

When using a scale of 0, you have no decimal places.
So, when passing 0.9 and 1.1, both will be rounded to one.
This happens even before the multiplication is done, so the result is 261 (261*1) in both cases.
(Assuming a rounding mode like HALF_EVEN or similar).

[Andre601]

Why does it do that?
For me does it make no sense that parts of the equation are rounded too. If I provide 1.1, I want it to be multiplied by that.
So how can I only round the final result to the decimal points?

[uklimaschewski]

If you want to only round the final result, you should not configure the decimalPlacesRounding. Round the resulting number yourself, using the standard BigDecimal methods.
The decimalPlacesRounding is meant exactly for the purpose of rounding all intermediate results and values.
This is important for e.g. financial sums of fractions. If you do not round each intermediate result or value, the resulting summary of values might differ from the summary of rounded values.
Look at an invoice of three positions: 1.103 + 2.002 + 3.583. Results in 6.688.
If you round this at the end, your printed invoice might print: 1.10 + 2.00 + 3.58 = 6.69.