Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
std::numeri...::quiet_NaN(3)  C++ Standard Libary std::numeri...::quiet_NaN(3)

NAME
       std::numeric_limits::quiet_NaN -	std::numeric_limits::quiet_NaN

Synopsis
	  static T quiet_NaN() throw();		    (until C++11)
	  static constexpr T quiet_NaN() noexcept;  (since C++11)

	  Returns  the	special	 value "quiet not-a-number", as	represented by
       the floating-point
	  type T. Only meaningful if std::numeric_limits<T>::has_quiet_NaN  ==
       true. In	IEEE
	  754,	the  most  common binary representation	of floating-point num-
       bers, any value with
	  all bits of the exponent set and at least one	bit  of	 the  fraction
       set represents a
	  NaN.	It is implementation-defined which values of the fraction rep-
       resent quiet or
	  signaling NaNs, and whether the sign bit is meaningful.

Return value
	  T			     std::numeric_limits<T>::quiet_NaN()
	  /* non-specialized */	     T()
	  bool			     false
	  char			     0
	  signed char		     0
	  unsigned char		     0
	  wchar_t		     0
	  char8_t (C++20)	     0
	  char16_t (C++11)	     0
	  char32_t (C++11)	     0
	  short			     0
	  unsigned short	     0
	  int			     0
	  unsigned int		     0
	  long			     0
	  unsigned long		     0
	  long long (C++11)	     0
	  unsigned long	long (C++11) 0
	  float			     implementation-defined (may be NAN)
	  double		     implementation-defined
	  long double		     implementation-defined

Notes
	  A NaN	never compares equal to	itself.	Copying	a NaN may not preserve
       its bit
	  representation.

Example
	  Several ways to generate a NaN (the output string  is	 compiler-spe-
       cific)

       // Run this code

	#include <iostream>
	#include <limits>
	#include <cmath>

	int main()
	{
	    std::cout  <<  std::numeric_limits<double>::quiet_NaN()	<< ' '
       // nan
		      << std::numeric_limits<double>::signaling_NaN() <<  '  '
       // nan
		      << std::acos(2)	 << ' '	  // nan
		      << std::tgamma(-1) << ' '	  // nan
		      << std::log(-1)	 << ' '	  // nan
		      << std::sqrt(-1)	 << ' '	  // -nan
		      << 0 / 0.0	 << '\n'; // -nan

	    std::cout << "NaN == NaN? "	<< std::boolalpha
		      << ( std::numeric_limits<double>::quiet_NaN() ==
			   std::numeric_limits<double>::quiet_NaN() ) << '\n';
	}

Possible output:
	nan nan	nan nan	nan -nan -nan
	NaN == NaN? false

See also
	  has_quiet_NaN	identifies floating-point types	that can represent the
       special value
	  [static]	"quiet not-a-number" (NaN)
			(public	static member constant)
	  signaling_NaN	 returns  a signaling NaN value	of the given floating-
       point type
	  [static]	(public	static member function)
	  nan
	  nanf
	  nanl		not-a-number (NaN)
	  (C++11)	(function)
	  (C++11)
	  (C++11)
	  isnan		checks if the given number is NaN
	  (C++11)	(function)

http://cppreference.com		  2022.07.31	  std::numeri...::quiet_NaN(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::numeric_limits::quiet_NaN&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help