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

NAME
     std::fpclassify - std::fpclassify

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

	int fpclassify( long double num );
	constexpr int fpclassify(  /*  floating-point-type  */	 (1)	  (since
     C++23)
	num );
	Additional overloads
	Defined in header <cmath>
	template<  class  Integer  >				     (A)  (since
     C++11)
	int fpclassify( Integer num );				      (constexpr
     since C++23)

	1)  Categorizes  floating point value num into the following categories:
     zero,
	subnormal, normal, infinite, NAN, or implementation-defined category.
	The library provides overloads of std::fpclassify 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
	one of FP_INFINITE, FP_NAN, FP_NORMAL, FP_SUBNORMAL, FP_ZERO or
	implementation-defined type, specifying the category of num.

Notes
	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::fpclassify(num) has the same effect as
	std::fpclassify(static_cast<double>(num)).

Example
     // Run this code

      #include <cfloat>
      #include <cmath>
      #include <iostream>

      auto show_classification(double x)
      {
	  switch (std::fpclassify(x))
	  {
	      case FP_INFINITE:
		  return "Inf";
	      case FP_NAN:
		  return "NaN";
	      case FP_NORMAL:
		  return "normal";
	      case FP_SUBNORMAL:
		  return "subnormal";
	      case FP_ZERO:
		  return "zero";
	      default:
		  return "unknown";
	  }
      }

      int main()
      {
	  std::cout << "1.0/0.0 is " << show_classification(1 / 0.0) << '\n'
		    << "0.0/0.0 is " << show_classification(0.0 / 0.0) << '\n'
		    << "DBL_MIN/2 is " << show_classification(DBL_MIN  /  2)  <<
     '\n'
		    << "-0.0 is " << show_classification(-0.0) << '\n'
		    << "1.0 is " << show_classification(1.0) << '\n';
      }

Output:
      1.0/0.0 is Inf
      0.0/0.0 is NaN
      DBL_MIN/2 is subnormal
      -0.0 is zero
      1.0 is normal

See also
	isfinite       checks if the given number has finite value
	(C++11)        (function)
	isinf	       checks if the given number is infinite
	(C++11)        (function)
	isnan	       checks if the given number is NaN
	(C++11)        (function)
	isnormal       checks if the given number is normal
	(C++11)        (function)
		       provides  an  interface to query properties of all funda-
     mental numeric
	numeric_limits types
		       (class template)
	C documentation for
	fpclassify

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