Standard C++ LibraryCopyright 1996, Rogue Wave Software, Inc.

NAME

  numeric_limits  - A class for representing information about scalar types.

SPECIALIZATIONS

  numeric_limits<float>
  numeric_limits<double>
  numeric_limits<long double>
  numeric_limits<short>
  numeric_limits<unsigned short>
  numeric_limits<int>
  numeric_limits<unsigned int>
  numeric_limits<long>
  numeric_limits<unsigned long>
  numeric_limits<char>
  numeric_limits<wchar_t>
  numeric_limits<unsigned char>
  numeric_limits<signed char>
  numeric_limits<bool>

SYNOPSIS

  #include <limits>

  template <class T>
  class numeric_limits ;

DESCRIPTION

  numeric_limits is a class for representing information about scalar types.
  Specializations are provided for each fundamental type, both floating point
  and integer, including bool.

  This class encapsulates information that is contained in the <climits> and
  <cfloat> headers, as well as providing additional information that is not
  contained in any existing C or C++ header.

  Not all of the information provided by members is meaningful for all
  specializations of numeric_limits.  Any value which is not meaningful for a
  particular type is set to 0 or false.

INTERFACE

  template <class T>
  class numeric_limits {

  public:

   // General -- meaningful for all specializations.

     static const bool is_specialized ;
     static T min ();
     static T max ();
     static const int radix ;
     static const int digits ;
     static const int digits10 ;
     static const bool is_signed ;
     static const bool is_integer ;
     static const bool is_exact ;
     static const bool traps ;
     static const bool is_modulo ;
     static const bool is_bounded ;

   // Floating point specific.

     static T epsilon ();
     static T round_error ();
     static const int min_exponent10 ;
     static const int max_exponent10 ;
     static const int min_exponent ;

     static const int max_exponent ;
     static const bool has_infinity ;
     static const bool has_quiet_NaN ;
     static const bool has_signaling_NaN ;
     static const bool is_iec559 ;
     static const bool has_denorm ;
     static const bool tinyness_before ;
     static const float_round_style round_style ;
     static T denorm_min ();
     static T infinity ();
     static T quiet_NaN ();
     static T signaling_NaN ();
   };

  enum float_round_style {
    round_indeterminate       = -1,
    round_toward_zero         =  0,
    round_to_nearest          =  1,
    round_toward_infinity     =  2,
    round_toward_neg_infinity =  3
   };

