Listing 2: The header <limits>

// limits standard header
#ifndef _LIMITS_
#define _LIMITS_
#include <cfloat>
#include <climits>
#include <cmath>
#include <cwchar>

//    ASSUMES:
//    wraparound 2's complement integer arithmetic w/o traps
//    all CHAR_BITs of each byte used by integers
//    IEC559 (IEEE 754) floating-point arithmetic
//    floating-point errors can trap
//    tinyness detected before floating-point rounding

namespace std {

#if _HAS_STATIC_CONST_INIT
 #define _STCONS(T, name, val)    static const T name = val
#else
 #define _STCONS(T, name, val)    enum {name = val}
#endif /* _HAS_STATIC_CONST_INIT */

        // ENUM float_round_style
typedef enum {
    round_indeterminate = -1, round_toward_zero = 0,
    round_to_nearest = 1, round_toward_infinity = 2,
    round_toward_neg_infinity = 3} float_round_style;
        // STRUCT _Num_base
struct _Num_base {
    _STCONS(bool, has_denorm, false);
    _STCONS(bool, has_denorm_loss, false);
    _STCONS(bool, has_infinity, false);
    _STCONS(bool, has_quiet_NaN, false);
    _STCONS(bool, has_signaling_NaN, false);
    _STCONS(bool, is_bounded, false);
    _STCONS(bool, is_exact, false);
    _STCONS(bool, is_iec559, false);
    _STCONS(bool, is_integer, false);
    _STCONS(bool, is_modulo, false);
    _STCONS(bool, is_signed, false);
    _STCONS(bool, is_specialized, false);
    _STCONS(bool, tinyness_before, false);
    _STCONS(bool, traps, false);
    _STCONS(float_round_style, round_style, round_toward_zero);
    _STCONS(int, digits, 0);
    _STCONS(int, digits10, 0);
    _STCONS(int, max_exponent, 0);
    _STCONS(int, max_exponent10, 0);
    _STCONS(int, min_exponent, 0);
    _STCONS(int, min_exponent10, 0);
    _STCONS(int, radix, 0);
    };
        // TEMPLATE CLASS numeric_limits
template<class _Ty>
    class numeric_limits : public _Num_base {
public:
    static _Ty (min)() throw()
        {return (_Ty(0)); }
    static _Ty (max)() throw()
        {return (_Ty(0)); }
    static _Ty epsilon() throw()
        {return (_Ty(0)); }
    static _Ty round_error() throw()
        {return (_Ty(0)); }
    static _Ty denorm_min() throw()
        {return (_Ty(0)); }
    static _Ty infinity() throw()
        {return (_Ty(0)); }
    static _Ty quiet_NaN() throw()
        {return (_Ty(0)); }
    static _Ty signaling_NaN() throw()
        {return (_Ty(0)); }
    };
        // STRUCT _Num_int_base
struct _Num_int_base : public _Num_base {
    _STCONS(bool, is_bounded, true);
    _STCONS(bool, is_exact, true);
    _STCONS(bool, is_integer, true);
    _STCONS(bool, is_modulo, true);
    _STCONS(bool, is_specialized, true);
    _STCONS(int, radix, 2);
    };
        // STRUCT _Num_float_base
struct _Num_float_base : public _Num_base {
    _STCONS(bool, has_denorm, true);
    _STCONS(bool, has_denorm_loss, true);
    _STCONS(bool, has_infinity, true);
    _STCONS(bool, has_quiet_NaN, true);
    _STCONS(bool, has_signaling_NaN, true);
    _STCONS(bool, is_bounded, true);
    _STCONS(bool, is_exact, false);
    _STCONS(bool, is_iec559, true);
    _STCONS(bool, is_integer, false);
    _STCONS(bool, is_modulo, false);
    _STCONS(bool, is_signed, true);
    _STCONS(bool, is_specialized, true);
    _STCONS(bool, tinyness_before, true);
    _STCONS(bool, traps, true);
    _STCONS(float_round_style, round_style, round_to_nearest);
    _STCONS(int, radix, FLT_RADIX);
    };
        // CLASS numeric_limits<char>
template<> class numeric_limits<char>
    : public _Num_int_base {
public:
    typedef char _Ty;
    static _Ty (min)() throw()
        {return (CHAR_MIN); }
    static _Ty (max)() throw()
        {return (CHAR_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, CHAR_MIN < 0);
    _STCONS(int, digits, CHAR_BIT - (CHAR_MIN < 0 ? 1 : 0));
    _STCONS(int, digits10, (CHAR_BIT - (CHAR_MIN < 0 ? 1 : 0))
        * 301L / 1000);
    };
        // CLASS numeric_limits<wchar_t>
template<> class numeric_limits<wchar_t>
    : public _Num_int_base {
public:
    typedef wchar_t _Ty;
    static _Ty (min)() throw()
        {return (WCHAR_MIN); }
    static _Ty (max)() throw()
        {return (WCHAR_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, WCHAR_MIN < 0);
    _STCONS(int, digits, CHAR_BIT * sizeof (wchar_t)
        - (WCHAR_MIN < 0 ? 1 : 0));
    _STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t)
        - (WCHAR_MIN < 0 ? 1 : 0)) * 301L / 1000);
    };
        // CLASS numeric_limits<bool>
