limits2.html

ST20 Embedded Toolset R2.0.5用于开发基于ST20芯片机顶盒软件的开发平台,2.0.5版本,国内找不到的.在国外论坛上花了N天才找到!

<P>The function returns the representation of positive infinity
for the type. The return value is meaningful only if
<A HREF="#numeric_limits::has_infinity"><CODE>has_infinity</CODE></A> is true.</P>

<H3><A NAME="numeric_limits::is_bounded">
<CODE>numeric_limits::is_bounded</CODE></A></H3>

<PRE>static const bool <B>is_bounded</B> = false;</PRE>

<P>The member stores true for a type that has
a bounded set of representable values (which is the case
for all predefined types).</P>

<H3><A NAME="numeric_limits::is_exact">
<CODE>numeric_limits::is_exact</CODE></A></H3>

<PRE>static const bool <B>is_exact</B> = false;</PRE>

<P>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.</P>

<H3><A NAME="numeric_limits::is_iec559">
<CODE>numeric_limits::is_iec559</CODE></A></H3>

<PRE>static const bool <B>is_iec559</B> = false;</PRE>

<P>The member stores true for a type that has
a representation conforming to
<B><A NAME="IEC 559">IEC 559</A></B>, an international
standard for representing floating-point values (also known as
<B><A NAME="IEEE 754">IEEE 754</A></B> in the USA).</P>

<H3><A NAME="numeric_limits::is_integer">
<CODE>numeric_limits::is_integer</CODE></A></H3>

<PRE>static const bool <B>is_integer</B> = false;</PRE>

<P>The member stores true for a type that has
an integer representation (which is the case for all
predefined integer types).</P>

<H3><A NAME="numeric_limits::is_modulo">
<CODE>numeric_limits::is_modulo</CODE></A></H3>

<PRE>static const bool <B>is_modulo</B> = false;</PRE>

<P>The member stores true for a type that has a
<B><A NAME="modulo representation">modulo representation</A></B>,
where all results are reduced modulo some value (which is the
case for all predefined unsigned integer types).</P>

<H3><A NAME="numeric_limits::is_signed">
<CODE>numeric_limits::is_signed</CODE></A></H3>

<PRE>static const bool <B>is_signed</B> = false;</PRE>

<P>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).</P>

<H3><A NAME="numeric_limits::is_specialized">
<CODE>numeric_limits::is_specialized</CODE></A></H3>

<PRE>static const bool <B>is_specialized</B> = false;</PRE>

<P>The member stores true for a type that has
an explicit specialization defined for template class
<A HREF="#numeric_limits"><CODE>numeric_limits</CODE></A>
(which is the case for all scalar types other than pointers).
</P>

<H3><A NAME="numeric_limits::max">
<CODE>numeric_limits::max</CODE></A></H3>

<PRE>static Ty <B>max</B>() throw();</PRE>

<P>The function returns the maximum finite value for the type
(which is
<A HREF="limits.html#INT_MAX"><CODE>INT_MAX</CODE></A>
for type <I>int</I> and
<A HREF="float.html#FLT_MAX"><CODE>FLT_MAX</CODE></A>
for type <I>float</I>). The return value is meaningful if
<A HREF="#numeric_limits::is_bounded"><CODE>is_bounded</CODE></A> is true.</P>

<H3><A NAME="numeric_limits::max_exponent">
<CODE>numeric_limits::max_exponent</CODE></A></H3>

<PRE>static const int <B>max_exponent</B> = 0;</PRE>

<P>The member stores the maximum positive integer such that
the type can represent as a finite value
<A HREF="#numeric_limits::radix"><CODE>radix</CODE></A> raised to that power
(which is the value
<A HREF="float.html#FLT_MAX_EXP"><CODE>FLT_MAX_EXP</CODE></A>
for type <I>float</I>).
Meaningful only for floating-point types.</P>

<H3><A NAME="numeric_limits::max_exponent10">
<CODE>numeric_limits::max_exponent10</CODE></A></H3>

<PRE>static const int <B>max_exponent10</B> = 0;</PRE>

<P>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
<A HREF="float.html#FLT_MAX_10_EXP"><CODE>FLT_MAX_10_EXP</CODE></A>
for type <I>float</I>).
Meaningful only for floating-point types.</P>

<H3><A NAME="numeric_limits::min">
<CODE>numeric_limits::min</CODE></A></H3>

<PRE>static Ty <B>min</B>() throw();</PRE>