MEMBER FIELDS AND FUNCTIONS

  static T
  denorm_min ();
     Returns the minimum denormalized value. Meaningful for all floating
     point types. For types that do not allow denormalized values, this
     method must return the minimum normalized value.

  static const int
  digits ;
     Number of radix digits which can be represented without change.   For
     built-in integer types, digits will usually be the number of non-sign
     bits in the representation. For floating point types, digits is the
     number of radix digits in the mantissa.  This member is meaningful for
     all  specializations that declare is_bounded to be true.

  static const int
  digits10 ;
     Number of base 10 digits that can be represented without change.
     Meaningful for all specializations that declare is_bounded to be true.

  static T
  epsilon ();
     Returns the machine epsilon (the difference between 1 and the least
     value greater than 1 that is representable).  This function is
     meaningful for floating point types only.

  static const bool
  has_denorm ;
     This field is true if the type allows denormalized values (variable
     number of exponent bits).  It is meaningful for floating point types
     only.

  static const bool
  has_infinity ;
     This field is true if the type has a representation for positive
     infinity.   It is meaningful for floating point types only.  This field
     must be true for any type claiming conformance to IEC 559.

  static const bool
  has_quiet_NaN ;
     This field is true is the type has a representation for a quiet (non-
     signaling)  "Not a Number".  It is meaningful for floating point types
     only and must be true for any type claiming conformance to IEC 559.

  static const bool
  has_signaling_NaN ;
     This field is true if the type has a representation for a signaling "Not
     a  Number".   It is meaningful for floating point types only, and must
     be true for any type claiming conformance to IEC 559.

  static T
  infinity ();
     Returns the representation of positive infinity, if available.  This
     member function is meaningful for only those specializations that
     declare has_infinity to be true.  Required for any type claiming
     conformance to IEC 559.

  static const bool
  is_bounded ;
     This field is true if the set of values representable by the type is
     finite.  All built-in C types are bounded; this member would be false
     for arbitrary precision types.

  static const bool
  is_exact ;
     This static member field is 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.  This member is meaningful for all specializations.

  static const bool
  is_iec559 ;
     This member is true if and only if the type adheres to the IEC 559
     standard.  It is meaningful for floating point types only. Must be true
     for any type claiming conformance to IEC 559.

  static const bool
  is_integer ;
     This member is true if the type is integer.  This member is meaningful
     for all specializations.

  static const bool
  is_modulo ;
     This field is true if the type is modulo.  Generally, this is false for
     floating types, true for unsigned integers, and true for signed integers
     on most machines.  A type is modulo if it is possible to add two
     positive numbers, and have a result that wraps around to a third number,
     which is less.

  static const bool
  is_signed ;
     This member is true if the type is signed.  This member is meaningful
     for all specializations.

  static const bool
  is_specialized ;
     Indicates whether numeric_limits has been specialized for type T.  This
     flag must be true for all specializations of numeric_limits.  In the
     default numeric_limits<T> template, this flag must be false.

  static T
  max ();
     Returns the maximum finite value.  This function is meaningful for all
     specializations that declare is_bounded to be true.

  static const int
  max_exponent ;
     Maximum positive integer such that the radix raised to that power is in
     range.  This field is meaningful for floating point types only.

  static const int
  max_exponent10 ;
     Maximum positive integer such that 10 raised to that power is in range.
     This field is meaningful for floating point types only.

  static T
  min ();
     Returns the minimum finite value.  For floating point types with
     denormalization, min()must return the minimum normalized value.  The
     minimum denormalized value is provided by denorm_min().  This function
     is meaningful for all specializations that declare is_bounded to be
     true.

  static const int
  min_exponent ;
     Minimum negative integer such that the radix raised to that power is in
     range.  This field is meaningful for floating point types only.

  static const int
  min_exponent10 ;
     Minimum negative integer such that 10 raised to that power is in range.
     This field is meaningful for floating point types only.

  static T
  quiet_NaN ();
     Returns the representation of a quiet "Not  a  Number", if available.
     This function is meaningful only for those specializations that declare
     has_quiet_NaN to be true.  This field is required for any type claiming
     conformance to IEC 559.

  static const int
  radix ;
     For floating types, specifies the base or radix of the exponent
     representation (often 2). For integer types, this member must specify
     the base of the representation. This field is meaningful for all
     specializations.

  static T
  round_error ();
     Returns the measure of the maximum rounding error. This function is
     meaningful for floating point types only.

  static const float_round_style
  round_style ;
     The rounding style for the type.  Specializations for integer types must
     return round_toward_zero.  This is meaningful for all floating point
     types.

  static T
  signaling_NaN();
     Returns the representation of a signaling "Not a Number",  if available.
     This function is meaningful for only those specializations that declare
     has_signaling_NaN to be true.  This function must be meaningful for any
     type claiming conformance to IEC 559.

  static const bool
  tinyness_before ;
     This member is true if tinyness is detected before rounding.  It is
     meaningful for floating point types only.

  static const bool
  traps ;
     This field is true if trapping is implemented for this type.   The traps
     field is meaningful for all specializations.

EXAMPLE

  //
  // limits.cpp
  //
   #include <limits>

  int main()
   {
      numeric_limits<float> float_info;
     if (float_info.is_specialized && float_info.has_infinity)
      {
        // get value of infinity
       float finfinity=float_info.infinity();
      }
     return 0;
   }

WARNING

  The specializations for wide chars and bool will only be available if your
  compiler has implemented them as real types and not simulated them with
  typedefs.

SEE ALSO

  IEEE Standard for Binary Floating-Point Arithmetic, 345 East 47th Street,
  New York, NY 10017

  Language Independent Arithmetic (LIA-1)

STANDARDS CONFORMANCE

  ANSI X3J16/ISO WG21 Joint C++ Committee



privacy and legal statement