NaN 何时不在 C++ 中传播？

Question

NaN propagates through "most" operations as described in NaN - Wikipedia .

I would like to know the operations which NaN does NOT propagate. For example, I'm coding in C++ and found that following code prints 1 , which is not NaN.

const double result = std::pow(1, std::numeric_limits<double>::quiet_NaN());
std::cout << result << std::endl;

For std::pow function, this behavior is described in std::pow - cppreference.com .

Could you share any other examples?

Answer 1

std::pow is not really an operator in the sense that something like the multiplication in a * b is an operation. It's a function . And functions can have branches which can deal with a NaN as they please. Another similar std function is, in a sense, std::is_nan . This doesn't propagate NaN either: it returns a bool which is implicitly convertible to a numeric type:

std::is_nan(std::is_nan(a))

is false for any type a that allows the expression to compile. Other examples include std::fpclassify and std::isfinite . I particularly like std::fpclassify as an example since it has an int return type, so really it's no less of a numeric function than pow !

Note that the implicit conversion of NaN to bool is defined to befalse true according to the accepted answer to this question , which is important. It allows ! , && , and || to work with an NaN . Finally, the expression separator operator , doesn't propagate NaN either, and an NaN on the unused branch of a ternary conditional operation is ignored.

Answer 2

The other case I would try is pow(0, NaN) . If one has pow(0,0) == 1 then one should expect

 pow(0, NaN) == 1

There is a rationale for this, and actually it is needed for consistent behavior. Even though there is no IEEE standard dictating the behavior of all elementary functions with respect to NaN, there is a very basic rule:

If for all finite point numbers x including +inf and -inf (but excluding NaN) we have

f(const1, x) == const2

then (and only then) one also must return a non-NaN result

f(const1, NaN) == const2

#Long explanation

This is because NaN represents "undefined" or "any other numeric value from -inf.. inf". Why? Consider the prototypical example 0/0. If one has the equation

 b = a * x

and wants to solve for x . Clearly the solution is

x = b/a

Now if a == b == 0 then the original equation has infinitely many solutions, namely all finite numbers x . That's why NaN means "unspecified" and 0/0 == NaN . Now if an unspecified number (ie NaN) enters a function as an argument, it most often will cause an "unspecified" answer. The exception is where the output does not depend on the input, and in this case one should/must not return NaN.

Consider

pow(1, a/b)

This expression always evaluates to 1 for nonzero a and b , which makes sense from a mathematical point of view as the 1^x in a mathematical sense does not depend on x . So also numerically one would require that for a = 0 or b = 0 (and hence x=NaN ) one also obtains 1.

So if one agrees upon the fact that

pow(1,-inf) = pow(1,inf) = 1 

then one also has to define

pow(1,NaN) = 1

for consistent behavior. The same applies to pow(0,c) but also evaluation of a polynomial of degree zero should generate a non-NaN output on NaN input.

Note: this reasoning can be applied to any function, including the built-in operators.

Answer 3

Here's an example demonstrating functions of NaN which return non-NaN. The list is in IEEE 754-2008, 9.2.1 Special values (there are some others functions, but they don't seem to be implemented in C++):

#include <cmath>
#include <limits>
#include <iostream>

int main()
{
    const auto nan=std::numeric_limits<double>::quiet_NaN();
    const auto inf=std::numeric_limits<double>::infinity();
    std::cout << std::hypot(nan,inf) << '\n';
    std::cout << std::hypot(inf,nan) << '\n';
    std::cout << std::pow(nan, 0) << '\n';
    std::cout << std::pow(1,nan) << '\n';
}

The output is:

inf
inf
1
1