3 <meta http-equiv=
"Content-Type" content=
"text/html; charset=US-ASCII">
4 <title>std::numeric_limits
<> functions
</title>
5 <link rel=
"stylesheet" href=
"../../../../../../../doc/src/boostbook.css" type=
"text/css">
6 <meta name=
"generator" content=
"DocBook XSL Stylesheets V1.77.1">
7 <link rel=
"home" href=
"../../../index.html" title=
"Chapter 1. Boost.Multiprecision">
8 <link rel=
"up" href=
"../limits.html" title=
"Numeric Limits">
9 <link rel=
"prev" href=
"constants.html" title=
"std::numeric_limits<> constants">
10 <link rel=
"next" href=
"limits32.html" title=
"Numeric limits for 32-bit platform">
12 <body bgcolor=
"white" text=
"black" link=
"#0000FF" vlink=
"#840084" alink=
"#0000FF">
13 <table cellpadding=
"2" width=
"100%"><tr>
14 <td valign=
"top"><img alt=
"Boost C++ Libraries" width=
"277" height=
"86" src=
"../../../../../../../boost.png"></td>
15 <td align=
"center"><a href=
"../../../../../../../index.html">Home
</a></td>
16 <td align=
"center"><a href=
"../../../../../../../libs/libraries.htm">Libraries
</a></td>
17 <td align=
"center"><a href=
"http://www.boost.org/users/people.html">People
</a></td>
18 <td align=
"center"><a href=
"http://www.boost.org/users/faq.html">FAQ
</a></td>
19 <td align=
"center"><a href=
"../../../../../../../more/index.htm">More
</a></td>
22 <div class=
"spirit-nav">
23 <a accesskey=
"p" href=
"constants.html"><img src=
"../../../../../../../doc/src/images/prev.png" alt=
"Prev"></a><a accesskey=
"u" href=
"../limits.html"><img src=
"../../../../../../../doc/src/images/up.png" alt=
"Up"></a><a accesskey=
"h" href=
"../../../index.html"><img src=
"../../../../../../../doc/src/images/home.png" alt=
"Home"></a><a accesskey=
"n" href=
"limits32.html"><img src=
"../../../../../../../doc/src/images/next.png" alt=
"Next"></a>
26 <div class=
"titlepage"><div><div><h4 class=
"title">
27 <a name=
"boost_multiprecision.tut.limits.functions"></a><a class=
"link" href=
"functions.html" title=
"std::numeric_limits<> functions">std::numeric_limits
<>
29 </h4></div></div></div>
31 <a name=
"boost_multiprecision.tut.limits.functions.h0"></a>
32 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.max_function"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.max_function">max function
</a>
35 Function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">max
</span><span class=
"special">()
</span></code>
36 returns the largest finite value that can be represented by the type T.
37 If there is no such value (and
<code class=
"computeroutput"><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">bounded
</span></code>
38 is
<code class=
"computeroutput"><span class=
"keyword">false
</span></code>) then returns
<code class=
"computeroutput"><span class=
"identifier">T
</span><span class=
"special">()
</span></code>.
41 For built-in types there is usually a corresponding MACRO value TYPE_MAX,
42 where TYPE is CHAR, INT, FLOAT etc.
45 Other types, including those provided by a typedef, for example
<code class=
"computeroutput"><span class=
"identifier">INT64_T_MAX
</span></code> for
<code class=
"computeroutput"><span class=
"identifier">int64_t
</span></code>,
46 may provide a macro definition.
49 To cater for situations where no
<code class=
"computeroutput"><span class=
"identifier">numeric_limits
</span></code>
50 specialization is available (for example because the precision of the type
51 varies at runtime), packaged versions of this (and other functions) are
54 <pre class=
"programlisting"><span class=
"preprocessor">#include
</span> <span class=
"special"><</span><span class=
"identifier">boost
</span><span class=
"special">/
</span><span class=
"identifier">math
</span><span class=
"special">/
</span><span class=
"identifier">tools
</span><span class=
"special">/
</span><span class=
"identifier">precision
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
56 <span class=
"identifier">T
</span> <span class=
"special">=
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">tools
</span><span class=
"special">::
</span><span class=
"identifier">max_value
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>();
</span>
59 Of course, these simply use
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">max
</span><span class=
"special">()
</span></code> if available, but otherwise 'do something
63 <a name=
"boost_multiprecision.tut.limits.functions.h1"></a>
64 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.lowest_function"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.lowest_function">lowest
68 Since C++
11:
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">lowest
</span><span class=
"special">()
</span></code>
71 <div class=
"itemizedlist"><ul class=
"itemizedlist" style=
"list-style-type: disc; ">
73 For integral types, the same as function
<code class=
"computeroutput"><span class=
"identifier">min
</span><span class=
"special">()
</span></code>.
76 For floating-point types, generally the negative of
<code class=
"computeroutput"><span class=
"identifier">max
</span><span class=
"special">()
</span></code> (but implementation-dependent).
79 <pre class=
"programlisting"><span class=
"special">-(
</span><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">max
</span><span class=
"special">)()
</span> <span class=
"special">==
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">lowest
</span><span class=
"special">();
</span>
82 <a name=
"boost_multiprecision.tut.limits.functions.h2"></a>
83 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.min_function"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.min_function">min function
</a>
86 Function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">min
</span><span class=
"special">()
</span></code>
87 returns the minimum finite value that can be represented by the type T.
90 For built-in types there is usually a corresponding MACRO value TYPE_MIN,
91 where TYPE is CHAR, INT, FLOAT etc.
94 Other types, including those provided by a typedef, for example
<code class=
"computeroutput"><span class=
"identifier">INT64_T_MIN
</span></code> for
<code class=
"computeroutput"><span class=
"identifier">int64_t
</span></code>,
95 may provide a macro definition.
98 For floating-point types, it is more fully defined as the
<span class=
"emphasis"><em>minimum
99 positive normalized value
</em></span>.
102 See
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">denorm_min
</span><span class=
"special">()
</span></code>
103 for the smallest denormalized value, provided
105 <pre class=
"programlisting"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">has_denorm
</span> <span class=
"special">==
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">denorm_present
</span>
108 To cater for situations where no
<code class=
"computeroutput"><span class=
"identifier">numeric_limits
</span></code>
109 specialization is available (for example because the precision of the type
110 varies at runtime), packaged versions of this (and other functions) are
113 <pre class=
"programlisting"><span class=
"preprocessor">#include
</span> <span class=
"special"><</span><span class=
"identifier">boost
</span><span class=
"special">/
</span><span class=
"identifier">math
</span><span class=
"special">/
</span><span class=
"identifier">tools
</span><span class=
"special">/
</span><span class=
"identifier">precision
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
115 <span class=
"identifier">T
</span> <span class=
"special">=
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">tools
</span><span class=
"special">::
</span><span class=
"identifier">min_value
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>();
</span>
118 Of course, these simply use
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">min
</span><span class=
"special">()
</span></code> if available.
121 <a name=
"boost_multiprecision.tut.limits.functions.h3"></a>
122 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.denorm_min_function"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.denorm_min_function">denorm_min
126 Function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">denorm_min
</span><span class=
"special">()
</span></code>
127 returns the smallest
<a href=
"http://en.wikipedia.org/wiki/Denormal_number" target=
"_top">denormalized
130 <pre class=
"programlisting"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">has_denorm
</span> <span class=
"special">==
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">denorm_present
</span>
132 <pre class=
"programlisting"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span><span class=
"special">.
</span><span class=
"identifier">precision
</span><span class=
"special">(
</span><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">max_digits10
</span><span class=
"special">);
</span>
133 <span class=
"keyword">if
</span> <span class=
"special">(
</span><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">has_denorm
</span> <span class=
"special">==
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">denorm_present
</span><span class=
"special">)
</span>
134 <span class=
"special">{
</span>
135 <span class=
"keyword">double
</span> <span class=
"identifier">d
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">denorm_min
</span><span class=
"special">();
</span>
137 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">d
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">//
4.9406564584124654e-324</span>
139 <span class=
"keyword">int
</span> <span class=
"identifier">exponent
</span><span class=
"special">;
</span>
141 <span class=
"keyword">double
</span> <span class=
"identifier">significand
</span> <span class=
"special">=
</span> <span class=
"identifier">frexp
</span><span class=
"special">(
</span><span class=
"identifier">d
</span><span class=
"special">,
</span> <span class=
"special">&</span><span class=
"identifier">exponent
</span><span class=
"special">);
</span>
142 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"exponent = "</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">hex
</span> <span class=
"special"><<</span> <span class=
"identifier">exponent
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">// fffffbcf
</span>
143 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"significand = "</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">hex
</span> <span class=
"special"><<</span> <span class=
"identifier">significand
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">//
0.50000000000000000</span>
144 <span class=
"special">}
</span>
145 <span class=
"keyword">else
</span>
146 <span class=
"special">{
</span>
147 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"No denormalization. "</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
148 <span class=
"special">}
</span>
151 The exponent is effectively reduced from -
308 to -
324 (though it remains
152 encoded as zero and leading zeros appear in the significand, thereby losing
153 precision until the significand reaches zero).
156 <a name=
"boost_multiprecision.tut.limits.functions.h4"></a>
157 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.round_error"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.round_error">round_error
</a>
160 Function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">round_error
</span><span class=
"special">()
</span></code>
161 returns the maximum error (in units of
<a href=
"http://en.wikipedia.org/wiki/Unit_in_the_last_place" target=
"_top">ULP
</a>)
162 that can be caused by any basic arithmetic operation.
164 <pre class=
"programlisting"><span class=
"identifier">round_style
</span> <span class=
"special">==
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">round_indeterminate
</span><span class=
"special">;
</span>
167 The rounding style is indeterminable at compile time.
170 For floating-point types, when rounding is to nearest, only half a bit
171 is lost by rounding, and
<code class=
"computeroutput"><span class=
"identifier">round_error
</span>
172 <span class=
"special">==
</span> <span class=
"number">0.5</span></code>.
173 In contrast when rounding is towards zero, or plus/minus infinity, we can
174 loose up to one bit from rounding, and
<code class=
"computeroutput"><span class=
"identifier">round_error
</span>
175 <span class=
"special">==
</span> <span class=
"number">1</span></code>.
178 For integer types, rounding always to zero, so at worst almost one bit
179 can be rounded, so
<code class=
"computeroutput"><span class=
"identifier">round_error
</span>
180 <span class=
"special">==
</span> <span class=
"number">1</span></code>.
183 <code class=
"computeroutput"><span class=
"identifier">round_error
</span><span class=
"special">()
</span></code>
184 can be used with
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">()
</span></code>
185 to estimate the maximum potential error caused by rounding. For typical
186 floating-point types,
<code class=
"computeroutput"><span class=
"identifier">round_error
</span><span class=
"special">()
</span> <span class=
"special">=
</span> <span class=
"number">1</span><span class=
"special">/
</span><span class=
"number">2</span></code>, so half
187 epsilon is the maximum potential error.
189 <pre class=
"programlisting"><span class=
"keyword">double
</span> <span class=
"identifier">round_err
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">()
</span> <span class=
"comment">//
2.2204460492503131e-016</span>
190 <span class=
"special">*
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">round_error
</span><span class=
"special">();
</span> <span class=
"comment">//
1/
2</span>
191 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">round_err
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">//
1.1102230246251565e-016</span>
194 There are, of course, many occasions when much bigger loss of precision
195 occurs, for example, caused by
<a href=
"http://en.wikipedia.org/wiki/Loss_of_significance" target=
"_top">Loss
196 of significance or cancellation error
</a> or very many iterations.
199 <a name=
"boost_multiprecision.tut.limits.functions.h5"></a>
200 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.epsilon"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.epsilon">epsilon
</a>
203 Function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">()
</span></code>
204 is meaningful only for non-integral types.
207 It returns the difference between
<code class=
"computeroutput"><span class=
"number">1.0</span></code>
208 and the next value representable by the floating-point type T. So it is
209 a one least-significant-bit change in this floating-point value.
212 For
<code class=
"computeroutput"><span class=
"keyword">double
</span></code> (
<code class=
"computeroutput"><span class=
"identifier">float_64t
</span></code>) it is
<code class=
"computeroutput"><span class=
"number">2.2204460492503131e-016</span></code>
213 showing all possibly significant
17 decimal digits.
215 <pre class=
"programlisting"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span><span class=
"special">.
</span><span class=
"identifier">precision
</span><span class=
"special">(
</span><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">max_digits10
</span><span class=
"special">);
</span>
216 <span class=
"keyword">double
</span> <span class=
"identifier">d
</span> <span class=
"special">=
</span> <span class=
"number">1.
</span><span class=
"special">;
</span>
217 <span class=
"keyword">double
</span> <span class=
"identifier">eps
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">();
</span>
218 <span class=
"keyword">double
</span> <span class=
"identifier">dpeps
</span> <span class=
"special">=
</span> <span class=
"identifier">d
</span><span class=
"special">+
</span><span class=
"identifier">eps
</span><span class=
"special">;
</span>
219 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">showpoint
</span> <span class=
"comment">// Ensure all trailing zeros are shown.
</span>
220 <span class=
"special"><<</span> <span class=
"identifier">d
</span> <span class=
"special"><<</span> <span class=
"string">"\n"</span> <span class=
"comment">//
1.0000000000000000</span>
221 <span class=
"special"><<</span> <span class=
"identifier">dpeps
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">//
2.2204460492503131e-016</span>
222 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">dpeps
</span> <span class=
"special">-
</span> <span class=
"identifier">d
</span> <span class=
"comment">//
1.0000000000000002</span>
223 <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
226 We can explicitly increment by one bit using the function
<code class=
"computeroutput"><span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">float_next
</span><span class=
"special">()
</span></code>
227 and the result is the same as adding
<code class=
"computeroutput"><span class=
"identifier">epsilon
</span></code>.
229 <pre class=
"programlisting"><span class=
"keyword">double
</span> <span class=
"identifier">one
</span> <span class=
"special">=
</span> <span class=
"number">1.
</span><span class=
"special">;
</span>
230 <span class=
"keyword">double
</span> <span class=
"identifier">nad
</span> <span class=
"special">=
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">float_next
</span><span class=
"special">(
</span><span class=
"identifier">one
</span><span class=
"special">);
</span>
231 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">nad
</span> <span class=
"special"><<</span> <span class=
"string">"\n"</span> <span class=
"comment">//
1.0000000000000002</span>
232 <span class=
"special"><<</span> <span class=
"identifier">nad
</span> <span class=
"special">-
</span> <span class=
"identifier">one
</span> <span class=
"comment">//
2.2204460492503131e-016</span>
233 <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
236 Adding any smaller value, like half
<code class=
"computeroutput"><span class=
"identifier">epsilon
</span></code>,
237 will have no effect on this value.
239 <pre class=
"programlisting"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span><span class=
"special">.
</span><span class=
"identifier">precision
</span><span class=
"special">(
</span><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">max_digits10
</span><span class=
"special">);
</span>
240 <span class=
"keyword">double
</span> <span class=
"identifier">d
</span> <span class=
"special">=
</span> <span class=
"number">1.
</span><span class=
"special">;
</span>
241 <span class=
"keyword">double
</span> <span class=
"identifier">eps
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"keyword">double
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">();
</span>
242 <span class=
"keyword">double
</span> <span class=
"identifier">dpeps
</span> <span class=
"special">=
</span> <span class=
"identifier">d
</span> <span class=
"special">+
</span> <span class=
"identifier">eps
</span><span class=
"special">/
</span><span class=
"number">2</span><span class=
"special">;
</span>
244 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">showpoint
</span> <span class=
"comment">// Ensure all trailing zeros are shown.
</span>
245 <span class=
"special"><<</span> <span class=
"identifier">dpeps
</span> <span class=
"special"><<</span> <span class=
"string">"\n"</span> <span class=
"comment">//
1.0000000000000000</span>
246 <span class=
"special"><<</span> <span class=
"identifier">eps
</span><span class=
"special">/
</span><span class=
"number">2</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">//
1.1102230246251565e-016</span>
247 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">dpeps
</span> <span class=
"special">-
</span> <span class=
"identifier">d
</span> <span class=
"comment">//
0.00000000000000000</span>
248 <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
251 So this cancellation error leaves the values equal, despite adding half
252 <code class=
"computeroutput"><span class=
"identifier">epsilon
</span></code>.
255 To achieve greater portability over platform and floating-point type, Boost.Math
256 and Boost.Multiprecion provide a package of functions that 'do something
257 sensible' if the standard
<code class=
"computeroutput"><span class=
"identifier">numeric_limits
</span></code>
258 is not available. To use these
<code class=
"computeroutput"><span class=
"preprocessor">#include
</span>
259 <span class=
"special"><</span><span class=
"identifier">boost
</span><span class=
"special">/
</span><span class=
"identifier">math
</span><span class=
"special">/
</span><span class=
"identifier">tools
</span><span class=
"special">/
</span><span class=
"identifier">precision
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span></code>.
262 A tolerance might be defined using this version of epsilon thus:
264 <pre class=
"programlisting"><span class=
"identifier">RealType
</span> <span class=
"identifier">tolerance
</span> <span class=
"special">=
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">tools
</span><span class=
"special">::
</span><span class=
"identifier">epsilon
</span><span class=
"special"><</span><span class=
"identifier">RealType
</span><span class=
"special">>()
</span> <span class=
"special">*
</span> <span class=
"number">2</span><span class=
"special">;
</span>
267 <a name=
"boost_multiprecision.tut.limits.functions.h6"></a>
268 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.tolerance_for_floating_point_com"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.tolerance_for_floating_point_com">Tolerance
269 for Floating-point Comparisons
</a>
272 <code class=
"computeroutput"><span class=
"identifier">epsilon
</span></code> is very useful
273 to compute a tolerance when comparing floating-point values, a much more
274 difficult task than is commonly imagined.
277 For more information you probably want (but still need) see
<a href=
"http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html" target=
"_top">What
278 Every Computer Scientist Should Know About Floating-Point Arithmetic
</a>
281 The naive test comparing the absolute difference between two values and
282 a tolerance does not give useful results if the values are too large or
286 So Boost.Test uses an algorithm first devised by Knuth for reliably checking
287 if floating-point values are close enough.
290 See Donald. E. Knuth. The art of computer programming (vol II). Copyright
291 1998 Addison-Wesley Longman, Inc.,
0-
201-
89684-
2. Addison-Wesley Professional;
298 <a href=
"http://adtmag.com/articles/2000/03/15/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx" target=
"_top">Alberto
299 Squassia, Comparing floats
</a>
302 <a href=
"http://adtmag.com/articles/2000/03/16/comparing-floats-how-to-determine-if-floating-quantities-are-close-enough-once-a-tolerance-has-been.aspx" target=
"_top">Alberto
303 Squassia, Comparing floats code
</a>
306 <a href=
"../../../../../../../libs/test/doc/html/utf/testing-tools/floating_point_comparison.html" target=
"_top">floating-point
310 For example, if we want a tolerance that might suit about
9 arithmetical
311 operations, say sqrt(
9) =
3, we could define:
313 <pre class=
"programlisting"><span class=
"identifier">T
</span> <span class=
"identifier">tolerance
</span> <span class=
"special">=
</span> <span class=
"number">3</span> <span class=
"special">*
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">();
</span>
316 This is very widely used in Boost.Math testing with Boost.Test's macro
317 <code class=
"computeroutput"><span class=
"identifier">BOOST_CHECK_CLOSE_FRACTION
</span></code>
319 <pre class=
"programlisting"><span class=
"identifier">T
</span> <span class=
"identifier">expected
</span> <span class=
"special">=
</span> <span class=
"number">1.0</span><span class=
"special">;
</span>
320 <span class=
"identifier">T
</span> <span class=
"identifier">calculated
</span> <span class=
"special">=
</span> <span class=
"number">1.0</span> <span class=
"special">+
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">();
</span>
322 <span class=
"identifier">BOOST_CHECK_CLOSE_FRACTION
</span><span class=
"special">(
</span><span class=
"identifier">expected
</span><span class=
"special">,
</span> <span class=
"identifier">calculated
</span><span class=
"special">,
</span> <span class=
"identifier">tolerance
</span><span class=
"special">);
</span>
327 <pre class=
"programlisting"><span class=
"identifier">BOOST_CHECK_CLOSE_FRACTION
</span><span class=
"special">(
</span><span class=
"identifier">expected
</span><span class=
"special">,
</span> <span class=
"identifier">calculated
</span><span class=
"special">,
</span> <span class=
"identifier">tolerance
</span><span class=
"special">);
</span>
330 (There is also a version using tolerance as a percentage rather than a
333 <pre class=
"programlisting"><span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">multiprecision
</span><span class=
"special">::
</span><span class=
"identifier">number
</span><span class=
"special">;
</span>
334 <span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">multiprecision
</span><span class=
"special">::
</span><span class=
"identifier">cpp_dec_float
</span><span class=
"special">;
</span>
335 <span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">multiprecision
</span><span class=
"special">::
</span><span class=
"identifier">et_off
</span><span class=
"special">;
</span>
337 <span class=
"keyword">typedef
</span> <span class=
"identifier">number
</span><span class=
"special"><</span><span class=
"identifier">cpp_dec_float
</span><span class=
"special"><</span><span class=
"number">50</span><span class=
"special">>,
</span> <span class=
"identifier">et_off
</span> <span class=
"special">></span> <span class=
"identifier">cpp_dec_float_50
</span><span class=
"special">;
</span> <span class=
"comment">//
50 decimal digits.
</span>
339 <div class=
"note"><table border=
"0" summary=
"Note">
341 <td rowspan=
"2" align=
"center" valign=
"top" width=
"25"><img alt=
"[Note]" src=
"../../../../../../../doc/src/images/note.png"></td>
342 <th align=
"left">Note
</th>
344 <tr><td align=
"left" valign=
"top"><p>
345 that Boost.Test does not yet allow floating-point comparisons with expression
346 templates on, so the default expression template parameter has been replaced
347 by
<code class=
"computeroutput"><span class=
"identifier">et_off
</span></code>.
350 <pre class=
"programlisting"><span class=
"identifier">cpp_dec_float_50
</span> <span class=
"identifier">tolerance
</span> <span class=
"special">=
</span> <span class=
"number">3</span> <span class=
"special">*
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">cpp_dec_float_50
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">();
</span>
351 <span class=
"identifier">cpp_dec_float_50
</span> <span class=
"identifier">expected
</span> <span class=
"special">=
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">constants
</span><span class=
"special">::
</span><span class=
"identifier">two_pi
</span><span class=
"special"><</span><span class=
"identifier">cpp_dec_float_50
</span><span class=
"special">>();
</span>
352 <span class=
"identifier">cpp_dec_float_50
</span> <span class=
"identifier">calculated
</span> <span class=
"special">=
</span> <span class=
"number">2</span> <span class=
"special">*
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">constants
</span><span class=
"special">::
</span><span class=
"identifier">pi
</span><span class=
"special"><</span><span class=
"identifier">cpp_dec_float_50
</span><span class=
"special">>();
</span>
354 <span class=
"identifier">BOOST_CHECK_CLOSE_FRACTION
</span><span class=
"special">(
</span><span class=
"identifier">expected
</span><span class=
"special">,
</span> <span class=
"identifier">calculated
</span><span class=
"special">,
</span> <span class=
"identifier">tolerance
</span><span class=
"special">);
</span>
357 <a name=
"boost_multiprecision.tut.limits.functions.h7"></a>
358 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.infinity_positive_and_negative"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.infinity_positive_and_negative">Infinity
359 - positive and negative
</a>
362 For floating-point types only, for which
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">has_infinity
</span>
363 <span class=
"special">==
</span> <span class=
"keyword">true
</span></code>,
364 function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">infinity
</span><span class=
"special">()
</span></code>
365 provides an implementation-defined representation for
∞.
368 The 'representation' is a particular bit pattern reserved for infinity.
369 For IEEE754 system (for which
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">is_iec559
</span>
370 <span class=
"special">==
</span> <span class=
"keyword">true
</span></code>)
371 <a href=
"http://en.wikipedia.org/wiki/IEEE_754-1985#Positive_and_negative_infinity" target=
"_top">positive
372 and negative infinity
</a> are assigned bit patterns for all defined
373 floating-point types.
376 Confusingly, the string resulting from outputting this representation,
377 is also implementation-defined. And the string that can be input to generate
378 the representation is also implementation-defined.
381 For example, the output is
<code class=
"computeroutput"><span class=
"number">1.
</span><span class=
"special">#
</span><span class=
"identifier">INF
</span></code>
382 on Microsoft systems, but
<code class=
"computeroutput"><span class=
"identifier">inf
</span></code>
383 on most *nix platforms.
386 This implementation-defined-ness has hampered use of infinity (and NaNs)
387 but Boost.Math and Boost.Multiprecision work hard to provide a sensible
388 representation for
<span class=
"bold"><strong>all
</strong></span> floating-point
389 types, not just the built-in types, which with the use of suitable facets
390 to define the input and output strings, makes it possible to use these
391 useful features portably and including Boost.Serialization.
394 <a name=
"boost_multiprecision.tut.limits.functions.h8"></a>
395 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.not_a_number_nan"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.not_a_number_nan">Not-A-Number
399 <a name=
"boost_multiprecision.tut.limits.functions.h9"></a>
400 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.quiet_nan"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.quiet_nan">Quiet_NaN
</a>
403 For floating-point types only, for which
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">has_quiet_NaN
</span>
404 <span class=
"special">==
</span> <span class=
"keyword">true
</span></code>,
405 function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">quiet_NaN
</span><span class=
"special">()
</span></code>
406 provides an implementation-defined representation for NaN.
409 <a href=
"http://en.wikipedia.org/wiki/NaN" target=
"_top">NaNs
</a> are values to
410 indicate that the result of an assignment or computation is meaningless.
411 A typical example is
<code class=
"computeroutput"><span class=
"number">0</span><span class=
"special">/
</span><span class=
"number">0</span></code> but there are many others.
414 NaNs may also be used, to represent missing values: for example, these
415 could, by convention, be ignored in calculations of statistics like means.
418 Many of the problems with a representation for
<a href=
"http://en.wikipedia.org/wiki/NaN" target=
"_top">Not-A-Number
</a>
419 has hampered portable use, similar to those with infinity.
422 NaN can be used with binary multiprecision types like
<code class=
"computeroutput"><span class=
"identifier">cpp_bin_float_quad
</span></code>:
424 <pre class=
"programlisting"><span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">multiprecision
</span><span class=
"special">::
</span><span class=
"identifier">cpp_bin_float_quad
</span><span class=
"special">;
</span>
426 <span class=
"keyword">if
</span> <span class=
"special">(
</span><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">cpp_bin_float_quad
</span><span class=
"special">>::
</span><span class=
"identifier">has_quiet_NaN
</span> <span class=
"special">==
</span> <span class=
"keyword">true
</span><span class=
"special">)
</span>
427 <span class=
"special">{
</span>
428 <span class=
"identifier">cpp_bin_float_quad
</span> <span class=
"identifier">tolerance
</span> <span class=
"special">=
</span> <span class=
"number">3</span> <span class=
"special">*
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">cpp_bin_float_quad
</span><span class=
"special">>::
</span><span class=
"identifier">epsilon
</span><span class=
"special">();
</span>
430 <span class=
"identifier">cpp_bin_float_quad
</span> <span class=
"identifier">NaN
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">cpp_bin_float_quad
</span><span class=
"special">>::
</span><span class=
"identifier">quiet_NaN
</span><span class=
"special">();
</span>
431 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"cpp_bin_float_quad NaN is "</span> <span class=
"special"><<</span> <span class=
"identifier">NaN
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span> <span class=
"comment">// cpp_bin_float_quad NaN is nan
</span>
433 <span class=
"identifier">cpp_bin_float_quad
</span> <span class=
"identifier">expected
</span> <span class=
"special">=
</span> <span class=
"identifier">NaN
</span><span class=
"special">;
</span>
434 <span class=
"identifier">cpp_bin_float_quad
</span> <span class=
"identifier">calculated
</span> <span class=
"special">=
</span> <span class=
"number">2</span> <span class=
"special">*
</span> <span class=
"identifier">NaN
</span><span class=
"special">;
</span>
435 <span class=
"comment">// Comparisons of NaN's always fail:
</span>
436 <span class=
"keyword">bool
</span> <span class=
"identifier">b
</span> <span class=
"special">=
</span> <span class=
"identifier">expected
</span> <span class=
"special">==
</span> <span class=
"identifier">calculated
</span><span class=
"special">;
</span>
437 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"identifier">b
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
438 <span class=
"identifier">BOOST_CHECK_NE
</span><span class=
"special">(
</span><span class=
"identifier">expected
</span><span class=
"special">,
</span> <span class=
"identifier">expected
</span><span class=
"special">);
</span>
439 <span class=
"identifier">BOOST_CHECK_NE
</span><span class=
"special">(
</span><span class=
"identifier">expected
</span><span class=
"special">,
</span> <span class=
"identifier">calculated
</span><span class=
"special">);
</span>
440 <span class=
"special">}
</span>
441 <span class=
"keyword">else
</span>
442 <span class=
"special">{
</span>
443 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"Type "</span> <span class=
"special"><<</span> <span class=
"keyword">typeid
</span><span class=
"special">(
</span><span class=
"identifier">cpp_bin_float_quad
</span><span class=
"special">).
</span><span class=
"identifier">name
</span><span class=
"special">()
</span> <span class=
"special"><<</span> <span class=
"string">" does not have NaNs!"</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
444 <span class=
"special">}
</span>
447 But using Boost.Math and suitable facets can permit portable use of both
448 NaNs and positive and negative infinity.
451 See
<a href=
"../../../../../../../libs/math/example/nonfinite_facet_sstream.cpp" target=
"_top">boost:/libs/math/example/nonfinite_facet_sstream.cpp
</a>
454 <pre class=
"programlisting"><span class=
"preprocessor">#include
</span> <span class=
"special"><</span><span class=
"identifier">boost
</span><span class=
"special">/
</span><span class=
"identifier">math
</span><span class=
"special">/
</span><span class=
"identifier">special_functions
</span><span class=
"special">/
</span><span class=
"identifier">nonfinite_num_facets
</span><span class=
"special">.
</span><span class=
"identifier">hpp
</span><span class=
"special">></span>
457 Then we can equally well use a multiprecision type cpp_bin_float_quad:
459 <pre class=
"programlisting"><span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">multiprecision
</span><span class=
"special">::
</span><span class=
"identifier">cpp_bin_float_quad
</span><span class=
"special">;
</span>
461 <span class=
"keyword">typedef
</span> <span class=
"identifier">cpp_bin_float_quad
</span> <span class=
"identifier">T
</span><span class=
"special">;
</span>
463 <span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">nonfinite_num_put
</span><span class=
"special">;
</span>
464 <span class=
"keyword">using
</span> <span class=
"identifier">boost
</span><span class=
"special">::
</span><span class=
"identifier">math
</span><span class=
"special">::
</span><span class=
"identifier">nonfinite_num_get
</span><span class=
"special">;
</span>
465 <span class=
"special">{
</span>
466 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">locale
</span> <span class=
"identifier">old_locale
</span><span class=
"special">;
</span>
467 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">locale
</span> <span class=
"identifier">tmp_locale
</span><span class=
"special">(
</span><span class=
"identifier">old_locale
</span><span class=
"special">,
</span> <span class=
"keyword">new
</span> <span class=
"identifier">nonfinite_num_put
</span><span class=
"special"><</span><span class=
"keyword">char
</span><span class=
"special">>);
</span>
468 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">locale
</span> <span class=
"identifier">new_locale
</span><span class=
"special">(
</span><span class=
"identifier">tmp_locale
</span><span class=
"special">,
</span> <span class=
"keyword">new
</span> <span class=
"identifier">nonfinite_num_get
</span><span class=
"special"><</span><span class=
"keyword">char
</span><span class=
"special">>);
</span>
469 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">stringstream
</span> <span class=
"identifier">ss
</span><span class=
"special">;
</span>
470 <span class=
"identifier">ss
</span><span class=
"special">.
</span><span class=
"identifier">imbue
</span><span class=
"special">(
</span><span class=
"identifier">new_locale
</span><span class=
"special">);
</span>
471 <span class=
"identifier">T
</span> <span class=
"identifier">inf
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">infinity
</span><span class=
"special">();
</span>
472 <span class=
"identifier">ss
</span> <span class=
"special"><<</span> <span class=
"identifier">inf
</span><span class=
"special">;
</span> <span class=
"comment">// Write out.
</span>
473 <span class=
"identifier">assert
</span><span class=
"special">(
</span><span class=
"identifier">ss
</span><span class=
"special">.
</span><span class=
"identifier">str
</span><span class=
"special">()
</span> <span class=
"special">==
</span> <span class=
"string">"inf"</span><span class=
"special">);
</span>
474 <span class=
"identifier">T
</span> <span class=
"identifier">r
</span><span class=
"special">;
</span>
475 <span class=
"identifier">ss
</span> <span class=
"special">>></span> <span class=
"identifier">r
</span><span class=
"special">;
</span> <span class=
"comment">// Read back in.
</span>
476 <span class=
"identifier">assert
</span><span class=
"special">(
</span><span class=
"identifier">inf
</span> <span class=
"special">==
</span> <span class=
"identifier">r
</span><span class=
"special">);
</span> <span class=
"comment">// Confirms that the floating-point values really are identical.
</span>
477 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"infinity output was "</span> <span class=
"special"><<</span> <span class=
"identifier">ss
</span><span class=
"special">.
</span><span class=
"identifier">str
</span><span class=
"special">()
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
478 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"infinity input was "</span> <span class=
"special"><<</span> <span class=
"identifier">r
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
479 <span class=
"special">}
</span>
481 <pre class=
"programlisting"><span class=
"identifier">infinity
</span> <span class=
"identifier">output
</span> <span class=
"identifier">was
</span> <span class=
"identifier">inf
</span>
482 <span class=
"identifier">infinity
</span> <span class=
"identifier">input
</span> <span class=
"identifier">was
</span> <span class=
"identifier">inf
</span>
485 Similarly we can do the same with NaN (except that we cannot use
<code class=
"computeroutput"><span class=
"identifier">assert
</span></code>)
487 <pre class=
"programlisting"><span class=
"special">{
</span>
488 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">locale
</span> <span class=
"identifier">old_locale
</span><span class=
"special">;
</span>
489 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">locale
</span> <span class=
"identifier">tmp_locale
</span><span class=
"special">(
</span><span class=
"identifier">old_locale
</span><span class=
"special">,
</span> <span class=
"keyword">new
</span> <span class=
"identifier">nonfinite_num_put
</span><span class=
"special"><</span><span class=
"keyword">char
</span><span class=
"special">>);
</span>
490 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">locale
</span> <span class=
"identifier">new_locale
</span><span class=
"special">(
</span><span class=
"identifier">tmp_locale
</span><span class=
"special">,
</span> <span class=
"keyword">new
</span> <span class=
"identifier">nonfinite_num_get
</span><span class=
"special"><</span><span class=
"keyword">char
</span><span class=
"special">>);
</span>
491 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">stringstream
</span> <span class=
"identifier">ss
</span><span class=
"special">;
</span>
492 <span class=
"identifier">ss
</span><span class=
"special">.
</span><span class=
"identifier">imbue
</span><span class=
"special">(
</span><span class=
"identifier">new_locale
</span><span class=
"special">);
</span>
493 <span class=
"identifier">T
</span> <span class=
"identifier">n
</span><span class=
"special">;
</span>
494 <span class=
"identifier">T
</span> <span class=
"identifier">NaN
</span> <span class=
"special">=
</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">quiet_NaN
</span><span class=
"special">();
</span>
495 <span class=
"identifier">ss
</span> <span class=
"special"><<</span> <span class=
"identifier">NaN
</span><span class=
"special">;
</span> <span class=
"comment">// Write out.
</span>
496 <span class=
"identifier">assert
</span><span class=
"special">(
</span><span class=
"identifier">ss
</span><span class=
"special">.
</span><span class=
"identifier">str
</span><span class=
"special">()
</span> <span class=
"special">==
</span> <span class=
"string">"nan"</span><span class=
"special">);
</span>
497 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"NaN output was "</span> <span class=
"special"><<</span> <span class=
"identifier">ss
</span><span class=
"special">.
</span><span class=
"identifier">str
</span><span class=
"special">()
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
498 <span class=
"identifier">ss
</span> <span class=
"special">>></span> <span class=
"identifier">n
</span><span class=
"special">;
</span> <span class=
"comment">// Read back in.
</span>
499 <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">cout
</span> <span class=
"special"><<</span> <span class=
"string">"NaN input was "</span> <span class=
"special"><<</span> <span class=
"identifier">n
</span> <span class=
"special"><<</span> <span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">endl
</span><span class=
"special">;
</span>
500 <span class=
"special">}
</span>
503 NaN output was nan NaN input was nan
506 <a name=
"boost_multiprecision.tut.limits.functions.h10"></a>
507 <span class=
"phrase"><a name=
"boost_multiprecision.tut.limits.functions.signaling_nan"></a></span><a class=
"link" href=
"functions.html#boost_multiprecision.tut.limits.functions.signaling_nan">Signaling
511 For floating-point types only, for which
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">has_signaling_NaN
</span>
512 <span class=
"special">==
</span> <span class=
"keyword">true
</span></code>,
513 function
<code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">signaling_NaN
</span><span class=
"special">()
</span></code>
514 provides an implementation-defined representation for NaN that causes a
515 hardware trap. It should be noted however, that at least one implementation
516 of this function causes a hardware trap to be triggered simply by calling
517 <code class=
"computeroutput"><span class=
"identifier">std
</span><span class=
"special">::
</span><span class=
"identifier">numeric_limits
</span><span class=
"special"><</span><span class=
"identifier">T
</span><span class=
"special">>::
</span><span class=
"identifier">signaling_NaN
</span><span class=
"special">()
</span></code>,
518 and not only by using the value returned.
521 <table xmlns:
rev=
"http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width=
"100%"><tr>
522 <td align=
"left"></td>
523 <td align=
"right"><div class=
"copyright-footer">Copyright
© 2002-
2013 John Maddock and Christopher Kormanyos
<p>
524 Distributed under the Boost Software License, Version
1.0. (See accompanying
525 file LICENSE_1_0.txt or copy at
<a href=
"http://www.boost.org/LICENSE_1_0.txt" target=
"_top">http://www.boost.org/LICENSE_1_0.txt
</a>)
530 <div class=
"spirit-nav">
531 <a accesskey=
"p" href=
"constants.html"><img src=
"../../../../../../../doc/src/images/prev.png" alt=
"Prev"></a><a accesskey=
"u" href=
"../limits.html"><img src=
"../../../../../../../doc/src/images/up.png" alt=
"Up"></a><a accesskey=
"h" href=
"../../../index.html"><img src=
"../../../../../../../doc/src/images/home.png" alt=
"Home"></a><a accesskey=
"n" href=
"limits32.html"><img src=
"../../../../../../../doc/src/images/next.png" alt=
"Next"></a>