For this code block:

```
int num = 5;
int denom = 7;
double d = num / denom;
```

the value of `d`

is `0.0`

. It can be forced to work by casting:

```
double d = ((double) num) / denom;
```

But is there another way to get the correct `double`

result? I don't like casting primitives, who knows what may happen.

## Solution 1

```
double num = 5;
```

That avoids a cast. But you'll find that the cast conversions are well-defined. You don't have to guess, just check the JLS. int to double is a widening conversion. From §5.1.2:

Widening primitive conversions do not lose information about the overall magnitude of a numeric value.

[...]

Conversion of an int or a long value to float, or of a long value to double, may result in loss of precision-that is, the result may lose some of the least significant bits of the value. In this case, the resulting floating-point value will be a correctly rounded version of the integer value, using IEEE 754 round-to-nearest mode (§4.2.4).

5 can be expressed exactly as a double.

## Solution 2

What's wrong with casting primitives?

If you don't want to cast for some reason, you could do

```
double d = num * 1.0 / denom;
```

## Solution 3

I don't like casting primitives, who knows what may happen.

Why do you have an irrational fear of casting primitives? Nothing bad will happen when you cast an `int`

to a `double`

. If you're just not sure of how it works, look it up in the Java Language Specification. Casting an `int`

to `double`

is a widening primitive conversion.

You can get rid of the extra pair of parentheses by casting the denominator instead of the numerator:

```
double d = num / (double) denom;
```

## Solution 4

If you change the type of one the variables you have to remember to sneak in a double again if your formula changes, because if this variable stops being part of the calculation the result is messed up. I make a habit of casting within the calculation, and add a comment next to it.

```
double d = 5 / (double) 20; //cast to double, to do floating point calculations
```

Note that casting the result won't do it

```
double d = (double)(5 / 20); //produces 0.0
```

## Solution 5

# Type Casting Is The Only Way

May be you will not do it explicitly but it will happen.

Now, there are several ways we can try to get precise `double`

value (where `num`

and `denom`

are `int`

type, and of-course *with casting*)-

- with explicit casting:

`double d = (double) num / denom;`

`double d = ((double) num) / denom;`

`double d = num / (double) denom;`

`double d = (double) num / (double) denom;`

but not `double d = (double) (num / denom);`

- with implicit casting:

`double d = num * 1.0 / denom;`

`double d = num / 1d / denom;`

`double d = ( num + 0.0 ) / denom;`

`double d = num; d /= denom;`

but not `double d = num / denom * 1.0;`

and not `double d = 0.0 + ( num / denom );`

Now if you are asking- Which one is **better**? explicit? or implicit?

Well, lets not follow a straight answer here. Simply remember- We programmers don't like surprises or magics in a source. And we really hate Easter Eggs.

Also, an extra operation will definitely not make your code more efficient. Right?

## Solution 6

Cast one of the integers/both of the integer to float to force the operation to be done with floating point Math. Otherwise integer Math is always preferred. So:

```
1. double d = (double)5 / 20;
2. double v = (double)5 / (double) 20;
3. double v = 5 / (double) 20;
```

Note that casting the result won't do it. Because first division is done as per precedence rule.

```
double d = (double)(5 / 20); //produces 0.0
```

I do not think there is any problem with casting as such you are thinking about.

## Solution 7

use something like:

```
double step = 1d / 5;
```

(1d is a cast to double)

## Solution 8

Best way to do this is

```
int i = 3;
Double d = i * 1.0;
d is 3.0 now.
```

## Solution 9

You might consider wrapping the operations. For example:

```
class Utils
{
public static double divide(int num, int denom) {
return ((double) num) / denom;
}
}
```

This allows you to look up (just once) whether the cast does exactly what you want. This method could also be subject to tests, to ensure that it continues to do what you want. It also doesn't matter what trick you use to cause the division (you could use any of the answers here), as long as it results in the correct result. Anywhere you need to divide two integers, you can now just call `Utils::divide`

and trust that it does the right thing.

## Solution 10

just use this.

```
int fxd=1;
double percent= (double)(fxd*40)/100;
```

## Solution 11

Just add "D".

```
int i = 6;
double d = i / 2D; // This will divide bei double.
System.out.println(d); // This will print a double. = 3D
```