Develop Reference

How to set the precision for double return type method

Below is the double return type function and i would like to get the answer with precision of 2 zeros. My current answer is coming out to be -4.5. Whereas i want it to be -4.50. Any kind of help will be really appreciated
public double getAmount(){
double ftotal = car.hello();
return Math.round(ftotal * 100)/100.0d;
}

The returned value is a Double so you can't pad 0s to a Double.
So you must format the returned value to create a string, like:
NumberFormat formatter = new DecimalFormat("#0.00");
String number = formatter.format(getTotal());
System.out.println(number);

Refer below code -
import java.text.DecimalFormat;
public class Decimal2{
private static DecimalFormat df2 = new DecimalFormat(".##");
public static void main(String[] args) {
double input = 62.123454;
System.out.println("double : " + df2.format(input));
}
}

How do I convert decimal 75.95 to 7595 in Java?

I have a program in which i need to convert double 75.95 to normal integer 7595. How do I write the actual program?
My code is:
class test5 {
public static void main(String args[]) {
double d = 75.95;
System.out.println("Price before converting = "+d);
int i = (int)d;
System.out.println("(float)d = "+i);
}
}

Any particular reason why multiplying by 100 wouldn't work?
class test5 {
public static void main(String args[]) {
double d = 75.95;
System.out.println("Price before converting = "+d);
long i = Math.round(d * 100);
System.out.println("(float)d = "+i);
}
}
You have to be careful with rounding errors. See: Losing precision converting from int to double in java

Now my code is this and its working :) thanks all of you :)
class test5
{
public static void main(String args[])
{
double d = 75.95;
{
System.out.println("Price before converting = "+d);
int i = (int)(d*100);
System.out.println("Answer after converting = "+i);
}
}
}

You can multiply by a constant 100 (if there are only, and always two decimal points). If there are more, you could use String.valueOf(double) and remove the '.' and call a double a double (not a float). Something like
double d = 75.95;
// int val = (int) (d * 100); // <-- or this.
String str = String.valueOf(d).replace(".", "");
int val = Integer.valueOf(str);
System.out.printf("(double)%f = (int)%d%n", d, val);
Which outputs
(double)75.950000 = (int)7595

Best way for shifting an double value to BigInteger value with Java

Is there a proper way for converting a double value to a BigInteger value and later back? In the best case without loosing data. The problem is, that I don't know how many decimal places the double values have. But I need this conversion for an Algorithm which only works with non decimal values. After the Algorithm finishes I have to convert it back.
An easy example what I need: for example the sum of 2 double values but the "sum" function works only with BigInteger.

You can do it in 5 steps:
double d1 = 0.1; //your original double
BigDecimal bd1 = new BigDecimal(d1); //convert to BigDecimal
BigInteger bi = bd1.unscaledValue(); //convert to BigInteger
//here do your stuff with the BigInteger
BigDecimal bd2 = new BigDecimal(bi, bd1.scale()); //back to BigDecimal, applying scale
double d2 = bd2.doubleValue(); //convert to double
Full example applied to a sum method
Output:
0.1 + 0.1 = 0.2
0.1 + 10.1 = 10.2
0.1245 + 17.0 = 17.1245
Code:
public static void main(String[] args) {
test(0.1, 0.1);
test(0.1, 10.1);
test(0.1245, 17);
}
private static void test(double d1, double d2) {
System.out.println(d1 + " + " + d2 + " = " + sum(d1, d2));
}
private static double sum(double d1, double d2) {
BigDecimal bd1 = new BigDecimal(d1);
BigDecimal bd2 = new BigDecimal(d2);
int shift = Integer.max(bd1.scale(), bd2.scale());
BigInteger bi1 = bd1.scaleByPowerOfTen(shift).toBigInteger();
BigInteger bi2 = bd2.scaleByPowerOfTen(shift).toBigInteger();
BigInteger sum = sum(bi1, bi2);
return new BigDecimal(sum, shift).doubleValue();
}
private static BigInteger sum(BigInteger i1, BigInteger i2) {
return i1.add(i2);
}

This program is based on the BigDecimal-and-scale idea, as in assylias's answer, but modified to unconditionally use the maximum possible required scale. This allows the same scale to be used across a stream of numbers, without seeing all the numbers before processing any of them. The cost is that it will usually return unnecessarily large BigInteger values.
The scale factor, "1e1074", is based on the observation that all finite double numbers are integer multiples of Double.MIN_VALUE, which has 1074 decimal digits after the decimal point. No double can have more decimal digits after the decimal point.
import java.math.BigDecimal;
import java.math.BigInteger;
public class Test {
public static void main(String[] args) {
testit(Double.MIN_VALUE);
testit(Double.MAX_VALUE);
testit(0);
testit(1.0);
testit(Math.E);
testit(Math.PI);
}
private static void testit(double d) {
double roundTrip = scaledIntegerToDouble(doubleToScaledInteger(d));
if (d != roundTrip) {
System.out.println("ERROR: " + d + " " + roundTrip);
}
}
public static final BigDecimal scale = new BigDecimal("1e1074");
public static BigInteger doubleToScaledInteger(double d) {
BigDecimal bd = new BigDecimal(d).multiply(scale);
return bd.toBigIntegerExact();
}
public static double scaledIntegerToDouble(BigInteger bi) {
BigDecimal bd = new BigDecimal(bi).divide(scale);
return bd.doubleValue();
}
}

