Code Inspection: Equality comparison of floating point numbers

Using the ==/ != operators to compare floating-point numbers is, generally, a bad idea. Floating point values are inherently inaccurate, and comparing them for exact equality is almost never the desired semantics. Comparison via the ==/ != operators checks floating-point value representation to be exactly the same, which is very unlikely if you perform any arithmetic operations involving precision loss. For example, let's perform two simple arithmetic operations —

• add 0.1 11 times, and

• multiply 0.1 by 11

— and check whether their floating-point results are equal:

double add = 0; for (int i = 1; i <= 11; i++) { add += 0.1; } double multiply = 0.1 * 11; Console.WriteLine(add == multiply); // false

In a test run, we get add = 1.0999999999999999 and multiply = 1.1000000000000001 (although different runtimes can render different results), so the == operator evaluates the comparison to false.

To do this kind of comparison correctly, we need to specify a tolerance, that is, a value to indicate by how much the result can diverge from the intended value. JetBrains Rider helps us automatically rewrite the comparison as Math.Abs([expression]) < [tolerance]. The tolerance value depends on the precision of the calculations you perform. In our example, we can safely rely on a tolerance of 0.000000001:

double add = 0; for (int i = 1; i <= 11; i++) { add += 0.1; } double multiply = 0.1 * 11; var tolerance = 0.000000001; Console.WriteLine(Math.Abs(add - multiply) < tolerance); // true

Note that this inspection ignores some values that are often used as "marker values", like 0, +Infinity, -Infinity, NaN to represent "not yet initialized value" or "value is absent" when non-zero values are otherwise expected.
However, a better way to do that would be the double? type with the null value.