vnl_numeric_limits< T > Class Template Reference

#include <vnl_numeric_limits.h>

List of all members.

Static Public Methods
T	min ()
T	max ()
T	epsilon ()
T	round_error ()
T	infinity ()
T	quiet_NaN ()
T	signaling_NaN ()
T	denorm_min ()
Static Public Attributes
const bool	is_specialized
const int	digits
const int	digits10
const bool	is_signed
const bool	is_integer
const bool	is_exact
const int	radix
const int	min_exponent
const int	min_exponent10
const int	max_exponent
const int	max_exponent10
const bool	has_infinity
const bool	has_quiet_NaN
const bool	has_signaling_NaN
const bool	has_denorm
const bool	is_iec559
const bool	is_bounded
const bool	is_modulo
const bool	traps
const bool	tinyness_before
const vnl_float_round_style	round_style

template<class T>
class vnl_numeric_limits< T >

---

Member Function Documentation

template<class T> T vnl_numeric_limits< T >::denorm_min (    )  [static]

Minimum positive denormalized value. Meaningful for all floating point types. In specializations for which has_denorm == false, returns the minimum positive normalized value. For types with has_denorm == false, the member denorm_min() shall return the same value as the member min().

template<class T> T vnl_numeric_limits< T >::epsilon (    )  [static]

Machine epsilon:. The difference between 1 and the least value greater than 1 that is representable. Equivalent to FLT_EPSILON, DBL_EPSILON, LDBL_EPSILON. Meaningful only for floating point types.

template<class T> T vnl_numeric_limits< T >::infinity (    )  [static]

Representation of positive infinity, if available.

template<class T> T vnl_numeric_limits< T >::max (    )  [static]

Maximum finite value. Equivalent to CHAR_MAX, SHRT_MAX, FLT_MAX, DBL_MAX, etc. Meaningful for all specializations in which is_bounded == true.

template<class T> T vnl_numeric_limits< T >::min (    )  [static]

Minimum finite value. (Equivalent to CHAR_MIN, SHRT_MIN, FLT_MIN, DBL_MIN, etc) For floating types with denormalization, returns the minimum positive normalized value, denorm_min(). Meaningful for all specializations in which is_bounded == true, or is_bounded == false && is_signed == false.

template<class T> T vnl_numeric_limits< T >::quiet_NaN (    )  [static]

Representation of a quiet ``Not a Number,'' if available.

template<class T> T vnl_numeric_limits< T >::round_error (    )  [static]

Measure of the maximum rounding error. This has a precise definition in the Language Independent Arithmetic (LIA-1) standard. Required by LIA-1.

template<class T> T vnl_numeric_limits< T >::signaling_NaN (    )  [static]

Representation of a signaling ``Not a Number,'' if available.

---

Member Data Documentation

template<class T> const int vnl_numeric_limits< T >::digits [static]

Number of radix digits which can be represented without change. For built-in integer types, the number of non-sign bits in the representation. For floating point types, the number of radix digits in the mantissa. Equivalent to FLT_MANT_DIG, DBL_MANT_DIG, LDBL_MANT_DIG. Definition at line 65 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< unsigned long >::epsilon(), vnl_numeric_limits< long >::epsilon(), vnl_numeric_limits< long >::round_error(), vnl_numeric_limits< unsigned char >::round_error(), and vnl_numeric_limits< vnl_tmp_signed32 >::round_error().

template<class T> const int vnl_numeric_limits< T >::digits10 [static]

Number of base 10 digits which can be represented without change. Equivalent to FLT_DIG, DBL_DIG, LDBL_DIG. Meaningful for all specializations in which is_bounded == true. Definition at line 71 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< unsigned short >::epsilon(), vnl_numeric_limits< unsigned long >::epsilon(), and vnl_numeric_limits< long >::round_error().

template<class T> const bool vnl_numeric_limits< T >::has_denorm [static]

True if the type allows denormalized values (variable number of exponent. bits). Meaningful only for flotaing point types. Definition at line 158 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::has_infinity [static]

True if the type has a representation for positive infinity. Meaningful only for floating point types. Shall be true for all specializations in which is_iec559 == true. Definition at line 138 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< unsigned char >::denorm_min(), vnl_numeric_limits< vnl_tmp_signed32 >::denorm_min(), vnl_numeric_limits< unsigned short >::infinity(), vnl_numeric_limits< unsigned long >::infinity(), and vnl_numeric_limits< long >::infinity().

template<class T> const bool vnl_numeric_limits< T >::has_quiet_NaN [static]

True if the type has a representation for a quiet (non-signaling). ``Not a Number.''. RLIA Meaningful only for floating point types. Shall be true for all specializations in which is_iec559 == true. Definition at line 145 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< long >::denorm_min(), vnl_numeric_limits< unsigned short >::infinity(), and vnl_numeric_limits< unsigned long >::infinity().

