#undef __STL_DEFINE_INTEGER_LIMITS_MEMBER#undef __STL_DEFINE_FLOAT_LIMITS_MEMBER// Class numeric_limits// The unspecialized class.template<class _Tp> class numeric_limits : public _Numeric_limits_base<_Tp> {};// Specializations for all built-in integral types.#ifndef __STL_NO_BOOL__STL_TEMPLATE_NULLclass numeric_limits<bool>  : public _Integer_limits<bool, false, true, 1, false>{};#endif /* __STL_NO_BOOL */__STL_TEMPLATE_NULLclass numeric_limits<char>  : public _Integer_limits<char, CHAR_MIN, CHAR_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<signed char>  : public _Integer_limits<signed char, SCHAR_MIN, SCHAR_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<unsigned char>  : public _Integer_limits<unsigned char, 0, UCHAR_MAX>{};#ifdef __STL_HAS_WCHAR_T__STL_TEMPLATE_NULLclass numeric_limits<wchar_t>  : public _Integer_limits<wchar_t, INT_MIN, INT_MAX>{};#endif__STL_TEMPLATE_NULLclass numeric_limits<short>  : public _Integer_limits<short, SHRT_MIN, SHRT_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<unsigned short>  : public _Integer_limits<unsigned short, 0, USHRT_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<int>  : public _Integer_limits<int, INT_MIN, INT_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<unsigned int>  : public _Integer_limits<unsigned int, 0, UINT_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<long>  : public _Integer_limits<long, LONG_MIN, LONG_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<unsigned long>  : public _Integer_limits<unsigned long, 0, ULONG_MAX>{};#ifdef __STL_LONG_LONG// Some compilers have long long, but don't define the// LONGLONG_MIN and LONGLONG_MAX macros in limits.h.  This// assumes that long long is 64 bits.#if !defined(LONGLONG_MIN) && !defined(LONGLONG_MAX) \                           && !defined(ULONGLONG_MAX)#define ULONGLONG_MAX 0xffffffffffffffffLLU#define LONGLONG_MAX 0x7fffffffffffffffLL#define LONGLONG_MIN (-LONGLONG_MAX - 1LL)#endif__STL_TEMPLATE_NULLclass numeric_limits<long long>  : public _Integer_limits<long long, LONGLONG_MIN, LONGLONG_MAX>{};__STL_TEMPLATE_NULLclass numeric_limits<unsigned long long>  : public _Integer_limits<unsigned long long, 0, ULONGLONG_MAX>{};#endif /* __STL_LONG_LONG */// Specializations for all built-in floating-point type.__STL_TEMPLATE_NULL class numeric_limits<float>  : public _Floating_limits<float,                             FLT_MANT_DIG,   // Binary digits of precision                            FLT_DIG,        // Decimal digits of precision                            FLT_MIN_EXP,    // Minimum exponent                            FLT_MAX_EXP,    // Maximum exponent                            FLT_MIN_10_EXP, // Minimum base 10 exponent                            FLT_MAX_10_EXP, // Maximum base 10 exponent                            true,           // conforms to iec559                            round_to_nearest>{public:  static float min() __STL_NOTHROW { return FLT_MIN; }  static float denorm_min() __STL_NOTHROW { return FLT_MIN; }  static float max() __STL_NOTHROW { return FLT_MAX; }  static float epsilon() __STL_NOTHROW { return FLT_EPSILON; }  static float round_error() __STL_NOTHROW { return 0.5f; } // Units: ulps.  static float infinity() __STL_NOTHROW;  static float quiet_NaN() __STL_NOTHROW;  static float signaling_NaN() __STL_NOTHROW;};__STL_TEMPLATE_NULL class numeric_limits<double>  : public _Floating_limits<double,                             DBL_MANT_DIG,   // Binary digits of precision                            DBL_DIG,        // Decimal digits of precision                            DBL_MIN_EXP,    // Minimum exponent                            DBL_MAX_EXP,    // Maximum exponent                            DBL_MIN_10_EXP, // Minimum base 10 exponent                            DBL_MAX_10_EXP, // Maximum base 10 exponent                            true,           // conforms to iec559                            round_to_nearest>{public:  static double min() __STL_NOTHROW { return DBL_MIN; }  static double denorm_min() __STL_NOTHROW { return DBL_MIN; }  static double max() __STL_NOTHROW { return DBL_MAX; }  static double epsilon() __STL_NOTHROW { return DBL_EPSILON; }  static double round_error() __STL_NOTHROW { return 0.5; } // Units: ulps.  static double infinity() __STL_NOTHROW;  static double quiet_NaN() __STL_NOTHROW;  static double signaling_NaN() __STL_NOTHROW;};__STL_TEMPLATE_NULL class numeric_limits<long double>  : public _Floating_limits<long double,                             LDBL_MANT_DIG,  // Binary digits of precision                            LDBL_DIG,       // Decimal digits of precision                            LDBL_MIN_EXP,   // Minimum exponent                            LDBL_MAX_EXP,   // Maximum exponent                            LDBL_MIN_10_EXP,// Minimum base 10 exponent                            LDBL_MAX_10_EXP,// Maximum base 10 exponent                            false,          // Doesn't conform to iec559                            round_to_nearest>{public:  static long double min() __STL_NOTHROW { return LDBL_MIN; }  static long double denorm_min() __STL_NOTHROW { return LDBL_MIN; }  static long double max() __STL_NOTHROW { return LDBL_MAX; }  static long double epsilon() __STL_NOTHROW { return LDBL_EPSILON; }  static long double round_error() __STL_NOTHROW { return 4; } // Units: ulps.  static long double infinity() __STL_NOTHROW;  static long double quiet_NaN() __STL_NOTHROW;  static long double signaling_NaN() __STL_NOTHROW;};// We write special values (Inf and NaN) as bit patterns and // cast the the appropriate floating-point types. #if defined(_MIPSEB)// Big-endian MIPS.  float is 32 bits, double 64, long double 128.#define _Define_float(__f, __h, __l)                                     \   inline float numeric_limits<float>::__f() __STL_NOTHROW {             \     static const unsigned short __x[2] = { __h, __l };                  \     return *reinterpret_cast<const float*>(__x); }#define _Define_double(__f, __h, __l)                                    \   inline double numeric_limits<double>::__f() __STL_NOTHROW {           \     static const unsigned short __x[4] = { __h, __l };                  \     return *reinterpret_cast<const double*>(__x); }#define _Define_ldouble(__f, __h, __l)                                   \   inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \     static const unsigned short __x[8] = { __h, __l };                  \     return *reinterpret_cast<const long double*>(__x); }_Define_float(infinity, 0x7f80, 0)_Define_float(quiet_NaN, 0x7f81, 0)_Define_float(signaling_NaN, 0x7fc1, 0)_Define_double(infinity, 0x7ff0, 0)_Define_double(quiet_NaN, 0x7ff1, 0)_Define_double(signaling_NaN, 0x7ff9, 0)_Define_ldouble(infinity, 0x7ff0, 0)_Define_ldouble(quiet_NaN, 0x7ff1, 0)_Define_ldouble(signaling_NaN, 0x7ff9, 0)#elif defined(__i386) || defined(_M_IX86)// Little-endian ia32.  float is 32 bits, double 64, long double 80.#define _Define_float(__f, __h, __l)                                     \   inline float numeric_limits<float>::__f() __STL_NOTHROW {             \     static const unsigned short __x[2] = { __l, __h };                  \     return *reinterpret_cast<const float*>(__x); }#define _Define_double(__f, __h, __l)                                    \   inline double numeric_limits<double>::__f() __STL_NOTHROW {           \     static const unsigned short __x[4] = { 0, 0, __l, __h };            \     return *reinterpret_cast<const double*>(__x); }#define _Define_ldouble(__f, __h, __l)                                   \   inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \     static const unsigned short __x[5] = { 0, 0, 0, __l, __h };         \     return *reinterpret_cast<const long double*>(__x); }_Define_float(infinity, 0x7f80, 0)_Define_float(quiet_NaN, 0x7fa0, 0)_Define_float(signaling_NaN, 0x7fc0, 0)_Define_double(infinity, 0x7ff0, 0)_Define_double(quiet_NaN, 0x7ff4, 0)_Define_double(signaling_NaN, 0x7ff8, 0)_Define_ldouble(infinity, 0x7fff, 0x8000)_Define_ldouble(quiet_NaN, 0x7fff, 0xa000)_Define_ldouble(signaling_NaN, 0x7fff, 0xc000)#else /* This is an architecture we don't know how to handle.  Return some    obviously wrong values. */#define _Define_float(__f)                                               \   inline float numeric_limits<float>::__f() __STL_NOTHROW {             \     return 0; }#define _Define_double(__f)                                              \   inline double numeric_limits<double>::__f() __STL_NOTHROW {           \     return 0; }#define _Define_ldouble(__f)                                             \   inline long double numeric_limits<long double>::__f() __STL_NOTHROW { \     return 0; }_Define_float(infinity)_Define_float(quiet_NaN)_Define_float(signaling_NaN)_Define_double(infinity)_Define_double(quiet_NaN)_Define_double(signaling_NaN)_Define_ldouble(infinity)_Define_ldouble(quiet_NaN)_Define_ldouble(signaling_NaN)   #endif#undef _Define_float#undef _Define_double#undef _Define_ldouble__STL_END_NAMESPACE#endif /* __SGI_CPP_LIMITS */// Local Variables:// mode:C++// End: