Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/numeric/math/isnan"

From cppreference.com
< cpp‎ | numeric‎ | math
(link to c too)
(Wording update.)
 
(6 intermediate revisions by 4 users not shown)
Line 1: Line 1:
−
{{cpp/title|isnan}}
+
{{cpp/numeric/math/unary is|isnan
−
{{cpp/numeric/math/navbar}}
+
|description=Determines if the given floating point number {{c|num}} is a not-a-number (NaN) value.
−
{{dcl begin}}
+
|condition=is a NaN
−
{{dcl header | cmath}}
+
|note=
−
{{dcl | since=c++11 |
+
There are many different NaN values with different sign bits and payloads, see {{lc|std::nan}} and {{lc|std::numeric_limits::quiet_NaN}}.
−
bool isnan( float arg );
+
−
}}
+
−
{{dcl | since=c++11 |
+
−
bool isnan( double arg );
+
−
}}
+
−
{{dcl | since=c++11 |
+
−
bool isnan( long double arg );
+
−
}}
+
−
{{dcl end}}
+
  
−
Determines if the given floating point number {{tt|arg}} is not-a-number ({{tt|NaN}}).
+
NaN values never compare equal to themselves or to other NaN values. Copying a NaN is not required, by IEEE-754, to preserve its bit representation (sign and {{rlp|nan|payload}}), though most implementation do.
  
−
===Parameters===
+
Another way to test if a floating-point value is NaN is to compare it with itself: {{c|1=bool is_nan(double x) { return x != x; }<!---->}}.
−
{{par begin}}
+
−
{{par | arg | floating point value}}
+
−
{{par end}}
+
  
−
===Return value===
+
[https://gcc.gnu.org/wiki/FloatingPointMath GCC] and [https://clang.llvm.org/docs/UsersManual.html#controlling-floating-point-behavior Clang] support a {{tt|-ffinite-math}} option (additionally implied by {{tt|-ffast-math}}), which allows the respective compiler to assume the nonexistence of special IEEE-754 floating point values such as NaN, infinity, or negative zero. In other words, {{tt|std::isnan}} is assumed to always return {{c|false}} under this option.
 +
}}
  
−
{{c|true}} if {{tt|arg}} is {{c|NaN}}, {{c|false}} otherwise
+
===Example===
 +
{{example
 +
|code=
 +
#include <cfloat>
 +
#include <cmath>
 +
#include <iostream>
  
−
===Notes===
+
int main()
−
In C, {{c|isnan}} is a preprocessor macro, rather than a function.
+
{
 +
    std::cout << std::boolalpha
 +
              << "isnan(NaN) = " << std::isnan(NAN) << '\n'
 +
              << "isnan(Inf) = " << std::isnan(INFINITY) << '\n'
 +
              << "isnan(0.0) = " << std::isnan(0.0) << '\n'
 +
              << "isnan(DBL_MIN/2.0) = " << std::isnan(DBL_MIN / 2.0) << '\n'
 +
              << "isnan(0.0 / 0.0)  = " << std::isnan(0.0 / 0.0) << '\n'
 +
              << "isnan(Inf - Inf)  = " << std::isnan(INFINITY - INFINITY) << '\n';
 +
}
 +
|output=
 +
isnan(NaN) = true
 +
isnan(Inf) = false
 +
isnan(0.0) = false
 +
isnan(DBL_MIN/2.0) = false
 +
isnan(0.0 / 0.0)  = true
 +
isnan(Inf - Inf)  = true
 +
}}
  
 
===See also===
 
===See also===
−
 
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/numeric/math/dsc fpclassify}}
+
{{dsc inc|cpp/numeric/math/dsc fnan}}
−
{{dsc inc | cpp/numeric/math/dsc isfinite}}
+
{{dsc inc|cpp/numeric/math/dsc fpclassify}}
−
{{dsc inc | cpp/numeric/math/dsc isinf}}
+
{{dsc inc|cpp/numeric/math/dsc isfinite}}
−
{{dsc inc | cpp/numeric/math/dsc isnormal}}
+
{{dsc inc|cpp/numeric/math/dsc isinf}}
−
{{dsc inc | cpp/numeric/math/dsc isunordered}}
+
{{dsc inc|cpp/numeric/math/dsc isnormal}}
−
{{dsc see c | c/numeric/math/isnan}}
+
{{dsc inc|cpp/numeric/math/dsc isunordered}}
 +
{{dsc see c|c/numeric/math/isnan}}
 