template<class T> const bool vnl_numeric_limits< T >::has_signaling_NaN [static]

True if the type has a representation for a signaling. ``Not a Number.''. Meaningful only for floating point types. Shall be true for all specializations in which is_iec559 == true. Definition at line 152 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< unsigned short >::denorm_min(), and vnl_numeric_limits< unsigned long >::denorm_min().

template<class T> const bool vnl_numeric_limits< T >::is_bounded [static]

True if the set of values representable by the type is finite. All built-in types are bounded, this member would be false for arbitrary precision types. Definition at line 191 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::is_exact [static]

True if the type uses an exact representation. All integer types are exact, but not vice versa. For example, rational and fixed-exponent representations are exact but not integer. Definition at line 85 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::is_iec559 [static]

True if and only if the type adheres to IEC 559 standard. International Electrotechnical Commission standard 559 is the same as IEEE 754. Definition at line 185 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::is_integer [static]

Definition at line 78 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::is_modulo [static]

True if the type is modulo.\ A type is modulo if it is possible to. add two positive numbers and have a result which wraps around to a third number which is less. Generally, this is false for floating types, true for unsigned integers, and true for signed integers on most machines. Definition at line 199 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::is_signed [static]

True if the type is signed. Definition at line 75 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< unsigned short >::round_error(), and vnl_numeric_limits< unsigned long >::round_error().

template<class T> const bool vnl_numeric_limits< T >::is_specialized [static]

Distingishes between scalar types, whixh have specialisations, and non-scalar types, which don't. Definition at line 40 of file vnl_numeric_limits.h.

template<class T> const int vnl_numeric_limits< T >::max_exponent [static]

Maximum positive integer such that radix raised to that power is in. range. Equivalent to FLT_MAX_EXP, DBL_MAX_EXP, LDBL_MAX_EXP. Meaningful only for floating point types. Definition at line 126 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< short >::infinity(), vnl_numeric_limits< long >::infinity(), vnl_numeric_limits< unsigned char >::infinity(), and vnl_numeric_limits< vnl_tmp_signed32 >::infinity().

template<class T> const int vnl_numeric_limits< T >::max_exponent10 [static]

Maximum positive integer such that 10 raised to that power is in. range. Equivalent to FLT_MAX_10_EXP, DBL_MAX_10_EXP, LDBL_MAX_10_EXP. Meaningful only for floating point types. Definition at line 132 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< float >::denorm_min(), vnl_numeric_limits< short >::denorm_min(), vnl_numeric_limits< unsigned short >::infinity(), vnl_numeric_limits< unsigned long >::infinity(), vnl_numeric_limits< long >::infinity(), vnl_numeric_limits< unsigned char >::infinity(), and vnl_numeric_limits< vnl_tmp_signed32 >::infinity().

template<class T> const int vnl_numeric_limits< T >::min_exponent [static]

Minimum negative integer such that radix raised to that power is in. range. Equivalent to FLT_MIN_EXP, DBL_MIN_EXP, LDBL_MIN_EXP. Meaningful only for floating point types. Definition at line 114 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< short >::infinity().

template<class T> const int vnl_numeric_limits< T >::min_exponent10 [static]

Minimum negative integer such that 10 raised to that power is in. range. Equivalent to FLT_MIN_10_EXP, DBL_MIN_10_EXP, LDBL_MIN_10_EXP. Meaningful only for floating point types. Definition at line 120 of file vnl_numeric_limits.h. Referenced by vnl_numeric_limits< short >::infinity(), vnl_numeric_limits< unsigned char >::infinity(), and vnl_numeric_limits< vnl_tmp_signed32 >::infinity().

template<class T> const int vnl_numeric_limits< T >::radix [static]

For floating types, specifies the base or radix of the exponent representation (often 2). Equivalent to FLT_RADIX. For integer types, specifies the base of the representation - distinguishes types with bases other than 2 (e.g. BCD). Definition at line 93 of file vnl_numeric_limits.h.

template<class T> const vnl_float_round_style vnl_numeric_limits< T >::round_style [static]

The rounding style for the type.\ Equivalent to FLT_ROUNDS. Specializations for integer types shall return round_toward_zero. Definition at line 212 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::tinyness_before [static]

True if tinyness is detected before rounding.\ Refer to IEC 559. Definition at line 207 of file vnl_numeric_limits.h.

template<class T> const bool vnl_numeric_limits< T >::traps [static]

True if trapping is implemented for the type. Definition at line 203 of file vnl_numeric_limits.h.

---

The documentation for this class was generated from the following file:

• vnl_numeric_limits.h

---