# NaN

In computing, NaN (Not a Number) is a value or symbol that is usually produced as the result of an operation on invalid input operands, especially in floating-point calculations. For example, most floating-point units are unable to calculate the square root of negative numbers, and will instead indicate that the operation was invalid and return a NaN result.

 Contents

## NaNs in floating point

In floating-point calculations, NaN is not the same as infinity, although both are typically handled as special cases in floating-point representations of real numbers as well as in floating-point operations. An invalid operation is also not the same as an arithmetic overflow (which might return an infinity) or an arithmetic underflow (which would return the smallest normal number, a denormal number, or zero).

A NaN does not compare equal to any floating-point number or NaN, even if the latter has an identical representation. One can therefore test whether a variable has a NaN value by comparing it to itself.

In the IEEE floating-point standard, arithmetic operations involving NaN always produce NaN, allowing the value to propagate through a calculation. In the current (proposed) IEEE 754r revision of that standard, there are two exceptions to this rule: the maxnum and minnum functions return the maximum and minimum of two operands, and will favour numbers (if just one of the operands is a NaN then the other operand is returned). This behaviour is useful in the statistical processing of sparse data.

A similar concept has been implemented in the NaN-toolbox for Octave and Matlab  (http://www.dpmi.tu-graz.ac.at/~schloegl/matlab/NaN/). The NaN-toolbox contains statistical functions that ignore any NaN in the data. Most algorithms in the NaN-toolbox are based on the function SUMSKIPNAN  (http://cvs.sourceforge.net/viewcvs.py/octave/octave-forge/extra/NaN/sumskipnan.m). SUMSKIPNAN adds and counts all numerals and skips all NaN. Every statistic in the NaN-toolbox is based on the numerals only - this bevahiour is useful in statistical data processing with missing values.

### Quiet NaNs

Quiet NaNs, or qNaNs, do not raise any additional exceptions as they propagate through most operations. The exceptions are where the NaN cannot simply be passed through unchanged to the output, such as in format conversions or certain comparison operations (which do not "expect" a NaN input).

### Signaling NaNs

Signaling NaNs, or sNaNs, are special forms of a NaN which when consumed by most operations should raise an invalid exception and then, if appropriate, be "quieted" into a qNaN which may then propagate. There have been several ideas for how these might be used:

• Filling uninitialized memory with signaling NaNs would produce an invalid exception if the data is used before it is initialized
• Using an sNaN as a place holder for a more complicated object such as:

When encountered a trap handler could decode the sNaN and return an index to the computed result. In practice this approach is faced with many complications. The treatment of the sign bit of NaNs for some simple operations (such as absolute value) is different than for arithmetic operations. Traps are not required by the standard. There are other approaches to this sort of problem which would be more portable.

There are questions about if signaling NaNs should continue to be required in the revised standard.

## NaNs in integers

Most fixed sized integer formats do not have any way of explicitly indicating invalid data.

Perl's BigInt package uses "NaN" for the result of strings which don't represent valid integers.

• ` >perl -mMath::BigInt -e "print Math::BigInt->new('foo')" `
` NaN `de:NaN

• Art and Cultures
• Countries of the World (http://www.academickids.com/encyclopedia/index.php/Countries)
• Space and Astronomy