template<> class numeric_limits<bool>
    : public _Num_int_base {
public:
    typedef bool _Ty;
    static _Ty (min)() throw()
        {return (false); }
    static _Ty (max)() throw()
        {return (true); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, false);
    _STCONS(int, digits, 1);
    _STCONS(int, digits10, 0);
    };
        // CLASS numeric_limits<signed char>
template<> class numeric_limits<signed char>
    : public _Num_int_base {
public:
    typedef signed char _Ty;
    static _Ty (min)() throw()
        {return (SCHAR_MIN); }
    static _Ty (max)() throw()
        {return (SCHAR_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, true);
    _STCONS(int, digits, CHAR_BIT - 1);
    _STCONS(int, digits10, (CHAR_BIT - 1) * 301L / 1000);
    };
        // CLASS numeric_limits<unsigned char>
template<> class numeric_limits<unsigned char>
    : public _Num_int_base {
public:
    typedef unsigned char _Ty;
    static _Ty (min)() throw()
        {return (0); }
    static _Ty (max)() throw()
        {return (UCHAR_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, false);
    _STCONS(int, digits, CHAR_BIT);
    _STCONS(int, digits10, (CHAR_BIT) * 301L / 1000);
    };
        // CLASS numeric_limits<short>
template<> class numeric_limits<short>
    : public _Num_int_base {
public:
    typedef short _Ty;
    static _Ty (min)() throw()
        {return (SHRT_MIN); }
    static _Ty (max)() throw()
        {return (SHRT_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, true);
    _STCONS(int, digits, CHAR_BIT * sizeof (short) - 1);
    _STCONS(int, digits10, (CHAR_BIT * sizeof (short) - 1)
        * 301L / 1000);
    };
        // CLASS numeric_limits<unsigned short>
template<> class numeric_limits<unsigned short>
    : public _Num_int_base {
public:
    typedef unsigned short _Ty;
    static _Ty (min)() throw()
        {return (0); }
    static _Ty (max)() throw()
        {return (USHRT_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, false);
    _STCONS(int, digits, CHAR_BIT * sizeof (unsigned short));
    _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned short))
        * 301L / 1000);
    };
        // CLASS numeric_limits<int>
template<> class numeric_limits<int>
    : public _Num_int_base {
public:
    typedef int _Ty;
    static _Ty (min)() throw()
        {return (INT_MIN); }
    static _Ty (max)() throw()
        {return (INT_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, true);
    _STCONS(int, digits, CHAR_BIT * sizeof (int) - 1);
    _STCONS(int, digits10, (CHAR_BIT * sizeof (int) - 1)
        * 301L / 1000);
    };
        // CLASS numeric_limits<unsigned int>
template<> class numeric_limits<unsigned int>
    : public _Num_int_base {
public:
    typedef unsigned int _Ty;
    static _Ty (min)() throw()
        {return (0); }
    static _Ty (max)() throw()
        {return (UINT_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, false);
    _STCONS(int, digits, CHAR_BIT * sizeof (unsigned int));
    _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned int))
        * 301L / 1000);
    };
        // CLASS numeric_limits<long>
