reactos/sdk/include/c++/limits

// Numerical limits for C++

#include <climits>
#include <cwchar>
#include <cfloat>
#include <ymath.h>

namespace std
{
    // Rounding style for floating point numbers
    enum float_round_style {
        round_indeterminate = -1,
        round_toward_zero = 0,
        round_to_nearest = 1,
        round_toward_infinity = 2,
        round_toward_neg_infinity = 3
        };

    // How to represent denormalized values
    enum float_denorm_style {
        denorm_indeterminate = -1,
        denorm_absent = 0,
        denorm_present = 1
        };

    template<class Type> class numeric_limits
    {
    public:
        // Not specialized by default
        static const bool is_specialized = false;

        // Bounding
        static const bool is_bounded = false;
        static Type lowest() throw();
        static Type max( ) throw( );
        static Type min( ) throw( );

        // infinity
        static const bool has_infinity = false;
        static Type infinity( ) throw( );

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static Type denorm_min( ) throw( );

        // Digits
        static const int digits = 0;
        static const int digits10 = 0;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static Type quiet_NaN( ) throw( );
        static Type signaling_NaN( ) throw( );

        // Information
        static const bool is_exact = false;
        static const bool is_iec559 = false;
        static const bool is_integer = false;
        static const bool is_modulo = false;
        static const bool is_signed = false;

        // misc
        static Type epsilon( ) throw( );
        static const int max_digits10 = 0;
        static const int radix = 0;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static Type round_error( ) throw( );
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<wchar_t>
    {
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static wchar_t lowest() throw()
            {return WCHAR_MIN;}
        static wchar_t max( ) throw()
            {return WCHAR_MAX;}
        static wchar_t min( ) throw()
            {return WCHAR_MIN;}

        // infinity
        static const bool has_infinity = false;
        static wchar_t infinity( ) throw()
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static wchar_t denorm_min( ) throw()
            {return 0;}

        // Digits
        static const bool is_signed = WCHAR_MIN != 0;
        static const int digits = sizeof(wchar_t) * CHAR_BIT - (is_signed ? 1 : 0);
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static wchar_t quiet_NaN( ) throw()
            {return 0;}
        static wchar_t signaling_NaN( ) throw()
            {return 0;}


        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;

        // misc
        static wchar_t epsilon( ) throw()
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static wchar_t round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<bool>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static bool lowest() throw()
            {return false;}
        static bool max( ) throw( )
            {return true;}
        static bool min( ) throw( )
            {return false;}

        // infinity
        static const bool has_infinity = false;
        static bool infinity( ) throw( )
            {return false;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static bool denorm_min( ) throw( )
            {return false;}

        // Digits
        static const int digits = 1;
        static const int digits10 = 0;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static bool quiet_NaN( ) throw( )
            {return false;}
        static bool signaling_NaN( ) throw( )
            {return false;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = false;
        static const bool is_signed = false;

        // misc
        static bool epsilon( ) throw( )
            {return false;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static bool round_error( ) throw( )
            {return false;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<char>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static char lowest() throw()
            {return CHAR_MIN;}
        static char max( ) throw( )
            {return CHAR_MAX;}
        static char min( ) throw( )
            {return CHAR_MIN;}

        // infinity
        static const bool has_infinity = false;
        static char infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static char denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const bool is_signed = CHAR_MIN != 0;
        static const int digits = sizeof(char) * CHAR_BIT - (is_signed ? 1 : 0);
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static char quiet_NaN( ) throw( )
            {return 0;}
        static char signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;

        // misc
        static char epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static char round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<signed char>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static signed char lowest() throw()
            {return SCHAR_MIN;}
        static signed char max( ) throw( )
            {return SCHAR_MAX;}
        static signed char min( ) throw( )
            {return SCHAR_MIN;}

        // infinity
        static const bool has_infinity = false;
        static signed char infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static signed char denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const int digits = sizeof(signed char) * CHAR_BIT - 1;
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static signed char quiet_NaN( ) throw( )
            {return 0;}
        static signed char signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;
        static const bool is_signed = true;

        // misc
        static signed char epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static signed char round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<unsigned char>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static unsigned char lowest() throw()
            {return 0;}
        static unsigned char max( ) throw( )
            {return UCHAR_MAX;}
        static unsigned char min( ) throw( )
            {return 0;}

        // infinity
        static const bool has_infinity = false;
        static unsigned char infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static unsigned char denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const int digits = sizeof(unsigned char) * CHAR_BIT;
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static unsigned char quiet_NaN( ) throw( )
            {return 0;}
        static unsigned char signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;
        static const bool is_signed = false;

        // misc
        static unsigned char epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static unsigned char round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<short>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static short lowest() throw()
            {return SHRT_MIN;}
        static short max( ) throw( )
            {return SHRT_MAX;}
        static short min( ) throw( )
            {return SHRT_MIN;}

        // infinity
        static const bool has_infinity = false;
        static short infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static short denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const bool is_signed = SHRT_MIN != 0;
        static const int digits = sizeof(short) * CHAR_BIT - (is_signed ? 1 : 0);
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static short quiet_NaN( ) throw( )
            {return 0;}
        static short signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;

        // misc
        static short epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static short round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<unsigned short>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static unsigned short lowest() throw()
            {return 0;}
        static unsigned short max( ) throw( )
            {return USHRT_MAX;}
        static unsigned short min( ) throw( )
            {return 0;}

        // infinity
        static const bool has_infinity = false;
        static unsigned short infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static unsigned short denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const int digits = sizeof(unsigned short) * CHAR_BIT;
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static unsigned short quiet_NaN( ) throw( )
            {return 0;}
        static unsigned short signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;
        static const bool is_signed = false;

        // misc
        static unsigned short epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static unsigned short round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<int>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static int lowest() throw()
            {return INT_MIN;}
        static int max( ) throw( )
            {return INT_MAX;}
        static int min( ) throw( )
            {return INT_MIN;}

        // infinity
        static const bool has_infinity = false;
        static int infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static int denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const bool is_signed = INT_MIN != 0;
        static const int digits = sizeof(int) * CHAR_BIT - (is_signed ? 1 : 0);
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static int quiet_NaN( ) throw( )
            {return 0;}
        static int signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;

        // misc
        static int epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static int round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<unsigned int>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static unsigned int lowest() throw()
            {return 0;}
        static unsigned int max( ) throw( )
            {return UINT_MAX;}
        static unsigned int min( ) throw( )
            {return 0;}

        // infinity
        static const bool has_infinity = false;
        static unsigned int infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static unsigned int denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const int digits = sizeof(unsigned int) * CHAR_BIT;
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static unsigned int quiet_NaN( ) throw( )
            {return 0;}
        static unsigned int signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;
        static const bool is_signed = false;

        // misc
        static unsigned int epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const int radix = 2;
        static const bool traps = false;

        // exponent
        static const int max_exponent = 0;
        static const int max_exponent10 = 0;
        static const int min_exponent = 0;
        static const int min_exponent10 = 0;

        // rounding
        static unsigned int round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<long>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static long lowest() throw()
            {return LONG_MIN;}
        static long max( ) throw( )
            {return LONG_MAX;}
        static long min( ) throw( )
            {return LONG_MIN;}

        // infinity
        static const bool has_infinity = false;
        static long infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static long denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const bool is_signed = LONG_MIN != 0;
        static const long digits = sizeof(long) * CHAR_BIT - (is_signed ? 1 : 0);
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const long digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static long quiet_NaN( ) throw( )
            {return 0;}
        static long signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_longeger = true;
        static const bool is_modulo = true;

        // misc
        static long epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const long radix = 2;
        static const bool traps = false;

        // exponent
        static const long max_exponent = 0;
        static const long max_exponent10 = 0;
        static const long min_exponent = 0;
        static const long min_exponent10 = 0;

        // rounding
        static long round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<unsigned long>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static unsigned long lowest() throw()
            {return 0;}
        static unsigned long max( ) throw( )
            {return ULONG_MAX;}
        static unsigned long min( ) throw( )
            {return 0;}

        // infinity
        static const bool has_infinity = false;
        static unsigned long infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static unsigned long denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const long digits = sizeof(unsigned long) * CHAR_BIT;
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const long digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static unsigned long quiet_NaN( ) throw( )
            {return 0;}
        static unsigned long signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_longeger = true;
        static const bool is_modulo = true;
        static const bool is_signed = false;

        // misc
        static unsigned long epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const long radix = 2;
        static const bool traps = false;

        // exponent
        static const long max_exponent = 0;
        static const long max_exponent10 = 0;
        static const long min_exponent = 0;
        static const long min_exponent10 = 0;

        // rounding
        static unsigned long round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<long long>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static long long lowest() throw()
            {return LLONG_MIN;}
        static long long max( ) throw( )
            {return LLONG_MAX;}
        static long long min( ) throw( )
            {return LLONG_MIN;}

        // infinity
        static const bool has_infinity = false;
        static long long infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static long long denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const long long digits = sizeof(long long) * CHAR_BIT - (LLONG_MIN != 0 ? 1 : 0);
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const long long digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static long long quiet_NaN( ) throw( )
            {return 0;}
        static long long signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;
        static const bool is_signed = LLONG_MIN != 0;

        // misc
        static long long epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const long long radix = 2;
        static const bool traps = false;

        // exponent
        static const long long max_exponent = 0;
        static const long long max_exponent10 = 0;
        static const long long min_exponent = 0;
        static const long long min_exponent10 = 0;

        // rounding
        static long long round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<unsigned long long>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static unsigned long long lowest() throw()
            {return 0;}
        static unsigned long long max( ) throw( )
            {return ULLONG_MAX;}
        static unsigned long long min( ) throw( )
            {return 0;}

        // infinity
        static const bool has_infinity = false;
        static unsigned long long infinity( ) throw( )
            {return 0;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_absent;
        static const bool has_denorm_loss = false;
        static unsigned long long denorm_min( ) throw( )
            {return 0;}

        // Digits
        static const long long digits = sizeof(unsigned long long) * CHAR_BIT;
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const long long digits10 = digits * 643 / 2136;

        // NaN
        static const bool has_quiet_NaN = false;
        static const bool has_signaling_NaN = false;
        static unsigned long long quiet_NaN( ) throw( )
            {return 0;}
        static unsigned long long signaling_NaN( ) throw( )
            {return 0;}

        // Information
        static const bool is_exact = true;
        static const bool is_iec559 = false;
        static const bool is_integer = true;
        static const bool is_modulo = true;
        static const bool is_signed = false;

        // misc
        static unsigned long long epsilon( ) throw( )
            {return 0;}
        static const int max_digits10 = 0;
        static const long long radix = 2;
        static const bool traps = false;

        // exponent
        static const long long max_exponent = 0;
        static const long long max_exponent10 = 0;
        static const long long min_exponent = 0;
        static const long long min_exponent10 = 0;

        // rounding
        static unsigned long long round_error( ) throw( )
            {return 0;}
        static const float_round_style round_style = round_toward_zero;
        static const bool tinyness_before = false;
    };

    template<> class numeric_limits<float>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static float lowest() throw()
            {return -FLT_MAX;}
        static float max( ) throw( )
            {return FLT_MAX;}
        static float min( ) throw( )
            {return FLT_MIN;}

        // infinity
        static const bool has_infinity = true;
        static float infinity( ) throw( )
            //{return _FInf._Float;}
        {
            static const unsigned __inf_bytes = 0x7f800000;
            return *(float*)&__inf_bytes;
        }

        // Denormalization
        static const float_denorm_style has_denorm = denorm_present;
        static const bool has_denorm_loss = true;
        static float denorm_min( ) throw( )
            {return _FDenorm._Float;}

        // Digits
        static const int digits = FLT_MANT_DIG;
        static const int digits10 = FLT_DIG;

        // NaN
        static const bool has_quiet_NaN = true;
        static const bool has_signaling_NaN = true;
        static float quiet_NaN( ) throw( )
            {return _FNan._Float;}
        static float signaling_NaN( ) throw( )
            {return _FSnan._Float;}

        // Information
        static const bool is_exact = false;
        static const bool is_iec559 = true;
        static const bool is_integer = false;
        static const bool is_modulo = false;
        static const bool is_signed = true;

        // misc
        static float epsilon( ) throw( )
            {return FLT_EPSILON;}
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int max_digits10 = FLT_MANT_DIG * 643 / 2136;
        static const int radix = FLT_RADIX;
        static const bool traps = true;

        // exponent
        static const int max_exponent = FLT_MAX_EXP;
        static const int max_exponent10 = FLT_MAX_10_EXP;
        static const int min_exponent = FLT_MIN_EXP;
        static const int min_exponent10 = FLT_MIN_10_EXP;

        // rounding
        static float round_error( ) throw( )
            {return 0.5f;}
        static const float_round_style round_style = round_to_nearest;
        static const bool tinyness_before = true;
    };

    template<> class numeric_limits<double>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static double lowest() throw()
            {return -DBL_MAX;}
        static double max( ) throw( )
            {return DBL_MAX;}
        static double min( ) throw( )
            {return DBL_MIN;}

        // infinity
        static const bool has_infinity = true;
        static double infinity( ) throw( )
            {return _Inf._Double;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_present;
        static const bool has_denorm_loss = true;
        static double denorm_min( ) throw( )
            {return _Denorm._Double;}

        // Digits
        static const int digits = DBL_MANT_DIG;
        static const int digits10 = DBL_DIG;

        // NaN
        static const bool has_quiet_NaN = true;
        static const bool has_signaling_NaN = true;
        static double quiet_NaN( ) throw( )
            {return _Nan._Double;}
        static double signaling_NaN( ) throw( )
            {return _Snan._Double;}

        // Information
        static const bool is_exact = false;
        static const bool is_iec559 = true;
        static const bool is_integer = false;
        static const bool is_modulo = false;
        static const bool is_signed = true;

        // misc
        static double epsilon( ) throw( )
            {return DBL_EPSILON;}
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int max_digits10 = DBL_MANT_DIG * 643 / 2136;
        static const int radix = FLT_RADIX;
        static const bool traps = true;

        // exponent
        static const int max_exponent = DBL_MAX_EXP;
        static const int max_exponent10 = DBL_MAX_10_EXP;
        static const int min_exponent = DBL_MIN_EXP;
        static const int min_exponent10 = DBL_MIN_10_EXP;

        // rounding
        static double round_error( ) throw( )
            {return 0.5f;}
        static const float_round_style round_style = round_to_nearest;
        static const bool tinyness_before = true;
    };

    template<> class numeric_limits<long double>
    {
    public:
        static const bool is_specialized = true;

        // Bounding
        static const bool is_bounded = true;
        static long double lowest() throw()
            {return -LDBL_MAX;}
        static long double max( ) throw( )
            {return LDBL_MAX;}
        static long double min( ) throw( )
            {return DBL_MIN;}

        // infinity
        static const bool has_infinity = true;
        static long double infinity( ) throw( )
            {return _LInf._Long_double;}

        // Denormalization
        static const float_denorm_style has_denorm = denorm_present;
        static const bool has_denorm_loss = true;
        static long double denorm_min( ) throw( )
            {return _LDenorm._Long_double;}

        // Digits
        static const int digits = LDBL_MANT_DIG;
        static const int digits10 = LDBL_DIG;

        // NaN
        static const bool has_quiet_NaN = true;
        static const bool has_signaling_NaN = true;
        static long double quiet_NaN( ) throw( )
            {return _LNan._Long_double;}
        static long double signaling_NaN( ) throw( )
            {return _LSnan._Long_double;}

        // Information
        static const bool is_exact = false;
        static const bool is_iec559 = true;
        static const bool is_integer = false;
        static const bool is_modulo = false;
        static const bool is_signed = true;

        // misc
        static long double epsilon( ) throw( )
            {return LDBL_EPSILON;}
        // The fraction 643/2136 approximates log10(2) to 7 significant digits.
        static const int max_digits10 = FLT_MANT_DIG * 643 / 2136;
        static const int radix = FLT_RADIX;
        static const bool traps = true;

        // exponent
        static const int max_exponent = LDBL_MAX_EXP;
        static const int max_exponent10 = LDBL_MAX_10_EXP;
        static const int min_exponent = LDBL_MIN_EXP;
        static const int min_exponent10 = LDBL_MIN_10_EXP;

        // rounding
        static long double round_error( ) throw( )
            {return 0.5f;}
        static const float_round_style round_style = round_to_nearest;
        static const bool tinyness_before = true;
    };
}