We ought to have some portable way to classify a floating-point type according to its ISO/IEC 60559 format. For example, one may want to detect at compile time whether float has the same representation as std::float32_t, and other such things.

Merely checking whether the type is 32 bits large and is_iec559 is true doesn't necessarily work. The floating-point type could also be in an extended 16-bit format, or in an interchange format that also has 32 bits but is not binary32, or it could be binary16 with 16 bits of padding. A perfectly reliable approach (that doesn't involve querying all sorts of other properties like the number of digits and the exponent) would look like:

enum class iec559_format : /* unspecified */ {

    unclassified,

    binary_arithmetic, // e.g. x87 80-bit long double;

                       // has inf, qNaN, sNaN, and can represent numbers,

                       // but is not an interchange format

    binary_interchange, // generic binary interchange format,

                        // e.g. binary256 or binary512

    binary16, // basic binary interchange format (std::float16_t)

    binary32,

    binary64,

    binary128,

    binary16x, // extended format for binary16 (C23 _Float16x)

    binary32x,

    binary64x,

    binary128x,

    decimal_arithmetic,

    decimal_interchange, // generic decimal interchange format

    decimal32, // basic decimal interchange format

    decimal64,

    decimal128,

    decimal32x, // extended format for decimal32 (C23 _Decimal32x)

    decimal64x,

    decimal128x,

};

The user could use this as follows:

constexpr auto f = std::numeric_limits<T>::iec559_format;

if constexpr (f == std::iec559_format::binary32) {

    // always true for std::float32_t, usually true for float

}

if constexpr (f == std::iec559_format::binary64) {

    // always true for std::float32_t, usually true for double,

    // sometimes true for long double

}