Java Rounding to 15 decimal place

Question

I have the below codes round the forward rate to 15 decimal place. When _ForwardRate is 13,555.0, the result return is wrong.

public double round(double Number, int Decimal_Place) {     
    if (Number==0) return 0;
    double _plug = 0.000001;
    if (Number < 0) {
        _plug = -0.000001;
    }
    //Sometime a number is rounded down to 2.22499999999 by java. 
    //Actual precision is 2.245.  Without this plug, a 2 dp rounding result
    //in 2.22 when it should be 2.23
    double _newNumber = Number;
    if (Decimal_Place==2) {
        _newNumber = _newNumber+_plug;      
    }

    double _number_abs = Math.abs(_newNumber);  
    double _factor = Math.pow(10, Decimal_Place);
    double _rd = Math.round(_number_abs * _factor);
    double _r = _rd/_factor;
    if (Number <= 0)
        _r = _r * -1;

    return _r;
}

Double _ForwardRate = getForward_rate();
BigDecimal _fwdrate_bd = BigDecimal.valueOf(_ForwardRate.doubleValue());
_ForwardRate = round(new Double(_fwdrate_bd.doubleValue()), 15);

Current result

9,223.372036854777

Expected result

13,555.000000000000000

Something other than the rounding is wrong if you are expecting `13,555` compared to `9,223` — OneCricketeer, Sep 19 '16 at 04:50
And, by the way, underscores aren't really encouraged in variable names in Java — OneCricketeer, Sep 19 '16 at 04:51
I'd recommend following naming conventions for Java, such as camelCase and no underscores. — Andrew Li, Sep 19 '16 at 04:52
@AndrewL. Ok. Thanks for the reminder I will do that. :) Any idea of the cause of getting this unexpected result? — bittersour, Sep 19 '16 at 04:54
I'd like to say you are seeing this problem, based on the code comment. http://stackoverflow.com/questions/588004/is-floating-point-math-broken — OneCricketeer, Sep 19 '16 at 04:54
This is all wrong. Please study [What Every Computer Scientist Should Know About Floating-Point Arithmetic](https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html) — Jim Garrison, Sep 19 '16 at 05:04
Can you explain exactly why you believe the result should be what you think it should be? — Joe C, Sep 19 '16 at 05:12

Andreas · Accepted Answer · 2016-09-19T05:25:46.493

Your problem is that Math.round(double a) returns long, and you're overflowing.

One easy way to do this, is to use BigDecimal:

public static double round(double number, int decimalPlaces) {
    return BigDecimal.valueOf(number)
                     .setScale(decimalPlaces, RoundingMode.HALF_UP)
                     .doubleValue();
}

This allows you to control the rounding mode. Note that the rounding done by Math.round() is a HALF_CEILING which isn't supported by setScale().

You might want to consider doing all you math using BigDecimal, if you need that level of precision.

score 0 · Answer 2 · answered Sep 19 '16 at 05:15

Consider:

    double _number_abs = Math.abs(_newNumber);

At this point, _number_abs contains the value 13555.0

    double _factor = Math.pow(10, Decimal_Place);

Now _factor contains 1.0E15

    double _rd = Math.round(_number_abs * _factor);

According to the Javadoc

Math.round() Returns the closest long to the argument, with ties rounding to positive infinity.

Since _number_abs * _factor is 1.3555E19, which is larger than Long.MAX_VALUE, the result is Long.MAX_VALUE, i.e. the "closest" Long to the given value.

Java Rounding to 15 decimal place

2 Answers2