numeric_limits
			   Standard C++	Library
		 Copyright 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