template<> class numeric_limits<long>
    : public _Num_int_base {
public:
    typedef long _Ty;
    static _Ty (min)() throw()
        {return (LONG_MIN); }
    static _Ty (max)() throw()
        {return (LONG_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, true);
    _STCONS(int, digits, CHAR_BIT * sizeof (long) - 1);
    _STCONS(int, digits10, (CHAR_BIT * sizeof (long) - 1)
        * 301L / 1000);
    };
        // CLASS numeric_limits<unsigned long>
template<> class numeric_limits<unsigned long>
    : public _Num_int_base {
public:
    typedef unsigned long _Ty;
    static _Ty (min)() throw()
        {return (0); }
    static _Ty (max)() throw()
        {return (ULONG_MAX); }
    static _Ty epsilon() throw()
        {return (0); }
    static _Ty round_error() throw()
        {return (0); }
    static _Ty denorm_min() throw()
        {return (0); }
    static _Ty infinity() throw()
        {return (0); }
    static _Ty quiet_NaN() throw()
        {return (0); }
    static _Ty signaling_NaN() throw()
        {return (0); }
    _STCONS(bool, is_signed, false);
    _STCONS(int, digits, CHAR_BIT * sizeof (unsigned long));
    _STCONS(int, digits10, (CHAR_BIT * sizeof (unsigned long))
        * 301L / 1000);
    };
        // CLASS numeric_limits<float>
template<> class numeric_limits<float>
    : public _Num_float_base {
public:
    typedef float _Ty;
    static _Ty (min)() throw()
        {return (FLT_MIN); }
    static _Ty (max)() throw()
        {return (FLT_MAX); }
    static _Ty epsilon() throw()
        {return (FLT_EPSILON); }
    static _Ty round_error() throw()
        {return (0.5); }
    static _Ty denorm_min() throw()
        {return (_FDenorm._F); }
    static _Ty infinity() throw()
        {return (_FInf._F); }
    static _Ty quiet_NaN() throw()
        {return (_FNan._F); }
    static _Ty signaling_NaN() throw()
        {return (_FSnan._F); }
    _STCONS(int, digits, FLT_MANT_DIG);
    _STCONS(int, digits10, FLT_DIG);
    _STCONS(int, max_exponent, FLT_MAX_EXP);
    _STCONS(int, max_exponent10, FLT_MAX_10_EXP);
    _STCONS(int, min_exponent, FLT_MIN_EXP);
    _STCONS(int, min_exponent10, FLT_MIN_10_EXP);
    };
        // CLASS numeric_limits<double>
template<> class numeric_limits<double>
    : public _Num_float_base {
public:
    typedef double _Ty;
    static _Ty (min)() throw()
        {return (DBL_MIN); }
    static _Ty (max)() throw()
        {return (DBL_MAX); }
    static _Ty epsilon() throw()
        {return (DBL_EPSILON); }
    static _Ty round_error() throw()
        {return (0.5); }
    static _Ty denorm_min() throw()
        {return (_Denorm._D); }
    static _Ty infinity() throw()
        {return (_Inf._D); }
    static _Ty quiet_NaN() throw()
        {return (_Nan._D); }
    static _Ty signaling_NaN() throw()
        {return (_Snan._D); }
    _STCONS(int, digits, DBL_MANT_DIG);
    _STCONS(int, digits10, DBL_DIG);
    _STCONS(int, max_exponent, DBL_MAX_EXP);
    _STCONS(int, max_exponent10, DBL_MAX_10_EXP);
    _STCONS(int, min_exponent, DBL_MIN_EXP);
    _STCONS(int, min_exponent10, DBL_MIN_10_EXP);
    };
        // CLASS numeric_limits<long double>
template<> class numeric_limits<long double>
    : public _Num_float_base {
public:
    typedef long double _Ty;
    static _Ty (min)() throw()
        {return (LDBL_MIN); }
    static _Ty (max)() throw()
        {return (LDBL_MAX); }
    static _Ty epsilon() throw()
        {return (LDBL_EPSILON); }
    static _Ty round_error() throw()
        {return (0.5); }
    static _Ty denorm_min() throw()
        {return (_LDenorm._L); }
    static _Ty infinity() throw()
        {return (_LInf._L); }
    static _Ty quiet_NaN() throw()
        {return (_LNan._L); }
    static _Ty signaling_NaN() throw()
        {return (_LSnan._L); }
    _STCONS(int, digits, LDBL_MANT_DIG);
    _STCONS(int, digits10, LDBL_DIG);
    _STCONS(int, max_exponent, LDBL_MAX_EXP);
    _STCONS(int, max_exponent10, LDBL_MAX_10_EXP);
    _STCONS(int, min_exponent, LDBL_MIN_EXP);
    _STCONS(int, min_exponent10, LDBL_MIN_10_EXP);
    };

    };    // end of namespace std
#endif /* _LIMITS_ */
//End of File