It is well-known that NaNs propagate in arithmetic, but I couldn't find any demonstrations, so I wrote a small test:

#include <limits> #include <cstdio> int main(int argc, char* argv[]) { float qNaN = std::numeric_limits<float>::quiet_NaN(); float neg = -qNaN; float sub1 = 6.0f - qNaN; float sub2 = qNaN - 6.0f; float sub3 = qNaN - qNaN; float add1 = 6.0f + qNaN; float add2 = qNaN + qNaN; float div1 = 6.0f / qNaN; float div2 = qNaN / 6.0f; float div3 = qNaN / qNaN; float mul1 = 6.0f * qNaN; float mul2 = qNaN * qNaN; printf( "neg: %f

sub: %f %f %f

add: %f %f

div: %f %f %f

mul: %f %f

", neg, sub1,sub2,sub3, add1,add2, div1,div2,div3, mul1,mul2 ); return 0; }

The example (running live here) produces basically what I would expect (the negative is a little weird, but it kind of makes sense):

neg: -nan sub: nan nan nan add: nan nan div: nan nan nan mul: nan nan

MSVC 2015 produces something similar. However, Intel C++ 15 produces:

neg: -nan(ind) sub: nan nan 0.000000 add: nan nan div: nan nan nan mul: nan nan

Specifically, qNaN - qNaN == 0.0 .

This... can't be right, right? What do the relevant standards (ISO C, ISO C++, IEEE 754) say about this, and why is there a difference in behavior between the compilers?