That's the point I've already tried to say: I *do* use tests like "if (a
== -1) a = DoLazyCalculation();" and the like; I'd also guess the equality
operator is implicitly used when you use doubles as keys in a hashtable, or
sort an array of doubles (at least with generics, things like this should
trigger your warning, too). I don't think it would be a good idea to have a
warning *every* time the == operator is used on fp values;
using -1 is imho a bad idea. what if you actually need -1 in your app?
Negative numbers are very common in floating point (in contrast to
integers). What if you inadvertantly use the float variable with its -1
value?
NaN is just for that purpose: If a value is NaN it stays NaN even if used in
calculations or converted from double to float and vice versa and this way,
you know that something gone wrong if you see NaN in the output.
The following code displays 4 times NaN:
float f = float.NaN;
double d = double.NaN;
Console.WriteLine(double.IsNaN((float)d));
Console.WriteLine(double.IsNaN((double)f));
Console.WriteLine(float.IsNaN((float)d));
Console.WriteLine(float.IsNaN((float)(double)f));
The funny thing is that if you compare a float with and int value -1 the
result returns true even if its value is not -1. The following prints
"hello":
float f1 = -1.00000001f;
float f2 = -0.99999999f;
if (f1==-1 && f2==-1)
{
Console.WriteLine("hello");
}
Btw: using floating point values as hashtable keys seems to be a bad idea.
Even when flooring and ceiling values it doesn't work. The following outputs
2 times false:
float f1 = -0.99999991f;
float f2 = -0.99999999f;
float f3 = 0.99999991f;
float f4 = 0.99999999f;
Console.WriteLine(Math.Ceiling(f1)==Math.Ceiling(f2));
Console.WriteLine(Math.Floor(f3)==Math.Floor(f4));
Only using Math.Round() seems always to work correctly.
BTW: If you "forbid" the == operator, wouldn't it make sense to apply the
same strictness to other comparison operators? After all, everything said
applies also to comparisons like "Math.Sqrt(2)*Math.Sqrt(2) < 2" as well.
Very strange I'd expect the value be smaller as 2 than bigger but it shows
that you cannot rely on exact representation. But I'd never go so far to
issue warnings on all comparison operators for floating point because it
would be simply plain stupid.
Keep in mind that if (f1 < f2) is used very commonly and works fine in
almost every situation (except the programmer makes a wrong assumtion as you
example shows), But in constrast if (f1==f2) will be undefined unless you
use *constants* for *both* values and I cannot imagine a scenario which
requires this which cannot be solved with a better method.
Whatever is said in this thread, one should never assume an exact
representation of floating point variables
even if it seems to work with some values if could fail with other ones or
fail on another platform.
