Comparing floating point values


Java Floating Point Operations

Floating-point numbers are numbers that have fractional parts (usually expressed with a decimal point). In Java, there is two primitive types for floating-point numbers which are float (uses 4 bytes), and double (uses 8 bytes). This documentation page is for detailing with examples operations that can be done on floating points in Java.


Comparing floating point values

You should be careful when comparing floating-point values (float or double) using relational operators: ==, !=, < and so on. These operators give results according to the binary representations of the floating point values. For example:

public class CompareTest {
	public static void main(String[] args) {
		double oneThird = 1.0 / 3.0;
		double one = oneThird * 3;
		System.out.println(one == 1.0); // prints "false"
	}
}

The calculation oneThird has introduced a tiny rounding error, and when we multiply oneThird by 3 we get a result that is slightly different to 1.0.

This problem of inexact representations is more stark when we attempt to mix double and float in calculations. For example:

public class CompareTest2 {
	public static void main(String[] args) {
		float floatVal = 0.1f;
		double doubleVal = 0.1;
		double doubleValCopy = floatVal;
		System.out.println(floatVal); // 0.1
		System.out.println(doubleVal); // 0.1
		System.out.println(doubleValCopy); // 0.10000000149011612
 
		System.out.println(floatVal == doubleVal); // false
		System.out.println(doubleVal == doubleValCopy); // false
	}
}

The floating point representations used in Java for the float and double types have limited number of digits of precision. For the float type, the precision is 23 binary digits or about 8 decimal digits. For the double type, it is 52 bits or about 15 decimal digits. On top of that, some arithmetical operations will introduce rounding errors. Therefore, when a program compares floating point values, it standard practice to define an acceptable delta for the comparison. If the difference between the two numbers is less than the delta, they are deemed to be equal. For example

if (Math.abs(v1 - v2) < delta)

Delta compare example:

public class DeltaCompareExample {
	private static boolean deltaCompare(double v1, double v2, double delta) {
		// return true iff the difference between v1 and v2 is less than delta
		return Math.abs(v1 - v2) < delta;
	}
 
	public static void main(String[] args) {
		double[] doubles = {1.0, 1.0001, 1.0000001, 1.000000001, 1.0000000000001};
		double[] deltas = {0.01, 0.00001, 0.0000001, 0.0000000001, 0};
 
		// loop through all of deltas initialized above
		for (int j = 0; j < deltas.length; j++) {
			double delta = deltas[j];
			System.out.println("delta: " + delta);
 
			// loop through all of the doubles initialized above
			for (int i = 0; i < doubles.length - 1; i++) {
				double d1 = doubles[i];
				double d2 = doubles[i + 1];
				boolean result = deltaCompare(d1, d2, delta);
 
				System.out.println("" + d1 + " == " + d2 + " ? " + result);
 
			}
			System.out.println();
		}
	}
}

Result:

delta: 0.01
1.0 == 1.0001 ? true
1.0001 == 1.0000001 ? true
1.0000001 == 1.000000001 ? true
1.000000001 == 1.0000000000001 ? true
 
delta: 1.0E-5
1.0 == 1.0001 ? false
1.0001 == 1.0000001 ? false
1.0000001 == 1.000000001 ? true
1.000000001 == 1.0000000000001 ? true
 
delta: 1.0E-7
1.0 == 1.0001 ? false
1.0001 == 1.0000001 ? false
1.0000001 == 1.000000001 ? true
1.000000001 == 1.0000000000001 ? true
 
delta: 1.0E-10
1.0 == 1.0001 ? false
1.0001 == 1.0000001 ? false
1.0000001 == 1.000000001 ? false
1.000000001 == 1.0000000000001 ? false
 
delta: 0.0
1.0 == 1.0001 ? false
1.0001 == 1.0000001 ? false
1.0000001 == 1.000000001 ? false
1.000000001 == 1.0000000000001 ? false

Also for comparison of double and float primitive types static compare method of corresponding boxing type can be used. For example:

double a = 1.0;
double b = 1.0001;
 
System.out.println(Double.compare(a, b));//-1
System.out.println(Double.compare(b, a));//1

Finally, determining what deltas are most appropriate for a comparison can be tricky. A commonly used approach is to pick delta values that are our intuition says are about right. However, if you know scale and (true) accuracy of the input values, and the calculations performed, it may be possible to come up with mathematically sound bounds on the accuracy of the results, and hence for the deltas. (There is a formal branch of Mathematics known as Numerical Analysis that used to be taught to computational scientists that covered this kind of analysis.)

Basic Programs