There is no general solution for comparing floating-point numbers that contain errors from previous operations. The code that must be used is application-specific. So, to get a proper answer, you must describe your situation more specifically.

The underlying problem is that performing a correct computation using incorrect data is in general impossible. If you want to compute some function of two exact mathematical values *x* and *y* but the only data you have is some inexactly computed values `x`

and `y`

, it is generally impossible to compute the exactly correct result. For example, suppose you want to know what the sum, *x*+*y*, is, but you only know `x`

is 3 and `y`

is 4, but you do not know what the true, exact *x* and *y* are. Then you cannot compute *x*+*y*.

If you know that `x`

and `y`

are **approximately** *x* and *y*, then you can compute an approximation of *x*+y by adding `x`

and `y`

. The works when the function being computed (`+`

in this example) has a reasonable derivative: Slightly changing the inputs of a function with a reasonable derivative slightly changes its outputs. This fails when the function you want to compute has a discontinuity or a large derivative. For example, if you want to compute the square root of *x* (in the real domain) using an approximation `x`

but `x`

might be negative due to previous rounding errors, then computing `sqrt(x)`

may produce an exception. Similarly, comparing for inequality or order is a discontinuous function: A slight change in inputs can change the answer completely (from false to true or vice-versa).

The common bad advice is to compare with a “tolerance”. This method trades false negatives (incorrect rejections of numbers that would satisfy the comparison if the exact mathematical values were compared) for false positives (incorrect acceptance of numbers that would not satisfy the comparison).

Whether or not an applicable can tolerate false acceptance depends on the application. Therefore, there is no general solution.

The level of tolerance to set, and even the nature by which it is calculated, depend on the data, the errors, and the previous calculations. So, even when it is acceptable to compare with a tolerance, the amount of tolerance to use and how to calculate it depend on the application. There is no general solution.