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 fundamental numeric
   numeric_limits types
                  (class template)
   C documentation for
   fpclassify