{{dsc end}}
 
{{dsc end}}
  
−
[[de:cpp/numeric/math/isnan]]
+
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
−
[[es:cpp/numeric/math/isnan]]
+
−
[[fr:cpp/numeric/math/isnan]]
+
−
[[it:cpp/numeric/math/isnan]]
+
−
[[ja:cpp/numeric/math/isnan]]
+
−
[[pt:cpp/numeric/math/isnan]]
+
−
[[ru:cpp/numeric/math/isnan]]
+
−
[[zh:cpp/numeric/math/isnan]]
+

Latest revision as of 19:39, 8 August 2023

 
C++
 
Numerics library
Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Factor operations
(C++17)
(C++17)
Interpolations
(C++20)
(C++20)
Saturation arithmetic
(C++26)
(C++26)
(C++26)
(C++26)
(C++26)

Generic numeric operations
Bit operations
(C++20)    
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++23)
(C++20)
 
Common mathematical functions
Functions
Basic operations
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Exponential functions
(C++11)
(C++11)

(C++11)
(C++11)
Power functions
(C++11)
(C++11)
Trigonometric and
hyperbolic functions
(C++11)
(C++11)
(C++11)

Error and gamma functions
(C++11)
(C++11)
(C++11)
(C++11)
Nearest integer floating point operations
(C++11)(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Floating point manipulation functions
(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
isnan
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
 
Defined in header <cmath>
(1)
bool isnan( float num );

bool isnan( double num );

bool isnan( long double num );
 (since C++11)
(until C++23)
constexpr bool isnan( /* floating-point-type */ num );
 (since C++23)
Defined in header <cmath>
template< class Integer >
bool isnan( Integer num );
 (A) (since C++11)
(constexpr since C++23)
1) Determines if the given floating point number num is a not-a-number (NaN) value. The library provides overloads for all cv-unqualified floating-point types as the type of the parameter num.(since C++23)
A) Additional overloads are provided for all integer types, which are treated as double.

Contents

[edit] Parameters

num - floating-point or integer value

[edit] Return value

true if num is a NaN, false otherwise.

[edit] Notes

There are many different NaN values with different sign bits and payloads, see std::nan and std::numeric_limits::quiet_NaN.

NaN values never compare equal to themselves or to other NaN values. Copying a NaN is not required, by IEEE-754, to preserve its bit representation (sign and payload), though most implementation do.

Another way to test if a floating-point value is NaN is to compare it with itself: bool is_nan(double x) { return x != x; }.

GCC and Clang support a -ffinite-math option (additionally implied by -ffast-math), which allows the respective compiler to assume the nonexistence of special IEEE-754 floating point values such as NaN, infinity, or negative zero. In other words, std::isnan is assumed to always return false under this option.

The additional overloads are not required to be provided exactly as (A). They only need to be sufficient to ensure that for their argument num of integer type, std::isnan(num) has the same effect as std::isnan(static_cast<double>(num)).

[edit] Example

Run this code
#include <cfloat>
#include <cmath>
#include <iostream>
 
int main()
{
    std::cout << std::boolalpha
              << "isnan(NaN) = " << std::isnan(NAN) << '\n'
              << "isnan(Inf) = " << std::isnan(INFINITY) << '\n'
              << "isnan(0.0) = " << std::isnan(0.0) << '\n'
              << "isnan(DBL_MIN/2.0) = " << std::isnan(DBL_MIN / 2.0) << '\n'
              << "isnan(0.0 / 0.0)   = " << std::isnan(0.0 / 0.0) << '\n'
              << "isnan(Inf - Inf)   = " << std::isnan(INFINITY - INFINITY) << '\n';
}

Output: 

isnan(NaN) = true
isnan(Inf) = false
isnan(0.0) = false
isnan(DBL_MIN/2.0) = false
isnan(0.0 / 0.0)   = true
isnan(Inf - Inf)   = true

[edit] See also

(C++11)(C++11)(C++11)
 not-a-number (NaN)
(function) [edit]
(C++11)
 categorizes the given floating-point value
(function) [edit]
(C++11)
 checks if the given number has finite value
(function) [edit]
(C++11)
 checks if the given number is infinite
(function) [edit]
(C++11)
 checks if the given number is normal
(function) [edit]
(C++11)
 checks if two floating-point values are unordered
(function) [edit]
C documentation for isnan
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/isnan&oldid=156452"