home | help 
std::isnan(3)		       C++ Standard Libary		   std::isnan(3)

NAME
     std::isnan - std::isnan

Synopsis
	Defined in header <cmath>
	bool isnan( float num );
								     (since
     C++11)
	bool  isnan(  double  num  );					  (until
     C++23)

	bool isnan( long double num );
	constexpr bool isnan( /*  floating-point-type  */  num	 (1)	  (since
     C++23)
	);
	Additional overloads
	Defined in header <cmath>
	template<  class  Integer  >				     (A)  (since
     C++11)
	bool isnan( Integer num );				      (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.

Parameters
	num - floating-point or integer value

Return value
	true if num is a NaN, false otherwise.

Notes
	There are many different NaN values with different sign  bits  and  pay-
     loads, 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 spe-
     cial 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<dou-
     ble>(num)).

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  -  INFIN-
     ITY) << '\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
	nan
	nanf
	nanl	    not-a-number (NaN)
	(C++11)     (function)
	(C++11)
	(C++11)
	fpclassify  categorizes the given floating-point value
	(C++11)     (function)
	isfinite    checks if the given number has finite value
	(C++11)     (function)
	isinf	    checks if the given number is infinite
	(C++11)     (function)
	isnormal    checks if the given number is normal
	(C++11)     (function)
	isunordered checks if two floating-point values are unordered
	(C++11)     (function)
	C documentation for
	isnan

http://cppreference.com 	   2024.06.10			   std::isnan(3)
home | help