double.NaN - how does this counterintuitive feature work?

Question

I stumbled upon .NET's definition of double.NaN in code:

public const double NaN = (double)0.0 / (double)0.0;

This is done similarly in PositiveInfinity and NegativeInfinity.

double.IsNaN (with removing a few #pragmas and comments) is defined as:

[Pure] 
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static bool IsNaN(double d) 
{
    if (d != d)
    { 
        return true; 
    }
    else 
    {
        return false;
    }
}

This is very counter-intuitive to me.

Why is NaN defined as division by zero? How is 0.0 / 0.0 represented "behind the scenes"? How can division by 0 be possible in double, and why does NaN != NaN?

This is more about NaN than .NET's specifics... see http://en.wikipedia.org/wiki/NaN — Jon Skeet, Dec 25 '10 at 19:44
possible duplicate of [double.NaN](http://stackoverflow.com/questions/1145443/double-nan) — Ahmad Mageed, Dec 25 '10 at 19:45
@Jon Skeet: I agree, thanks for pointing that out and for the link! Changed the question a bit, to be less .NET specific. — GeReV, Dec 25 '10 at 19:56
its compatibile with database-null. There is also a rule that says that null != null — k3b, Dec 25 '10 at 20:00

Spence · Accepted Answer · 2010-12-25T19:53:20.577

Fairly simple answer here. .Net framework has implemented the floating point standard specified by the IEEE (System.Double complies with the IEC 60559:1989 (IEEE 754) standard for binary floating-point arithmetic.). This is because floating point arithmetic actually has to work across many systems, not just x86/64 architectures, so by following the conventions this ensures that there will be less compatibility issues (for instance porting code from a DSP into an x86 processor).

As for the d != d, this is a performance optimisation. Basically this instruction relies on a hardware instruction which can very quickly determine if two double floating point numbers are equal. Under the standard, NAN != NAN and therefore is the fastest way to test. Trying to find a reference for you.

I don’t think it’s a performance optimization. Rather, this is the standard (and probably the only portable) way of testing for NaN which works by definition. — Konrad Rudolph, Dec 25 '10 at 19:49

score 2 · Answer 2 · answered Dec 25 '10 at 20:14

Why is NaN defined as division by zero? How can division by 0 be possible in double, and why does NaN != NaN?

All of these are mandated by the IEEE 754 standard, which pretty much all modern CPUs implement.

How is 0.0 / 0.0 represented "behind the scenes"?

By having an exponent with all bits set to 1 and a mantissa with at least one bit set to 1. Note that this means that there are a large number of different bit patterns that all represent NaN - but, as mentioned above, even if the bit patterns are identical, they must be considered not equal (i.e. == must return false).

Restore the Data Dumps · Answer 3 · 2010-12-25T20:06:31.837

From the C# Spec:

14.9.2 Floating-point comparison operators The predefined floating-point comparison operators are:

bool operator ==(float x, float y); bool operator ==(double x, double y);
bool operator !=(float x, float y); bool operator !=(double x, double y);
bool operator <(float x, float y); bool operator <(double x, double y);
bool operator >(float x, float y); bool operator >(double x, double y);
bool operator <=(float x, float y); bool operator <=(double x, double y);
bool operator >=(float x, float y); bool operator >=(double x, double y);

The operators compare the operands according to the rules of the IEC 60559 standard: If either operand is NaN, the result is false for all operators except !=, for which the result is true. For any two operands, x != y always produces the same result as !(x == y). However, when one or both operands are NaN, the <, >, <=, and >= operators do not produce the same results as the logical negation of the opposite operator. [Example: If either of x and y is NaN, then x < y is false, but !(x >= y) is true. end example]

As to how NaN is represented behind the scenes, the wikipedia article on the IEEE spec has some examples.

double.NaN - how does this counterintuitive feature work?

3 Answers3