How to round a double to n length (not n decimal places)?

Question

I have been trying to find a way to make sure the length of the double "value" is not larger than 10. However, this is becoming difficult to program since I am not rounding it to a certain number of decimal places.

For example, 1234567.8912 and 12.345678912 are both larger than 10 digits however, they will have to be rounded to a different number of decimal places. My logic was to find where the decimal point occurs and rounding the double to "10 - number of digits before the decimal place".

I created two different methods and both methods won't seem to work correctly.

    if ((Double.toString(value)).length()> 10){
        int counter = 0;
        double no_of_dec = 1;
        double no_of_int = 1;
        double new_value = 0;
        for (int i = 0; i< (Double.toString(value)).length(); i++){
            if ( (Character.toString((Double.toString(value)).charAt(i))).equals(".") ){
                counter = 1;
            } if (counter == 1){
                no_of_dec = no_of_dec * 10;
            } else if (counter == 0){
                no_of_int = no_of_int * 10;
            }
        } 
        no_of_dec = no_of_dec / (no_of_int);
        new_value = (double)Math.round(value * 100d/100d);
        return Double.toString(new_value);
    } else {
        return Double.toString(value);
    }


    if ((Double.toString(value)).length()> 10){
        double no_of_dec = 0;
        double no_of_int = 0;
        double new_value = 0;
        for (int i = 0; i< (Double.toString(value)).length(); i++){
            while (!(Character.toString((Double.toString(value)).charAt(i))).equals(".")){
                no_of_int = no_of_int + 1;
            }
        }
        no_of_dec = (Double.toString(value)).length() - no_of_int;
        no_of_dec = no_of_dec * 10;
        new_value = (double)Math.round(value * no_of_dec/no_of_dec);
        return Double.toString(new_value);
    } else {
        return Double.toString(value);
    }
}

Answer 1

I did it this way:

private static BigDecimal getRounded(double n, int totalDigits) {

    String nString = Double.toString(n); // transform to string to make the job easier

    if(nString.contains(".")) {
        int dotPos = nString.indexOf("."); // = number of digits before the decimal point

        int remainingDigits = totalDigits - dotPos; // = remaining digits after the decimal point

        return new BigDecimal(nString).setScale(remainingDigits, BigDecimal.ROUND_HALF_UP); // round
    }

    return new BigDecimal(n);
}

This was my test:

double n = 1234567.8912;
System.out.println(getRounded(n, 10));

n = 12.345678915;
System.out.println(getRounded(n, 10));

And this the result:

1234567.891
12.34567892

Demo: http://ideone.com/my7eB2

Answer 2

BigDecimal has an operation for doing this:

double truncate(double value) {
    BigDecimal b = new BigDecimal(String.valueOf(value));
    b = b.round(new MathContext(10));
    return b.doubleValue();
}

There is a reason for using the BigDecimal(String) constructor and not the BigDecimal(double) constructor. doubles and floats are not base 10 numbers, so they don’t exactly represent the values we see when we print them; the constructor documentation has a good illustration of this. This is not unique to Java and is true in most languages.

Update:

4castle points out that the above won’t work for nonzero numbers with a magnitude less than 1, since BigDecimal doesn’t consider the zero integer part a significant digit. You can work around that:

double truncate(double value) {
    int precision = 10;
    if (value != 0 && Math.abs(value) < 1) {
        precision--;
    }

    BigDecimal b = new BigDecimal(String.valueOf(value));
    b = b.round(new MathContext(precision));
    return b.doubleValue();
}

Update 2:

BackSlash points out that it’s more complex than the above for nonzero numbers between -1 and 1. I’m sure it’s possible to calculate the exact precision needed, but I think it’s simpler to just eliminate the issue by adding 1 for rounding purposes:

double truncate(double value) {
    BigDecimal b = new BigDecimal(String.valueOf(value));

    MathContext context = new MathContext(10);
    if (value > 0 && value < 1) {
        b = b.add(BigDecimal.ONE);
        b = b.round(context);
        b = b.subtract(BigDecimal.ONE);
    } else if (value < 0 && value > -1) {
        b = b.subtract(BigDecimal.ONE);
        b = b.round(context);
        b = b.add(BigDecimal.ONE);
    } else {
        b = b.round(context);
    }

    return b.doubleValue();
}