1015 lines
22 KiB
Plaintext
1015 lines
22 KiB
Plaintext
// limits standard header
|
|
#pragma once
|
|
#ifndef _LIMITS_
|
|
#define _LIMITS_
|
|
#include <ymath.h>
|
|
#include <cfloat>
|
|
#include <climits>
|
|
#include <cmath>
|
|
#include <cwchar>
|
|
#include <xstddef>
|
|
|
|
#pragma pack(push,8)
|
|
#pragma warning(push,3)
|
|
_STD_BEGIN
|
|
|
|
// 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
|
|
// 64-bit long long (if _LONGLONG defined)
|
|
|
|
// ENUM float_denorm_style
|
|
typedef enum
|
|
{ // constants for different IEEE float denormalization styles
|
|
denorm_indeterminate = -1,
|
|
denorm_absent = 0,
|
|
denorm_present = 1}
|
|
float_denorm_style;
|
|
|
|
// ENUM float_round_style
|
|
typedef enum
|
|
{ // constants for different IEEE rounding styles
|
|
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 _CRTIMP2 _Num_base
|
|
{ // base for all types, with common defaults
|
|
_STCONS(float_denorm_style, has_denorm, denorm_absent);
|
|
_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
|
|
{ // numeric limits for arbitrary type _Ty (say little or nothing)
|
|
public:
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (_Ty(0));
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (_Ty(0));
|
|
}
|
|
};
|
|
|
|
// STRUCT _Num_int_base
|
|
struct _CRTIMP2 _Num_int_base
|
|
: public _Num_base
|
|
{ // base for integer types
|
|
_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 _CRTIMP2 _Num_float_base
|
|
: public _Num_base
|
|
{ // base for floating-point types
|
|
_STCONS(float_denorm_style, has_denorm, denorm_present);
|
|
_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 _CRTIMP2 numeric_limits<char>
|
|
: public _Num_int_base
|
|
{ // limits for type char
|
|
public:
|
|
typedef char _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (CHAR_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (CHAR_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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<_Bool>
|
|
template<> class _CRTIMP2 numeric_limits<_Bool>
|
|
: public _Num_int_base
|
|
{ // limits for type bool
|
|
public:
|
|
typedef bool _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (false);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (true);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
_STCONS(bool, is_modulo, false);
|
|
_STCONS(bool, is_signed, false);
|
|
_STCONS(int, digits, 1);
|
|
_STCONS(int, digits10, 0);
|
|
};
|
|
|
|
// CLASS numeric_limits<signed char>
|
|
template<> class _CRTIMP2 numeric_limits<signed char>
|
|
: public _Num_int_base
|
|
{ // limits for type signed char
|
|
public:
|
|
typedef signed char _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (SCHAR_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (SCHAR_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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 _CRTIMP2 numeric_limits<unsigned char>
|
|
: public _Num_int_base
|
|
{ // limits for type unsigned char
|
|
public:
|
|
typedef unsigned char _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (UCHAR_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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 _CRTIMP2 numeric_limits<short>
|
|
: public _Num_int_base
|
|
{ // limits for type short
|
|
public:
|
|
typedef short _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (SHRT_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (SHRT_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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 _CRTIMP2 numeric_limits<unsigned short>
|
|
: public _Num_int_base
|
|
{ // limits for type unsigned short
|
|
public:
|
|
typedef unsigned short _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (USHRT_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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);
|
|
};
|
|
|
|
#ifdef _NATIVE_WCHAR_T_DEFINED
|
|
// CLASS numeric_limits<wchar_t>
|
|
template<> class _CRTIMP2 numeric_limits<wchar_t>
|
|
: public _Num_int_base
|
|
{ // limits for type wchar_t
|
|
public:
|
|
typedef wchar_t _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (USHRT_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
_STCONS(bool, is_signed, false);
|
|
_STCONS(int, digits, CHAR_BIT * sizeof (wchar_t));
|
|
_STCONS(int, digits10, (CHAR_BIT * sizeof (wchar_t))
|
|
* 301L / 1000);
|
|
};
|
|
#endif
|
|
|
|
// CLASS numeric_limits<int>
|
|
template<> class _CRTIMP2 numeric_limits<int>
|
|
: public _Num_int_base
|
|
{ // limits for type int
|
|
public:
|
|
typedef int _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (INT_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (INT_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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 _CRTIMP2 numeric_limits<unsigned int>
|
|
: public _Num_int_base
|
|
{ // limits for type unsigned int
|
|
public:
|
|
typedef unsigned int _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (UINT_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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 _CRTIMP2 numeric_limits<long>
|
|
: public _Num_int_base
|
|
{ // limits for type long
|
|
public:
|
|
typedef long _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (LONG_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (LONG_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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 _CRTIMP2 numeric_limits<unsigned long>
|
|
: public _Num_int_base
|
|
{ // limits for type unsigned long
|
|
public:
|
|
typedef unsigned long _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (ULONG_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
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);
|
|
};
|
|
|
|
#ifdef _LONGLONG
|
|
// CLASS numeric_limits<_LONGLONG>
|
|
template<> class _CRTIMP2 numeric_limits<_LONGLONG>
|
|
: public _Num_int_base
|
|
{ // limits for type long long
|
|
public:
|
|
typedef _LONGLONG _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (-_LLONG_MAX - _C2);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (_LLONG_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
_STCONS(bool, is_signed, true);
|
|
_STCONS(int, digits, CHAR_BIT * sizeof (_LONGLONG) - 1);
|
|
_STCONS(int, digits10, (CHAR_BIT * sizeof (_LONGLONG) - 1)
|
|
* 301L / 1000);
|
|
};
|
|
|
|
// CLASS numeric_limits<_ULONGLONG>
|
|
template<> class _CRTIMP2 numeric_limits<_ULONGLONG>
|
|
: public _Num_int_base
|
|
{ // limits for type unsigned long long
|
|
public:
|
|
typedef _ULONGLONG _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (_ULLONG_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (0);
|
|
}
|
|
|
|
_STCONS(bool, is_signed, false);
|
|
_STCONS(int, digits, CHAR_BIT * sizeof (_ULONGLONG));
|
|
_STCONS(int, digits10, (CHAR_BIT * sizeof (_ULONGLONG))
|
|
* 301L / 1000);
|
|
};
|
|
#endif /* _LONGLONG */
|
|
|
|
// CLASS numeric_limits<float>
|
|
template<> class _CRTIMP2 numeric_limits<float>
|
|
: public _Num_float_base
|
|
{ // limits for type float
|
|
public:
|
|
typedef float _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (FLT_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (FLT_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (FLT_EPSILON);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0.5);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (_FDenorm._Float);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (_FInf._Float);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (_FNan._Float);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (_FSnan._Float);
|
|
}
|
|
|
|
_STCONS(int, digits, FLT_MANT_DIG);
|
|
_STCONS(int, digits10, FLT_DIG);
|
|
_STCONS(int, max_exponent, (int)FLT_MAX_EXP);
|
|
_STCONS(int, max_exponent10, (int)FLT_MAX_10_EXP);
|
|
_STCONS(int, min_exponent, (int)FLT_MIN_EXP);
|
|
_STCONS(int, min_exponent10, (int)FLT_MIN_10_EXP);
|
|
};
|
|
|
|
// CLASS numeric_limits<double>
|
|
template<> class _CRTIMP2 numeric_limits<double>
|
|
: public _Num_float_base
|
|
{ // limits for type double
|
|
public:
|
|
typedef double _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (DBL_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (DBL_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (DBL_EPSILON);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0.5);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (_Denorm._Double);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (_Inf._Double);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (_Nan._Double);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (_Snan._Double);
|
|
}
|
|
|
|
_STCONS(int, digits, DBL_MANT_DIG);
|
|
_STCONS(int, digits10, DBL_DIG);
|
|
_STCONS(int, max_exponent, (int)DBL_MAX_EXP);
|
|
_STCONS(int, max_exponent10, (int)DBL_MAX_10_EXP);
|
|
_STCONS(int, min_exponent, (int)DBL_MIN_EXP);
|
|
_STCONS(int, min_exponent10, (int)DBL_MIN_10_EXP);
|
|
};
|
|
|
|
// CLASS numeric_limits<long double>
|
|
template<> class _CRTIMP2 numeric_limits<long double>
|
|
: public _Num_float_base
|
|
{ // limits for type long double
|
|
public:
|
|
typedef long double _Ty;
|
|
|
|
static _Ty (__cdecl min)() _THROW0()
|
|
{ // return minimum value
|
|
return (LDBL_MIN);
|
|
}
|
|
|
|
static _Ty (__cdecl max)() _THROW0()
|
|
{ // return maximum value
|
|
return (LDBL_MAX);
|
|
}
|
|
|
|
static _Ty __cdecl epsilon() _THROW0()
|
|
{ // return smallest effective increment from 1.0
|
|
return (LDBL_EPSILON);
|
|
}
|
|
|
|
static _Ty __cdecl round_error() _THROW0()
|
|
{ // return largest rounding error
|
|
return (0.5);
|
|
}
|
|
|
|
static _Ty __cdecl denorm_min() _THROW0()
|
|
{ // return minimum denormalized value
|
|
return (_LDenorm._Long_double);
|
|
}
|
|
|
|
static _Ty __cdecl infinity() _THROW0()
|
|
{ // return positive infinity
|
|
return (_LInf._Long_double);
|
|
}
|
|
|
|
static _Ty __cdecl quiet_NaN() _THROW0()
|
|
{ // return non-signaling NaN
|
|
return (_LNan._Long_double);
|
|
}
|
|
|
|
static _Ty __cdecl signaling_NaN() _THROW0()
|
|
{ // return signaling NaN
|
|
return (_LSnan._Long_double);
|
|
}
|
|
|
|
_STCONS(int, digits, LDBL_MANT_DIG);
|
|
_STCONS(int, digits10, LDBL_DIG);
|
|
_STCONS(int, max_exponent, (int)LDBL_MAX_EXP);
|
|
_STCONS(int, max_exponent10, (int)LDBL_MAX_10_EXP);
|
|
_STCONS(int, min_exponent, (int)LDBL_MIN_EXP);
|
|
_STCONS(int, min_exponent10, (int)LDBL_MIN_10_EXP);
|
|
};
|
|
_STD_END
|
|
#pragma warning(pop)
|
|
#pragma pack(pop)
|
|
|
|
#endif /* _LIMITS_ */
|
|
|
|
/*
|
|
* Copyright (c) 1992-2001 by P.J. Plauger. ALL RIGHTS RESERVED.
|
|
* Consult your license regarding permissions and restrictions.
|
|
V3.10:0009 */
|