package test;
import java.math.*;
public class HelloWorld{
public static BigInteger sumBigInteger(BigInteger n1,BigInteger n2){
return n1.add(n2);
}
public static double sumDouble(double n1,double n2){
int scale=1;
int max = Math.max(((""+n1).split("\\."))[1].length(), ((""+n2).split("\\."))[1].length());
for (int i=0;i<max;i++) scale*=10;
BigInteger nbr1 = new BigDecimal(n1*scale).toBigInteger();
BigInteger nbr2 = new BigDecimal(n2*scale).toBigInteger();
return (sumBigInteger(nbr1,nbr2).doubleValue() / scale);
}
public static void main(String []args){
double n1=117.22 , n2=56.945;
System.out.println(n1+" + "+n2+" = "+sumDouble(n1,n2));
}
}
Output:
117.22 + 56.945 = 174.165

Converting decimal to fraction

I have a method that is converting a decimal (double value) into a fraction and putting the numerator and denominator values into an int[] of size 2.
Testing it works out fine for most values except when I hit 0.0001. Then the return value is 1.0/1.0.
The method:
private static int[] toFractionPos(double x){
String[] parts = Double.toString(x).split("\\.");
double den = Math.pow(10, parts[1].length()); //denominator
double num = Double.parseDouble(parts[0]) * den + Double.parseDouble(parts[1]); //numerator
return reduceFraction((int)num, (int)den);
}
reduceFraction() method:
public static int[] reduceFraction(int num, int den){
int gcf = GCF(num, den); //greatest common factor
int[] rf = {num/gcf, den/gcf};
return rf;
}
Thanks!

The algorithm seems fine. However, using double is not suitable for this kind of problem, because precision decreases as the scale grows.
You should use BigDecimal and BigInteger instead. I've roughly modified your example so that it works with them, but I haven't taken care of details, i.e. parsing the String shouldn't be necessary since scale can be retrieved from a BigDecimal with a getter, you can configure different rounding modes, etc:
import java.math.BigDecimal;
import java.math.BigInteger;
public class Sample {
static int[] toFractionPos(BigDecimal x) {
String[] parts = x.toString().split("\\.");
BigDecimal den = BigDecimal.TEN.pow(parts[1].length()); // denominator
BigDecimal num = (new BigDecimal(parts[0]).multiply(den)).add(new BigDecimal(parts[1])); // numerator
return reduceFraction(num.intValue(), den.intValue());
}
static int[] reduceFraction(int num, int den) {
int gcd = BigInteger.valueOf(num).gcd(BigInteger.valueOf(den)).intValue(); // greatest
// common
// divisor
int[] rf = { num / gcd, den / gcd };
return rf;
}
public static void main(String[] args) {
int[] fraction = toFractionPos(new BigDecimal("0.0001"));
System.out.println(fraction[0] + "/" + fraction[1]); // 1/10000
}
}
Note: optimizations left as an excercise ;)

You shouldn't work with doubles as you are losing precision and this can lead to serious errors. But in the case of 1.0001 the problem is that:
Double.toString(1.0001) == "1.0E-4"
Then you try to parse "0E-4" and you get 0 instead of 1. You could do the following if you expect at most 10 decimal points:
DecimalFormat df = new DecimalFormat("0",
DecimalFormatSymbols.getInstance(Locale.ENGLISH));
df.setMaximumFractionDigits(10);
String[] parts = df.format(x).split("\\.");

How about this?
private static int[] toFractionPos(double x){
int den = (int)Math.pow(10,(int)Math.log10(Integer.MAX_VALUE));
int num = (int)(x*den);
return reduceFraction(num, den);//this came from your code
}

I think this will work,
public int[] Fraction(double n) {
BigDecimal p = BigDecimal.ONE;
BigDecimal dn = BigDecimal.valueOf(n);
while(true){
dn = dn.multiply(p);
if( dn.compareTo(new BigDecimal(dn.toBigInteger()))==0 )
break;
else
p = p.multiply(BigDecimal.TEN);
}
BigInteger num=dn.toBigInteger(), den=p.toBigInteger(), g=num.gcd(den);
num = num.divide(g);
den = den.divide(g);
int[] res = new int[2];
res[0] = num.intValue();
res[0] = den.intValue();
return res;
}

Converting a price string into an integer

I need to convert prices into integers, like such:
(String) 12,000 to (int) 12000
245.00 to (int) 245
How can I do this?

Use NumberFormat.getCurrencyInstance():
NumberFormat nf = NumberFormat.getCurrencyInstance(); // Use Locale?
int[] ints = new int[strings.length];
for(int i = 0 ; i < strings.length ; ++i) {
ints[i] = nf.parse(strings[i]).intValue();
}

Much shorter than the other solutions:
public static int parseStringToInt(String s){
s = s.replaceAll(",", ""); //remove commas
return (int)Math.round(Double.parseDouble(s)); //return rounded double cast to int
}
Use it like so:
public static void main(String[] args) {
String[] m = {"12,000", "245.67"};
for (String s : m){
System.out.println(parseStringToInt(s));
}
}

public static int convertDoubleToInt(double d){
//rounds off to the nearest 100
long l = Math.round(d);
int i = (int) l;
return i;
}
public static double convertCommaDoubleToInt(String s) throws ParseException{
NumberFormat nf = NumberFormat.getInstance(Locale.US);
Number number = nf.parse(s);
return number.doubleValue();
}
public static void main(String[] args) throws ParseException {
String[] moneys = {"12,000", "245.76"};
for(String n: moneys){
Double d = convertCommaDoubleToInt(n);//first remove the comma, if there
System.out.println(convertDoubleToInt(d)); //then convert double into int
}
}