Round Double datatype upto 3 digits

Question

I am trying to calculate the value a field which represent Interest rate for that I have to round up the value to 3 digits.

Below is code which I am using :

double bigAmt1 = Double.parseDouble(amount);
            bigAmt = (intsign*bigAmt1)/div;
            
        bigAmt=Math.round(bigAmt*1000d)/1000d;

amount = 4048500
intsign = 1
div = 6

it returns = 4.048 I need it return = 4.049

if I change the value of amount to 4048600 then it return 4.049 so I think it is rounding up values where last digit after division is greater than 5 but It should be if last digit equal or greater than 5 then It should round up to next digit.

Below is my test class --

package test;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.text.DecimalFormat;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println(divideAndConvertToString1("4048100","6","1"));
        //System.out.println("---> 3 places  "+Math.round(3.5));
        //Math.round(3.7)
        /*double value = 12.3457652133;
        value =Double.parseDouble(new DecimalFormat("##.####").format(value));
        System.out.println("---> 3 places  "+value);*/
    }
    
    public static String divideAndConvertToString(String amount, String decml, String sign) {

        double bigAmt = 0.00;
        
        int div = 0;
        
        double d =0;
        
        if (!isStringEmpty(decml)) {
          d = Double.parseDouble(decml);
        }
        
        double d1 = Math.pow(10, d);
        div = (int)d1;              
        
        int intsign = Integer.parseInt(sign);
        
        if (amount != null && !"".equalsIgnoreCase(amount)) {
            //BigDecimal bigAmt1 = new BigDecimal(amount);
            
            double bigAmt1 = Double.parseDouble(amount);
            bigAmt = (intsign*bigAmt1)/div;         
            bigAmt=Math.ceil(bigAmt*1000d)/1000d;
            
            //bigAmt = new BigDecimal((intsign*bigAmt1.doubleValue())/div);
            
            return  String.valueOf(bigAmt);
                        
        }
        else {
            bigAmt = bigAmt;
        }
        System.out.println("inside divideAndConvertToString");
        return String.valueOf(bigAmt);
        
    }
    
    
     public static String divideAndConvertToString1(String amount, String decml, String sign) {

         BigDecimal bigAmt = null;
            
            int div = 0;
            
            double d =0;
            
            if (!Util.isStringEmpty(decml)) {
              d = Double.parseDouble(decml);
            }
            
            double d1 = Math.pow(10, d);
            div = (int)d1;              
            
            int intsign = Integer.parseInt(sign);
            
            if (amount != null && !"".equalsIgnoreCase(amount)) {
                BigDecimal bigAmt1 = new BigDecimal(amount);

                bigAmt = new BigDecimal((intsign*bigAmt1.doubleValue())/div);
            }
            else {
                bigAmt = new BigDecimal("0");
            }
            System.out.println("inside divideAndConvertToString1");

            return String.valueOf(bigAmt.setScale(3, RoundingMode.CEILING));
            
            //System.out.println(b.setScale(0, RoundingMode.CEILING)); 
            
        }
     
     public static boolean isStringEmpty(String input) {
            if (input == null || input.trim().length() == 0 || "".equalsIgnoreCase(input)) {
                return true;
            }
            return false;
        }

}

Answer 1

Math.round should work however I usual do this like this:

bigAmt=Math.floor((bigAmt*1000d)+0.5d)/1000d;

Your problem however lies elsewhere:

bigAmt1 = Double.parseDouble(amount);
bigAmt = (intsign*bigAmt1)/div;
bigAmt=Math.round(bigAmt*1000d)/1000d;

So using your values:

amount = 4048500
intsign = 1
div = 6

bigAmt1 = 4048500;
bigAmt = (1*4048500)/6 = 674750;
bigAmt=   round(674750*1000)/1000 = round(674750000)/1000 = 674750;

However in your example You wrote: it returns = 4.048 I need it return = 4.049 So do you have the same div value? If the div is 1000000 instead then:

bigAmt1 = 4048500;
bigAmt = (1*4048500)/1000000 = 4.048500;
bigAmt=   round(4.048500*1000)/1000 = round(4048.500)/1000 = 4.049;

However there is a big problem because floating point might round your 4.048500 number to something like 4.048499999999. It is safer to use integer rounding directly:

1000* ((amount+500)/1000)
1000* ((4048500+500)/1000)
1000* ((4049000    )/1000)
1000* (4049)
       4049000

So you add half of the rounding value, divide by rounding value and then multiply by rounding value. All done on integers

Answer 2

Why won't you use Math.ceil(), instead of Math.round(), I think that's what it's for.