std::fpclassify(3)

Hey bestie!! 💖 Welcome to the std::fpclassify(3) page from the C++ Standard Libary manual — it's giving “what kind of floating-point number is this?” energy, and honestly? Iconic. 💅

🌸 NAME 🌸

std::fpclassify - std::fpclassify

✨ Synopsis ✨

Okay so here's the whole signature situation, no cap. 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 */ num ); — (1) (since C++23)

Additional overloads 💖

Defined in header <cmath>:

template< class Integer >
int fpclassify( Integer num );

(A) (since C++11) (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. Literally the vibe check for your number. 💖

🦋 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)
• numeric_limits — provides an interface to query properties of all fundamental numeric types — (class template)
• C documentation for fpclassify

---

That's the whole page, bestie — no cap, you now know how to vibe-check a floating-point number. 💖 This was std::fpclassify(3) from http://cppreference.com, dated 2024.06.10. Mwah! 🫶✨