C++ float number to nan

I want to know what makes a float number nan in c++. I am using a large dataset and it is really hard to trace. I want to know the ways of changing a float number to nan to reduce bug possibilities.

I found the code that causes the nan problem. I found that s/m is nan in some cases. But I don't know how to solve it.

float gp(float x){
float e = 2.71828183;
x *= -1;
float s = pow(e,x);开发者_运维百科
float m = (1 + pow(e,x)) * (1 + pow(e,x));  
return s / m;}

Taken from wikipedia -> special values -> nan

• 0/0
• ∞×0
• sqrt(−1)
• in general "invalid operations" (I am not sure wether there are not more than the three above)

Looking at you code: infinity times 0 is possible, is it?

edit:

• 0 <= s <= +inf

• 1 <= m <= +inf

s / m:

• +inf / +inf does indeed make minus NaN (I tested it)

I think that's the only thing that makes a NaN.

If you can keep x between 0 and FLT_MAX (3.40E+38 in my case), your gp function will not return NaN.

You say in a comment that you only use *, +, -.

[Edit: you've since said that you also use pow and division, which introduce some extra ways to get NaN. For example if the parameter x is a large negative value then pow(e,-x) is infinity, so you can easily end up computing infinity/infinity, which is another NaN]

So, if you have IEEE floating-point then assuming this summary is correct, the only ways you can generate NaN are:

1. Generate a positive or negative infinity by going out of range,
2. Multiply it by zero.

or:

1. Generate a positive and a negative infinity,
2. Add them (or equivalently, subtract two infinities of the same sign).

So if you check for and catch infinities, you don't have to worry about NaNs as well. That said, the usual way is to let such values propagate as quiet NaNs, and check at the end.

For C++ implementations using non-IEEE arithmetic, I'm not sure what the rules are when a NaN is permitted. I could look them up in the standard, but then again so could you ;-)

sqrt(-1)

give you NaN, for example. http://www.gnu.org/s/libc/manual/html_node/Infinity-and-NaN.html

EDIT Try use double instead of float.

Probably it depends to compiler you using but general option is:

• variable is too small
• variable is too big
• divide by 0 (zero)

This is exactly the use case for enabling and trapping floating-point exceptions. That way you can detect exactly where the NaN (or other exception value) first appears.

However, that's a platform-dependant feature, so you may have to look into the documentation of your compiler and/or hardware.