`_FDscale()` wasn't dllexported, so we can move it into an unnamed namespace.

`_FDnorm()` wasn't dllexported, so we can move it into an unnamed namespace.

It had no other effect. I'm adding `// underflow` versus `// overflow` comments to preserve clarity.

`_Feraise()` wasn't dllexported. It was marked `__CLRCALL_PURE_OR_CDECL` but not `_CRTIMP2_PURE`.

Remove now-unused macros.

They return the same values:

    C:\Temp>type meow.cpp
    #include <cmath>
    #include <limits>
    #include <print>
    using namespace std;

    static_assert(FP_SUBNORMAL == -2); // _DENORM
    static_assert(FP_NORMAL == -1); // _FINITE
    static_assert(FP_ZERO == 0);
    static_assert(FP_INFINITE == 1); // _INFCODE
    static_assert(FP_NAN == 2); // _NANCODE

    extern "C" _CRTIMP2_PURE short __CLRCALL_PURE_OR_CDECL _Dtest(double*) noexcept;

    void classify(double dbl) {
        const short stl = _Dtest(&dbl);
        const int crt   = fpclassify(dbl);
        println("dbl: {:6}; stl: {:2}; crt: {:2}; Equal: {}", dbl, stl, crt, stl == crt);
    }

    int main() {
        classify(numeric_limits<double>::denorm_min());
        classify(3.14);
        classify(0.0);
        classify(-0.0);
        classify(numeric_limits<double>::infinity());
        classify(numeric_limits<double>::quiet_NaN());
    }

    C:\Temp>cl /EHsc /nologo /W4 /std:c++latest /MTd /Od meow.cpp
    meow.cpp

    C:\Temp>meow
    dbl: 5e-324; stl: -2; crt: -2; Equal: true
    dbl:   3.14; stl: -1; crt: -1; Equal: true
    dbl:      0; stl:  0; crt:  0; Equal: true
    dbl:     -0; stl:  0; crt:  0; Equal: true
    dbl:    inf; stl:  1; crt:  1; Equal: true
    dbl:    nan; stl:  2; crt:  2; Equal: true

Equivalence proof:

    C:\Temp>type meow.cpp
    #include <cmath>
    #include <limits>
    #include <print>
    using namespace std;

    union _Dval {
        unsigned short _Sh[8];
        double _Val;
    };
    union _Fval {
        unsigned short _Sh[8];
        float _Val;
    };

    #define _D0 3
    #define _F0 1

    #define DSIGN(x) (reinterpret_cast<_Dval*>(&(x))->_Sh[_D0] & _DSIGN)
    #define FSIGN(x) (reinterpret_cast<_Fval*>(&(x))->_Sh[_F0] & _FSIGN)

    void test_dbl(double dbl) {
        const bool macro = static_cast<bool>(DSIGN(dbl));
        println("dbl: {:4}; macro: {:5}; signbit: {:5}; Equal: {}", dbl, macro, signbit(dbl), macro == signbit(dbl));
    }

    void test_flt(float flt) {
        const bool macro = static_cast<bool>(FSIGN(flt));
        println("flt: {:4}; macro: {:5}; signbit: {:5}; Equal: {}", flt, macro, signbit(flt), macro == signbit(flt));
    }

    int main() {
        test_dbl(numeric_limits<double>::infinity());
        test_dbl(-numeric_limits<double>::infinity());
        test_flt(numeric_limits<float>::infinity());
        test_flt(-numeric_limits<float>::infinity());
    }

    C:\Temp>cl /EHsc /nologo /W4 /std:c++latest /MTd /Od meow.cpp
    meow.cpp

    C:\Temp>meow
    dbl:  inf; macro: false; signbit: false; Equal: true
    dbl: -inf; macro: true ; signbit: true ; Equal: true
    flt:  inf; macro: false; signbit: false; Equal: true
    flt: -inf; macro: true ; signbit: true ; Equal: true

… namespace.

It's okay to move these unions out of _EXTERN_C_UNLESS_PURE,
because nothing else uses them.

…mespace.

They obviously aren't dllexported.

They weren't dllexported.

Although this results in a bit of code duplication, the result is more optimizer-friendly, and will allow us to eliminate xmath.hpp.

These are within an unnamed namespace, so we can alter their sizes.

There was no actual harm here, since we never indexed into the nonexistent memory,
but it was still risky, and likely to annoy static analysis someday.