chr0mzie - 3 months ago 11

Java Question

I would like some advice from people who have more experience working with primitive

`double`

`d1 == d2`

`d1`

`d2`

My questions are:

- Is Java's handling rounding errors to some degree? As explained in the 1.7 documentation it returns value
`Double.compare(d1,d2) == 0`

if`0`

is numerically equal to`d1`

. Is anyone certain what exactly they mean by numerically equal?`d2`

- Using relative error calculation against some delta value, is there a generic (not application specific) value of delta you would recommend? Please see example below.

Below is a generic function for checking equality considering relative error. What value of

`delta`

`public static boolean isEqual(double d1, double d2) {`

return d1 == d2 || isRelativelyEqual(d1,d2);

}

private static boolean isRelativelyEqual(double d1, double d2) {

return delta > Math.abs(d1- d2) / Math.max(Math.abs(d1), Math.abs(d2));

}

Answer

You could experiment with delta values in the order of 10^{-15} but you will notice that some calculations give a larger rounding error. Furthermore, the more operations you make the larger will be the accumulated rounding error.

One particularly bad case is if you subtract two almost equal numbers, for example 1.0000000001 - 1.0 and compare the result to 0.0000000001

So there is little hope to find a generic method that would be applicable in all situations. You always have to calculate the accuracy you can expect in a certain application and then consider results equal if they are closer than this accuracy.

For example the output of

```
public class Main {
public static double delta(double d1, double d2) {
return Math.abs(d1- d2) / Math.max(Math.abs(d1), Math.abs(d2));
}
public static void main(String[] args) {
System.out.println(delta(0.1*0.1, 0.01));
System.out.println(delta(1.0000000001 - 1.0, 0.0000000001));
}
}
```

is

```
1.7347234759768068E-16
8.274036411668976E-8
```

Interval arithmetic can be used to keep track of the accumulated rounding errors. However in practise the error intervals come out too pessimistic, because sometimes rounding errors also cancel each other.

Source (Stackoverflow)

Comments