In computing, NaN (/næn/), standing for Not a Number, is a particular value of a numeric data type (often a floatingpoint number) which is undefined as a number, such as the result of 0/0. Systematic use of NaNs was introduced by the IEEE 754 floatingpoint standard in 1985, along with the representation of other nonfinite quantities such as infinities.
In mathematics, the result of 0/0 is typically not defined as a number^{[a]} and may therefore be represented by NaN in computing systems.
The square root of a negative number is not a real number, and is therefore also represented by NaN in compliant computing systems. NaNs may also be used to represent missing values in computations.^{[1]}^{[2]}
Two separate kinds of NaNs are provided, termed quiet NaNs and signaling NaNs. Quiet NaNs are used to propagate errors resulting from invalid operations or values. Signaling NaNs can support advanced features such as mixing numerical and symbolic computation or other extensions to basic floatingpoint arithmetic.
Floatingpoint formats 

IEEE 754 

Other 
Alternatives 
In floatingpoint calculations, NaN is not the same as infinity, although both are typically handled as special cases in floatingpoint representations of real numbers as well as in floatingpoint operations. An invalid operation is also not the same as an arithmetic overflow (which would return an infinity or the largest finite number in magnitude) or an arithmetic underflow (which would return the smallest normal number in magnitude, a subnormal number, or zero).
IEEE 754 NaNs are encoded with the exponent field filled with ones (like infinity values), and some nonzero number in the significand field (to make them distinct from infinity values); this allows the definition of multiple distinct NaN values, depending on which bits are set in the significand field, but also on the value of the leading sign bit (but applications are not required to provide distinct semantics for those distinct NaN values).
For example, an IEEE 754 single precision (32bit) NaN would be encoded as
s111 1111 1xxx xxxx xxxx xxxx xxxx xxxx
where s is the sign (most often ignored in applications) and the x sequence represents a nonzero number (the value zero encodes infinities). In practice, the most significant bit from x is used to determine the type of NaN: "quiet NaN" or "signaling NaN" (see details in Encoding). The remaining bits encode a payload (most often ignored in applications).
Floatingpoint operations other than ordered comparisons normally propagate a quiet NaN (qNaN). Most floatingpoint operations on a signaling NaN (sNaN) signal the invalidoperation exception; the default exception action is then the same as for qNaN operands and they produce a qNaN if producing a floatingpoint result.
The propagation of quiet NaNs through arithmetic operations allows errors to be detected at the end of a sequence of operations without extensive testing during intermediate stages. For example, if one starts with a NaN and adds 1 five times in a row, each addition results in a NaN, but there is no need to check each calculation because one can just note that the final result is NaN. However, depending on the language and the function, NaNs can silently be removed from a chain of calculations where one calculation in the chain would give a constant result for all other floatingpoint values. For example, the calculation x^{0} may produce the result 1, even where x is NaN, so checking only the final result would obscure the fact that a calculation before the x^{0} resulted in a NaN. In general, then, a later test for a set invalid flag is needed to detect all cases where NaNs are introduced^{[3]} (see Function definition below for further details).
In section 6.2 of the old IEEE 7542008 standard, there are two anomalous functions (the maxNum
and minNum
functions, which return the maximum and the minimum, respectively, of two operands that are expected to be numbers) that favor numbers — if just one of the operands is a NaN then the value of the other operand is returned. The IEEE 7542019 revision has replaced these functions as they are not associative (when a signaling NaN appears in an operand).^{[4]}^{[5]}
Comparisons are specified by the IEEE 754 standard to take into account possible NaN operands.^{[6]} When comparing two real numbers, or extended real numbers (as in the IEEE 754 floatingpoint formats), the first number may be either less than, equal to, or greater than the second number. This gives three possible relations. But when at least one operand of a comparison is NaN, this trichotomy does not apply, and a fourth relation is needed: unordered. In particular, two NaN values compare as unordered, not as equal.
As specified, the predicates associated with the <, ≤, =, ≥, > mathematical symbols (or equivalent notation in programming languages) return false on an unordered relation. So, for instance, NOT(x < y) is not logically equivalent to x ≥ y: on unordered, i.e. when x or y is NaN, the former returns true while the latter returns false. However, ≠ is defined as the negation of =, thus it returns true on unordered.
Comparison  NaN ≥ x  NaN ≤ x  NaN > x  NaN < x  NaN = x  NaN ≠ x 