<P>The function returns the minimum normalized value for the type
(which is
<A HREF="limits.html#INT_MIN"><CODE>INT_MIN</CODE></A>
for type <I>int</I> and
<A HREF="float.html#FLT_MIN"><CODE>FLT_MIN</CODE></A>
for type <I>float</I>). The return value is meaningful if
<A HREF="#numeric_limits::is_bounded"><CODE>is_bounded</CODE></A> is true or
<CODE>is_bounded</CODE> is false and
<A HREF="#numeric_limits::is_signed"><CODE>is_signed</CODE></A> is false.</P>

<H3><A NAME="numeric_limits::min_exponent">
<CODE>numeric_limits::min_exponent</CODE></A></H3>

<PRE>static const int <B>min_exponent</B> = 0;</PRE>

<P>The member stores the minimum negative integer such that
the type can represent as a normalized value
<A HREF="#numeric_limits::radix"><CODE>radix</CODE></A> raised to that power
(which is the value
<A HREF="float.html#FLT_MIN_EXP"><CODE>FLT_MIN_EXP</CODE></A>
for type <I>float</I>).
Meaningful only for floating-point types.</P>

<H3><A NAME="numeric_limits::min_exponent10">
<CODE>numeric_limits::min_exponent10</CODE></A></H3>

<PRE>static const int <B>min_exponent10</B> = 0;</PRE>

<P>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
<A HREF="float.html#FLT_MIN_10_EXP"><CODE>FLT_MIN_10_EXP</CODE></A>
for type <I>float</I>).
Meaningful only for floating-point types.</P>

<H3><A NAME="numeric_limits::quiet_NaN">
<CODE>numeric_limits::quiet_NaN</CODE></A></H3>

<PRE>static Ty <B>quiet_NaN</B>() throw();</PRE>

<P>The function returns a representation of a
<A HREF="#quiet NaN">quiet NaN</A>
for the type. The return value is meaningful only if
<A HREF="#numeric_limits::has_quiet_NaN"><CODE>has_quiet_NaN</CODE></A> is true.</P>

<H3><A NAME="numeric_limits::radix">
<CODE>numeric_limits::radix</CODE></A></H3>

<PRE>static const int <B>radix</B> = 0;</PRE>

<P>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
<A HREF="float.html#FLT_RADIX"><CODE>FLT_RADIX</CODE></A>,
for the predefined floating-point types).</P>

<H3><A NAME="numeric_limits::round_error">
<CODE>numeric_limits::round_error</CODE></A></H3>

<PRE>static Ty <B>round_error</B>() throw();</PRE>

<P>The function returns the maximum rounding error for the type.</P>

<H3><A NAME="numeric_limits::round_style">
<CODE>numeric_limits::round_style</CODE></A></H3>

<PRE>static const <A HREF="#float_round_style">float_round_style</A> <B>round_style</B> =
     round_toward_zero;</PRE>

<P>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.</P>

<H3><A NAME="numeric_limits::signaling_NaN">
<CODE>numeric_limits::signaling_NaN</CODE></A></H3>

<PRE>static Ty <B>signaling_NaN</B>() throw();</PRE>

<P>The function returns a representation of a
<A HREF="#signaling NaN">signaling NaN</A>
for the type. The return value is meaningful only if
<A HREF="#numeric_limits::has_signaling_NaN"><CODE>has_signaling_NaN</CODE></A> is true.</P>

<H3><A NAME="numeric_limits::tinyness_before">
<CODE>numeric_limits::tinyness_before</CODE></A></H3>

<PRE>static const bool <B>tinyness_before</B> = false;</PRE>

<P>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
<A HREF="#IEC 559">IEC 559</A> floating-point representations
that can affect some results.</P>

<H3><A NAME="numeric_limits::traps">
<CODE>numeric_limits::traps</CODE></A></H3>

<PRE>static const bool <B>traps</B> = false;</PRE>

<P>The member stores true for a type that generates some kind of
<A HREF="signal.html#signals">signal</A> to report certain
arithmetic exceptions.</P>

<HR>
<P>See also the
<B><A HREF="index.html#Table of Contents">Table of Contents</A></B> and the
<B><A HREF="_index.html">Index</A></B>.</P>

<P><I>
<A HREF="crit_pjp.html">Copyright</A> &#169; 1992-2002
by P.J. Plauger. All rights reserved.</I></P>

<!--V4.01:1125--></BODY></HTML>