<limits>namespace std {
enum float_round_style;
template<class T>
class numeric_limits;
};
Include the standard header <limits>
to define the template class numeric_limits.
Explicit specializations of this class describe many arithmetic
properties of the scalar types (other than pointers).
enum float_round_style {
round_indeterminate = -1,
round_toward_zero = 0,
round_to_nearest = 1,
round_toward_infinity = 2,
round_toward_neg_infinity = 3
};
The enumeration describes the various methods that an implementation can choose for rounding a floating-point value to an integer value:
round_indeterminate
-- rounding method cannot be determined round_toward_zero
-- round toward zero round_to_nearest
-- round to nearest integer round_toward_infinity
-- round away from zero round_toward_neg_infinity -- round
to more negative integer template<class T>
class numeric_limits {
public:
static const bool has_denorm = false;
static const bool has_denorm_loss = false;
static const bool has_infinity = false;
static const bool has_quiet_NaN = false;
static const bool has_signaling_NaN = false;
static const bool is_bounded = false;
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;
static const bool is_specialized = false;
static const bool tinyness_before = false;
static const bool traps = false;
static const float_round_style round_style =
round_toward_zero;
static const int digits = 0;
static const int digits10 = 0;
static const int max_exponent = 0;
static const int max_exponent10 = 0;
static const int min_exponent = 0;
static const int min_exponent10 = 0;
static const int radix = 0;
static T denorm_min() throw();
static T epsilon() throw();
static T infinity() throw();
static T max() throw();
static T min() throw();
static T quiet_NaN() throw();
static T round_error() throw();
static T signaling_NaN() throw();
};
The template class describes many arithmetic properties of its
parameter type T. The header defines explicit
specializations for the types wchar_t, bool,
char, signed char, unsigned char, short, unsigned short, int,
unsigned int, long, unsigned long, float, double, and long
double. For all these explicit specializations, the member is_specialized
is true, and all relevant members have meaningful values. The
program can supply additional explicit specializations.
For an arbitrary specialization, no members have
meaningful values. A member object that does not have a
meaningful value stores zero (or false) and a member function
that does not return a meaningful value returns T(0).
numeric_limits::denorm_minstatic T denorm_min() throw();
The function returns the minimum value for the type (which is
the same as min()
if has_denorm
is false).
numeric_limits::digitsstatic const int digits = 0;
The member stores the number of radix
digits that the type can represent without change (which is the
number of bits other than any sign bit for a predefined integer
type, or the number of mantissa digits for a predefined
floating-point type).
numeric_limits::digits10static const int digits10 = 0;
The member stores the number of decimal digits that the type can represent without change.
numeric_limits::epsilonstatic T epsilon() throw();
The function returns the difference between 1 and the smallest
value greater than 1 that is representable for the type (which is
the value FLT_EPSILON
for type float).
numeric_limits::has_denormstatic const bool has_denorm = false;
The member stores true for a floating-point type that has denormalized values (effectively a variable number of exponent bits).
numeric_limits::has_denorm_lossstatic const bool has_denorm_loss = false;
The member stores true for a type that determines whether a value has lost accuracy because it is delivered as a denormalized result (too small to represent as a normalized value) or because it is inexact (not the same as a result not subject to limitations of exponent range and precision), an option with IEC 559 floating-point representations that can affect some results.
numeric_limits::has_infinitystatic const bool has_infinity = false;
The member stores true for a type that has a representation
for positive infinity. True if is_iec559
is true.
numeric_limits::has_quiet_NaNstatic const bool has_quiet_NaN = false;
The member stores true for a type that has a representation
for a quiet NaN, an encoding that
is ``Not a Number'' which does not signal
its presence in an expression. True if is_iec559
is true.
numeric_limits::has_signaling_NaNstatic const bool has_signaling_NaN = false;
The member stores true for a type that has a representation
for a signaling NaN, an
encoding that is ``Not a Number'' which signals its presence in an
expression by reporting an exception. True if is_iec559
is true.
numeric_limits::infinitystatic T infinity() throw();
The function returns the representation of positive infinity
for the type. The return value is meaningful only if has_infinity
is true.
numeric_limits::is_boundedstatic const bool is_bounded = false;
The member stores true for a type that has a bounded set of representable values (which is the case for all predefined types).
numeric_limits::is_exactstatic const bool is_exact = false;
The member stores true for a type that has exact representations for all its values (which is the case for all predefined integer types). A fixed-point or rational representation is also considered exact, but not a floating-point representation.
numeric_limits::is_iec559static const bool is_iec559 = false;
The member stores true for a type that has a representation conforming to IEC 559, an international standard for representing floating-point values (also known as IEEE 754 in the USA).
numeric_limits::is_integerstatic const bool is_integer = false;
The member stores true for a type that has an integer representation (which is the case for all predefined integer types).
numeric_limits::is_modulostatic const bool is_modulo = false;
The member stores true for a type that has a modulo representation, where all results are reduced modulo some value (which is the case for all predefined unsigned integer types).
numeric_limits::is_signedstatic const bool is_signed = false;
The member stores true for a type that has a signed representation (which is the case for all predefined floating-point and signed integer types).
numeric_limits::is_specializedstatic const bool is_specialized = false;
The member stores true for a type that has an explicit
specialization defined for template class numeric_limits
(which is the case for all scalar types other than pointers).
numeric_limits::maxstatic T max() throw();
The function returns the maximum finite value for the type
(which is INT_MAX
for type int and FLT_MAX
for type float). The return value is meaningful if is_bounded
is true.
numeric_limits::max_exponentstatic const int max_exponent = 0;
The member stores the maximum positive integer such that the
type can represent as a finite value radix
raised to that power (which is the value FLT_MAX_EXP for
type float). Meaningful only for floating-point types.
numeric_limits::max_exponent10static const int max_exponent10 = 0;
The member stores the maximum positive integer such that the
type can represent as a finite value 10 raised to that power
(which is the value FLT_MAX_10_EXP
for type float). Meaningful only for floating-point types.
numeric_limits::minstatic T min() throw();
The function returns the minimum normalized value for the type
(which is INT_MIN
for type int and FLT_MIN
for type float). The return value is meaningful if is_bounded
is true or is_signed
is false.
numeric_limits::min_exponentstatic const int min_exponent = 0;
The member stores the minimum negative integer such that the
type can represent as a normalized value radix
raised to that power (which is the value FLT_MIN_EXP for
type float). Meaningful only for floating-point types.
numeric_limits::min_exponent10static const int min_exponent10 = 0;
The member stores the minimum negative integer such that the
type can represent as a normalized value 10 raised to that power
(which is the value FLT_MIN_10_EXP
for type float). Meaningful only for floating-point types.
numeric_limits::quiet_NaNstatic T quiet_NaN() throw();
The function returns a representation of a quiet NaN for the type. The
return value is meaningful only if has_quiet_NaN
is true.
numeric_limits::radixstatic const int radix = 0;
The member stores the base of the representation for the type
(which is 2 for the predefined integer types, and the base to
which the exponent is raised, or FLT_RADIX,
for the predefined floating-point types).
numeric_limits::round_errorstatic T round_error() throw();
The function returns the maximum rounding error for the type.
numeric_limits::round_stylestatic const float_round_style round_style =
round_toward_zero;
The member stores a value that describes the vaious methods that an implementation can choose for rounding a floating-point value to an integer value.
numeric_limits::signaling_NaNstatic T signaling_NaN() throw();
The function returns a representation of a signaling NaN for the
type. The return value is meaningful only if has_signaling_NaN
is true.
numeric_limits::tinyness_beforestatic const bool tinyness_before = false;
The member stores true for a type that determines whether a value is ``tiny'' (too small to represent as a normalized value) before rounding, an option with IEC 559 floating-point representations that can affect some results.
numeric_limits::trapsstatic const bool traps = false;
The member stores true for a type that generates some kind of signal to report certain arithmetic exceptions.
See also the Table of Contents .
Copyright © 1992-1996 by P.J. Plauger. All rights reserved.