Result  False  False  False  False  False  True 
From these rules, comparing x with itself, x ≠ x or x = x, can be used to test whether x is NaN or nonNaN.
The comparison predicates are either signaling or nonsignaling on quiet NaN operands; the signaling versions signal the invalidoperation exception for such comparisons (i.e., by default, this just sets the corresponding status flag in addition to the behavior of the nonsignaling versions). The equality and inequality predicates are nonsignaling. The other standard comparison predicates associated with the above mathematical symbols are all signaling if they receive a NaN operand. The standard also provides nonsignaling versions of these other predicates. The predicate isNaN(x)
determines whether a value is a NaN and never signals an exception, even if x is a signaling NaN.
The IEEE floatingpoint standard requires that NaN ≠ NaN hold. In contrast, the 2022 private standard of posit arithmetic has a similar concept, NaR (Not a Real), where NaR = NaR holds.^{[7]}
There are three kinds of operations that can return NaN:^{[8]}
pow
function and the integer exponent pown
function define 0^{0}, 1^{∞}, and ∞^{0} as 1.powr
function defines all three indeterminate forms as invalid operations and so returns NaN.NaNs may also be explicitly assigned to variables, typically as a representation for missing values. Prior to the IEEE standard, programmers often used a special value (such as −99999999) to represent undefined or missing values, but there was no guarantee that they would be handled consistently or correctly.^{[1]}
NaNs are not necessarily generated in all the above cases. If an operation can produce an exception condition and traps are not masked then the operation will cause a trap instead.^{[9]} If an operand is a quiet NaN, and there is also no signaling NaN operand, then there is no exception condition and the result is a quiet NaN. Explicit assignments will not cause an exception even for signaling NaNs.
In general, quiet NaNs, or qNaNs, do not raise any additional exceptions, as they propagate through most operations. But the invalidoperation exception is signaled by some operations that do not return a floatingpoint value, such as format conversions or certain comparison operations.
Signaling NaNs, or sNaNs, are special forms of a NaN that, when consumed by most operations, should raise the invalid operation exception and then, if appropriate, be "quieted" into a qNaN that may then propagate. They were introduced in IEEE 754. There have been several ideas for how these might be used:
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 from that for arithmetic operations. Traps are not required by the standard. There are other approaches to this sort of problem that would be more portable.^{[citation needed]}
IEEE 7542019 recommends the operations getPayload, setPayload, and setPayloadSignaling be implemented,^{[10]} standardizing the access to payloads to streamline application use.^{[11]} According to the IEEE 7542019 background document, this recommendation should be interpreted as "required for new implementations, with reservation for backward compatibility".^{[12]}
In IEEE 754 interchange formats, NaNs are identified by specific, predefined bit patterns unique to NaNs. The sign bit does not matter. Binary format NaNs are represented with the exponential field filled with ones (like infinity values), and some nonzero number in the significand field (to make them distinct from infinity values). The original IEEE 754 standard from 1985 (IEEE 7541985) only described binary floatingpoint formats, and did not specify how the signaling/quiet state was to be tagged. In practice, the most significant bit of the significand field determined whether a NaN is signaling or quiet. Two different implementations, with reversed meanings, resulted:
is_quiet
flag;is_signaling
flag.The former choice has been preferred as it allows the implementation to quiet a signaling NaN by just setting the signaling/quiet bit to 1. The reverse is not possible with the latter choice because setting the signaling/quiet bit to 0 could yield an infinity.^{[13]}
The 2008 and 2019 revisions of the IEEE 754 standard make formal requirements and recommendations for the encoding of the signaling/quiet state.
is_quiet
flag.^{[15]} That is, this bit is nonzero if the NaN is quiet, and zero if the NaN is signaling.is_signaling
flag. That is, this bit is zero if the NaN is quiet, and nonzero if the NaN is signaling.^{[16]}For IEEE 7542008 conformance, the meaning of the signaling/quiet bit in recent MIPS processors is now configurable via the NAN2008 field of the FCSR register. This support is optional in MIPS Release 3 and required in Release 5.^{[17]}
The state/value of the remaining bits of the significand field are not defined by the standard. This value is called the 'payload' of the NaN. If an operation has a single NaN input and propagates it to the output, the result NaN's payload should be that of the input NaN (this is not always possible for binary formats when the signaling/quiet state is encoded by an is_signaling
flag, as explained above). If there are multiple NaN inputs, the result NaN's payload should be from one of the input NaNs; the standard does not specify which.
A number of systems have the concept of a "canonical NaN", where one specific NaN value is chosen to be the only possible qNaN generated by floatingpoint operations not having a NaN input. The value is usually chosen to be a quiet NaN with an allzero payload and an arbitrarilydefined sign bit.
Using a limited amount of NaN representations allows the system to use other possible NaN values for nonarithmetic purposes, the most important being "NaNboxing", i.e. using the payload for arbitrary data.^{[23]} (This concept of "canonical NaN" is not the same as the concept of a "canonical encoding" in IEEE 754.)
There are differences of opinion about the proper definition for the result of a numeric function that receives a quiet NaN as input. One view is that the NaN should propagate to the output of the function in all cases to propagate the indication of an error. Another view, and the one taken by the ISO C99 and IEEE 7542008 standards in general, is that if the function has multiple arguments and the output is uniquely determined by all the nonNaN inputs (including infinity), then that value should be the result. Thus for example the value returned by hypot(±∞, qNaN)
and hypot(qNaN, ±∞)
is +∞.
The problem is particularly acute for the exponentiation function pow(x, y)
= x^{y}. The expressions 0^{0}, ∞^{0} and 1^{∞} are considered indeterminate forms when they occur as limits (just like ∞ × 0), and the question of whether zero to the zero power should be defined as 1 has divided opinion.
If the output is considered as undefined when a parameter is undefined, then pow(1, qNaN)
should produce a qNaN. However, math libraries have typically returned 1 for pow(1, y)
for any real number y, and even when y is an infinity. Similarly, they produce 1 for pow(x, 0)
even when x is 0 or an infinity. The rationale for returning the value 1 for the indeterminate forms was that the value of functions at singular points can be taken as a particular value if that value is in the limit the value^{[clarification needed]} for all but a vanishingly small part of a ball around the limit value of the parameters.^{[citation needed]} The 2008 version of the IEEE 754 standard says that pow(1, qNaN)
and pow(qNaN, 0)
should both return 1 since they return 1 whatever else is used instead of quiet NaN. Moreover, ISO C99, and later IEEE 7542008, chose to specify pow(−1, ±∞)
= 1 instead of qNaN; the reason of this choice is given in the C rationale:^{[24]} "Generally, C99 eschews a NaN result where a numerical value is useful. ... The result of pow(−2, ∞)
is +∞, because all large positive floatingpoint values are even integers."
To satisfy those wishing a more strict interpretation of how the power function should act, the 2008 standard defines two additional power functions: pown(x, n)
, where the exponent must be an integer, and powr(x, y)
, which returns a NaN whenever a parameter is a NaN or the exponentiation would give an indeterminate form.
Most fixedsize integer formats cannot explicitly indicate invalid data. In such a case, when converting NaN to an integer type, the IEEE 754 standard requires that the invalidoperation exception be signaled. For example in Java, such operations throw instances of java.lang.ArithmeticException
.^{[25]} In C, they lead to undefined behavior, but if annex F is supported, the operation yields an "invalid" floatingpoint exception (as required by the IEEE standard) and an unspecified value.
Perl's Math::BigInt
package uses "NaN" for the result of strings that do not represent valid integers.^{[26]}
> perl mMath::BigInt e "print Math::BigInt>new('foo')"
NaN
Different operating systems and programming languages may have different string representations of NaN.
nan (C, C++, Python) NaN (ECMAScript, Rust, C#, Julia). Julia may show alternative NaN, depending on precision, NaN32, and NaN16; NaN is for Float64 type. NaN% NAN (C, C++, Rust) NaNQ (IBM XL and AIX: Fortran, C++ proposal n2290) NaNS (ditto) qNaN sNaN 1.#SNAN (Excel) 1.#QNAN (Excel) 1.#IND (Excel) +nan.0 (Scheme)
Since, in practice, encoded NaNs have a sign, a quiet/signaling bit and optional 'diagnostic information' (sometimes called a payload), these will occasionally be found in string representations of NaNs, too. Some examples are:
nan
) when present. There is no standard display of the payload nor of the signaling status, but a quiet NaN value of a specific payload may either be constructed by providing the string nan(charsequence)
to a numberparsing function (e.g. strtod
) or by providing the charsequence string to nan()
(or nans()
for sNaN), both interpreted in an implementationdefined manner.
nan()
and nans()
. They parse the charsequence as an integer for strtoull
(or a differentlysized equivalent) with its detection of integer bases.nan()
parsing, but strtod()
accepts a hexadecimal format without prefix.Not all languages admit the existence of multiple NaNs. For example, ECMAScript only uses one NaN value throughout.
For the most part, the Java SE platform treats NaN values of a given type as though collapsed into a single canonical value, and hence this specification normally refers to an arbitrary NaN as though to a canonical value.
Math::BigInt
". perldoc.perl.org. Retrieved 12 June 2015.
If chars… are provided, they are used in some unspecified fashion to select a particular representation of NaN (there can be several).