Ytukyg

Due to rounding errors, most floating-point numbers end up being
slightly imprecise.

https://www.floating-point-gui.de/errors/comparison/

public static boolean nearlyEqual(float a, float b, float epsilon) {

        final float absA = Math.abs(a);

        final float absB = Math.abs(b);

        final float diff = Math.abs(a - b);



        if (a == b) { // shortcut, handles infinities

            return true;

        } else if (a == 0 || b == 0 || diff < Float.MIN_NORMAL) {

            // a or b is zero or both are extremely close to it

            // relative error is less meaningful here

            return diff < (epsilon * Float.MIN_NORMAL);

        } else { // use relative error

            return diff / Math.min((absA + absB), Float.MAX_VALUE) < epsilon;

        }

    }

What is the universal standard value for epsilon, if, for instance, I wanted to hardcode it for an API that anyone could use for comparing any values?

There is no universal standard for epsilon because it strongly depends on what you are comparing and for what purpose. Every time you test for near equality of two floating-point numbers you need to consider two things:

• the absolute value of those numbers


• the kind of quantity they represent

For example PI is widely known to be "around 3.14", and that's good enough for most engineering applications but in Mathematics, or in spectral analysis (Astronomy) you need much higher precision.

Even withing the same domain the absolute values of numbers you compare will influence your choice of epsilon. Comparing circumference of Earth in kilometers to 40_000.00 vs distance to the Moon in meters to 384_400_000.00 have completely different tolerance of errors.

public static boolean nearlyEqual(double a, double b) {

    if (a == b) { 

        return true;

    } else if (a == 0 || b == 0) {

        return false;

    } else {

        BigDecimal diff = new BigDecimal("" + a)

                .subtract(new BigDecimal("" + b))

                .abs();

        int exponentA = new Double(Math.log10(Math.abs(a))).intValue();

        int exponentB = new Double(Math.log10(Math.abs(b))).intValue();

        int sigFigsA = getSignificantFigs(a);

        int sigFigsB = getSignificantFigs(b);

        BigDecimal epsilon = new BigDecimal("0.1")

                .scaleByPowerOfTen(Math.min(exponentA, exponentB))

                .scaleByPowerOfTen(-1 * Math.max(sigFigsA, sigFigsB));

        return diff.compareTo(epsilon) < 0;

    }

}



public static int getSignificantFigs(double inputDouble) {

    // remove any exponent

    BigDecimal input = new BigDecimal("" + Math.abs(inputDouble))

            .stripTrailingZeros();

    if (input.scale() < 0) {

        int exponent = new Double(

                Math.log10(Math.abs(inputDouble)))

                .intValue();

        input = input.scaleByPowerOfTen(-1 * exponent);

    }

    return input.precision(); 

}

And some tests:

@Test

public void testDoubleComparisonOnePositiveOneNegative() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    1.234E300D,

                    -1.234E300D

            ), "because one's positive and one's negative");

}



@Test

public void testDoubleComparisonZeroes() {

    Assertions.assertTrue(

            GeneralUtils.nearlyEqual(

                    0D,

                    0.0D

            ), "zeroes");

}



@Test

public void testDoubleComparisonBasicDifferentNumbers() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    2.3450D,

                    2345.0D

            ), "typical numbers");

}



@Test

public void testDoubleComparisonMassivelyDifferentNumbers() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    1.23456789E300D,

                    1.23456789E-300D

            ), "big number vs tiny number");

}



@Test

public void testDoubleComparisonHugePositiveNumbers() {

    Assertions.assertTrue(

            GeneralUtils.nearlyEqual(

                    1.23456789E300D,

                    1.23456789E300D

            ), "big number");

}



@Test

public void testDoubleComparisonHugePositiveNumbers2() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    1.2345678901234E300D,

                    1.2345678901233E300D

            ), "big number");

}



@Test

public void testDoubleComparisonHugePositiveNumbers3() {

    Assertions.assertTrue(

            GeneralUtils.nearlyEqual(

                    Double.MAX_VALUE,

                    Double.MAX_VALUE

            ), "big number equals");

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    Double.MAX_VALUE,

                    Double.MAX_VALUE * 0.1

            ), "big number");

}



@Test

public void testDoubleComparisonHugeNegativeNumbers() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    -1.2345678901234E300D,

                    -1.2345678901233E300D

            ), "big negative numbers");

}



@Test

public void testDoubleComparisonTinyPositiveNumbers() {

    Assertions.assertTrue(

            GeneralUtils.nearlyEqual(

                    1.23456789012345E-300D,

                    1.23456789012345E-300D

            ), "tiny number");

}



@Test

public void testDoubleComparisonTinyNegativeNumbers() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    1.23456789012345E-300D,

                    1.23456789012344E-300D

            ), "tiny number");

}



@Test

public void testDoubleComparisonTinyTinyNumbers() {

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    1.5E-322D,

                    1.4E-322D

            ), "tiny tiny number");

}



@Test

public void testDoubleComparisonTinyTinyTinyNumbers() {

    Assertions.assertTrue(

            GeneralUtils.nearlyEqual(

                    Double.MIN_NORMAL,

                    Double.MIN_NORMAL

            ), "tiny tiny number");

    Assertions.assertFalse(

            GeneralUtils.nearlyEqual(

                    Double.MIN_NORMAL,

                    Double.MIN_NORMAL * 0.1

            ), "tiny tiny numbers not same");

}



@Test

public void testDoubleComparisonThirds() {

    Assertions.assertTrue(

            GeneralUtils.nearlyEqual(

                    1.3333333333333333333333333333333333333333D,

                    1.3333333333333333333333333333333333333333D

            ), "thirds");

}