• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1<html>
2<head>
3<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
4<title>Real Number Generators (float_, double_, etc.)</title>
5<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
6<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
7<link rel="home" href="../../../../index.html" title="Spirit 2.5.8">
8<link rel="up" href="../numeric.html" title="Numeric Generators">
9<link rel="prev" href="signed_int.html" title="Signed Integer Number Generators (int_, etc.)">
10<link rel="next" href="boolean.html" title="Boolean Generators (bool_)">
11</head>
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>
20</tr></table>
21<hr>
22<div class="spirit-nav">
23<a accesskey="p" href="signed_int.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../numeric.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="boolean.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
24</div>
25<div class="section">
26<div class="titlepage"><div><div><h5 class="title">
27<a name="spirit.karma.reference.numeric.real_number"></a><a class="link" href="real_number.html" title="Real Number Generators (float_, double_, etc.)">Real
28          Number Generators (<code class="computeroutput"><span class="identifier">float_</span></code>,
29          <code class="computeroutput"><span class="identifier">double_</span></code>, etc.)</a>
30</h5></div></div></div>
31<h6>
32<a name="spirit.karma.reference.numeric.real_number.h0"></a>
33            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.description"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.description">Description</a>
34          </h6>
35<p>
36            The <code class="computeroutput"><span class="identifier">real_generator</span></code> can
37            generate real numbers of arbitrary length and size limited by its template
38            parameter, <code class="computeroutput"><span class="identifier">Num</span></code>. The numeric
39            base type <code class="computeroutput"><span class="identifier">Num</span></code> can be
40            a user defined numeric type such as fixed_point (fixed point reals) and
41            bignum (unlimited precision numbers) if the type follows certain expression
42            requirements (for more information about the requirements, see <a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.additional_requirements">below</a>).
43          </p>
44<h6>
45<a name="spirit.karma.reference.numeric.real_number.h1"></a>
46            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.header"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.header">Header</a>
47          </h6>
48<pre class="programlisting"><span class="comment">// forwards to &lt;boost/spirit/home/karma/numeric/real.hpp&gt;</span>
49<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">karma_real</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
50</pre>
51<p>
52            Also, see <a class="link" href="../../../structure/include.html" title="Include">Include Structure</a>.
53          </p>
54<h6>
55<a name="spirit.karma.reference.numeric.real_number.h2"></a>
56            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.namespace"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.namespace">Namespace</a>
57          </h6>
58<div class="informaltable"><table class="table">
59<colgroup><col></colgroup>
60<thead><tr><th>
61                    <p>
62                      Name
63                    </p>
64                  </th></tr></thead>
65<tbody>
66<tr><td>
67                    <p>
68                      <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">spirit</span><span class="special">::</span><span class="identifier">lit</span> <span class="comment">// alias:
69                      boost::spirit::karma::lit</span></code>
70                    </p>
71                  </td></tr>
72<tr><td>
73                    <p>
74                      <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">spirit</span><span class="special">::</span><span class="identifier">float_</span> <span class="comment">//
75                      alias: boost::spirit::karma::float_</span></code>
76                    </p>
77                  </td></tr>
78<tr><td>
79                    <p>
80                      <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">spirit</span><span class="special">::</span><span class="identifier">double_</span> <span class="comment">//
81                      alias: boost::spirit::karma::double_</span></code>
82                    </p>
83                  </td></tr>
84<tr><td>
85                    <p>
86                      <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">spirit</span><span class="special">::</span><span class="identifier">long_double</span> <span class="comment">//
87                      alias: boost::spirit::karma::long_double</span></code>
88                    </p>
89                  </td></tr>
90</tbody>
91</table></div>
92<div class="note"><table border="0" summary="Note">
93<tr>
94<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../images/note.png"></td>
95<th align="left">Note</th>
96</tr>
97<tr><td align="left" valign="top"><p>
98              <code class="computeroutput"><span class="identifier">lit</span></code> is reused by the
99              <a class="link" href="../string.html" title="String Generators">String Generators</a>,
100              the <a class="link" href="../char.html" title="Char Generators">Character Generators</a>,
101              and the Numeric Generators. In general, a char generator is created
102              when you pass in a character, a string generator is created when you
103              pass in a string, and a numeric generator is created when you use a
104              numeric literal.
105            </p></td></tr>
106</table></div>
107<h6>
108<a name="spirit.karma.reference.numeric.real_number.h3"></a>
109            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.synopsis"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.synopsis">Synopsis</a>
110          </h6>
111<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Num</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">RealPolicies</span><span class="special">&gt;</span>
112<span class="keyword">struct</span> <span class="identifier">real_generator</span><span class="special">;</span>
113</pre>
114<h6>
115<a name="spirit.karma.reference.numeric.real_number.h4"></a>
116            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.template_parameters"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.template_parameters">Template
117            parameters</a>
118          </h6>
119<div class="informaltable"><table class="table">
120<colgroup>
121<col>
122<col>
123<col>
124</colgroup>
125<thead><tr>
126<th>
127                    <p>
128                      Parameter
129                    </p>
130                  </th>
131<th>
132                    <p>
133                      Description
134                    </p>
135                  </th>
136<th>
137                    <p>
138                      Default
139                    </p>
140                  </th>
141</tr></thead>
142<tbody>
143<tr>
144<td>
145                    <p>
146                      <code class="computeroutput"><span class="identifier">Num</span></code>
147                    </p>
148                  </td>
149<td>
150                    <p>
151                      The type of the real number to generate.
152                    </p>
153                  </td>
154<td>
155                    <p>
156                      <code class="computeroutput"><span class="keyword">double</span></code>
157                    </p>
158                  </td>
159</tr>
160<tr>
161<td>
162                    <p>
163                      <code class="computeroutput"><span class="identifier">RealPolicies</span></code>
164                    </p>
165                  </td>
166<td>
167                    <p>
168                      The policies to use while converting the real number.
169                    </p>
170                  </td>
171<td>
172                    <p>
173                      <code class="computeroutput"><span class="identifier">real_policies</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;</span></code>
174                    </p>
175                  </td>
176</tr>
177</tbody>
178</table></div>
179<p>
180            For more information about the type <code class="computeroutput"><span class="identifier">RealPolicies</span></code>
181            see <a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.real_number_formatting_policies">below</a>.
182          </p>
183<h6>
184<a name="spirit.karma.reference.numeric.real_number.h5"></a>
185            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.model_of"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.model_of">Model of</a>
186          </h6>
187<div class="blockquote"><blockquote class="blockquote"><p>
188              <a class="link" href="../generator_concepts/primitivegenerator.html" title="PrimitiveGenerator"><code class="computeroutput"><span class="identifier">PrimitiveGenerator</span></code></a>
189            </p></blockquote></div>
190<div class="variablelist">
191<p class="title"><b>Notation</b></p>
192<dl class="variablelist">
193<dt><span class="term"><code class="computeroutput"><span class="identifier">num</span></code></span></dt>
194<dd><p>
195                  Numeric literal, any real number value, or a <a class="link" href="../basics.html#spirit.karma.reference.basics.lazy_argument">Lazy
196                  Argument</a> that evaluates to a real number value of type
197                  <code class="computeroutput"><span class="identifier">Num</span></code>
198                </p></dd>
199<dt><span class="term"><code class="computeroutput"><span class="identifier">Num</span></code></span></dt>
200<dd><p>
201                  Type of <code class="computeroutput"><span class="identifier">num</span></code>: any
202                  real number type
203                </p></dd>
204</dl>
205</div>
206<h6>
207<a name="spirit.karma.reference.numeric.real_number.h6"></a>
208            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.expression_semantics"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.expression_semantics">Expression
209            Semantics</a>
210          </h6>
211<p>
212            Semantics of an expression is defined only where it differs from, or
213            is not defined in <a class="link" href="../generator_concepts/primitivegenerator.html" title="PrimitiveGenerator"><code class="computeroutput"><span class="identifier">PrimitiveGenerator</span></code></a>.
214          </p>
215<div class="informaltable"><table class="table">
216<colgroup>
217<col>
218<col>
219</colgroup>
220<thead><tr>
221<th>
222                    <p>
223                      Expression
224                    </p>
225                  </th>
226<th>
227                    <p>
228                      Semantics
229                    </p>
230                  </th>
231</tr></thead>
232<tbody>
233<tr>
234<td>
235                    <p>
236                      <code class="computeroutput"><span class="identifier">lit</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></code>
237                    </p>
238                  </td>
239<td>
240                    <p>
241                      Generate the real number literal <code class="computeroutput"><span class="identifier">num</span></code>
242                      using the default formatting (no trailing zeros, <code class="computeroutput"><span class="identifier">fixed</span></code> representation for
243                      numbers <code class="computeroutput"><span class="identifier">fabs</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">&lt;=</span>
244                      <span class="number">1e5</span> <span class="special">&amp;&amp;</span>
245                      <span class="identifier">fabs</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
246                      <span class="special">&gt;</span> <span class="number">1e-3</span></code>,
247                      scientific representation otherwise, 3 fractional digits, sign
248                      is only printed for negative literals). This generator never
249                      fails (unless the underlying output stream reports an error).
250                    </p>
251                  </td>
252</tr>
253<tr>
254<td>
255                    <p>
256</p>
257<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">float_</span>
258<span class="identifier">double_</span>
259<span class="identifier">long_double</span></pre>
260<p>
261                    </p>
262                  </td>
263<td>
264                    <p>
265                      Generate the real number provided by a mandatory attribute
266                      using the default formatting (no trailing zeros, <code class="computeroutput"><span class="identifier">fixed</span></code> representation for
267                      numbers <code class="computeroutput"><span class="identifier">fabs</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">&lt;=</span>
268                      <span class="number">1e5</span> <span class="special">&amp;&amp;</span>
269                      <span class="identifier">fabs</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
270                      <span class="special">&gt;</span> <span class="number">1e-3</span></code>,
271                      scientific representation otherwise, 3 fractional digits, sign
272                      is only printed for negative literals). This generator never
273                      fails (unless the underlying output stream reports an error).
274                    </p>
275                  </td>
276</tr>
277<tr>
278<td>
279                    <p>
280</p>
281<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">float_</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span>
282<span class="identifier">double_</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span>
283<span class="identifier">long_double</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></pre>
284<p>
285                    </p>
286                  </td>
287<td>
288                    <p>
289                      Generate the real point number provided by the immediate literal
290                      value the generator is initialized from using the default formatting
291                      (no trailing zeros, <code class="computeroutput"><span class="identifier">fixed</span></code>
292                      representation for numbers <code class="computeroutput"><span class="identifier">fabs</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span> <span class="special">&lt;=</span>
293                      <span class="number">1e5</span> <span class="special">&amp;&amp;</span>
294                      <span class="identifier">fabs</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span>
295                      <span class="special">&gt;</span> <span class="number">1e-3</span></code>,
296                      scientific representation otherwise, 3 fractional digits, sign
297                      is only printed for negative literals). If this generator has
298                      an associated attribute it succeeds only if the attribute is
299                      equal to the immediate literal (unless the underlying output
300                      stream reports an error). Otherwise this generator fails and
301                      does not generate any output.
302                    </p>
303                  </td>
304</tr>
305</tbody>
306</table></div>
307<p>
308            All generators listed in the table above (except <code class="computeroutput"><span class="identifier">lit</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></code>) are predefined specializations of the
309            <code class="computeroutput"><span class="identifier">real_generator</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">,</span> <span class="identifier">RealPolicies</span><span class="special">&gt;</span></code>
310            basic real number generator type described below. It is possible to directly
311            use this type to create real number generators using a wide range of
312            formatting options.
313          </p>
314<div class="informaltable"><table class="table">
315<colgroup>
316<col>
317<col>
318</colgroup>
319<thead><tr>
320<th>
321                    <p>
322                      Expression
323                    </p>
324                  </th>
325<th>
326                    <p>
327                      Semantics
328                    </p>
329                  </th>
330</tr></thead>
331<tbody>
332<tr>
333<td>
334                    <p>
335</p>
336<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">real_generator</span><span class="special">&lt;</span>
337    <span class="identifier">Num</span><span class="special">,</span> <span class="identifier">RealPolicies</span>
338<span class="special">&gt;()</span></pre>
339<p>
340                    </p>
341                  </td>
342<td>
343                    <p>
344                      Generate the real number of type <code class="computeroutput"><span class="identifier">Num</span></code>
345                      provided by a mandatory attribute using the specified <code class="computeroutput"><span class="identifier">RealPolicies</span></code>. This generator
346                      never fails (unless the underlying output stream reports an
347                      error).
348                    </p>
349                  </td>
350</tr>
351<tr>
352<td>
353                    <p>
354</p>
355<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">real_generator</span><span class="special">&lt;</span>
356    <span class="identifier">Num</span><span class="special">,</span> <span class="identifier">RealPolicies</span>
357<span class="special">&gt;()(</span><span class="identifier">num</span><span class="special">)</span></pre>
358<p>
359                    </p>
360                  </td>
361<td>
362                    <p>
363                      Generate the real number of type <code class="computeroutput"><span class="identifier">Num</span></code>
364                      provided by the immediate literal value the generator is initialized
365                      from using the specified <code class="computeroutput"><span class="identifier">RealPolicies</span></code>.
366                      If this generator has an associated attribute it succeeds only
367                      if the attribute is equal to the immediate literal (unless
368                      the underlying output stream reports an error). Otherwise this
369                      generator fails and does not generate any output.
370                    </p>
371                  </td>
372</tr>
373</tbody>
374</table></div>
375<h6>
376<a name="spirit.karma.reference.numeric.real_number.h7"></a>
377            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.additional_requirements"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.additional_requirements">Additional
378            Requirements</a>
379          </h6>
380<p>
381            The following list enumerates the requirements which must be met in order
382            to use a certain type <code class="computeroutput"><span class="identifier">Num</span></code>
383            to instantiate a <code class="computeroutput"><span class="identifier">real_generator</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">,</span> <span class="identifier">Policies</span><span class="special">&gt;</span></code>.
384          </p>
385<p>
386            In order to be usable as the first template parameter for <code class="computeroutput"><span class="identifier">real_generator</span><span class="special">&lt;&gt;</span></code>
387            the type <code class="computeroutput"><span class="identifier">Num</span></code> must have
388            defined:
389          </p>
390<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
391<li class="listitem">
392                comparison operators for: <code class="computeroutput"><span class="special">&lt;</span></code>,
393                <code class="computeroutput"><span class="special">&lt;=</span></code>, <code class="computeroutput"><span class="special">==</span></code>, <code class="computeroutput"><span class="special">!=</span></code>,
394                <code class="computeroutput"><span class="special">&gt;</span></code>, and <code class="computeroutput"><span class="special">&gt;=</span></code>
395              </li>
396<li class="listitem">
397                numeric operators for: <code class="computeroutput"><span class="special">+</span></code>,
398                <code class="computeroutput"><span class="special">-</span></code>, <code class="computeroutput"><span class="special">/</span></code>,
399                <code class="computeroutput"><span class="special">*</span></code>, and <code class="computeroutput"><span class="special">%</span></code>
400              </li>
401<li class="listitem">
402                functions implementing the interface and the semantics of: <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">fmod</span></code>, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pow</span></code>,
403                <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">log10</span></code>, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">lround</span></code>,
404                <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ltrunc</span></code>, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">modf</span></code>,
405                <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">floor</span></code>, and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ceil</span></code>.
406                These need to be defined in a way so that they will be found using
407                argument dependent lookup (ADL).
408              </li>
409<li class="listitem">
410                a valid specialization of the type <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;</span></code> allowing for numeric property
411                inspection.
412              </li>
413</ul></div>
414<h6>
415<a name="spirit.karma.reference.numeric.real_number.h8"></a>
416            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.attributes"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.attributes">Attributes</a>
417          </h6>
418<div class="informaltable"><table class="table">
419<colgroup>
420<col>
421<col>
422</colgroup>
423<thead><tr>
424<th>
425                    <p>
426                      Expression
427                    </p>
428                  </th>
429<th>
430                    <p>
431                      Attribute
432                    </p>
433                  </th>
434</tr></thead>
435<tbody>
436<tr>
437<td>
438                    <p>
439                      <code class="computeroutput"><span class="identifier">lit</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></code>
440                    </p>
441                  </td>
442<td>
443                    <p>
444                      <code class="computeroutput"><span class="identifier">unused</span></code>
445                    </p>
446                  </td>
447</tr>
448<tr>
449<td>
450                    <p>
451                      <code class="computeroutput"><span class="identifier">float_</span></code>
452                    </p>
453                  </td>
454<td>
455                    <p>
456                      <code class="computeroutput"><span class="keyword">float</span></code>, attribute
457                      is mandatory (otherwise compilation will fail)
458                    </p>
459                  </td>
460</tr>
461<tr>
462<td>
463                    <p>
464                      <code class="computeroutput"><span class="identifier">float_</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></code>
465                    </p>
466                  </td>
467<td>
468                    <p>
469                      <code class="computeroutput"><span class="identifier">float_</span></code>, attribute
470                      is optional, if it is supplied, the generator compares the
471                      attribute with <code class="computeroutput"><span class="identifier">num</span></code>
472                      and succeeds only if both are equal, failing otherwise.
473                    </p>
474                  </td>
475</tr>
476<tr>
477<td>
478                    <p>
479                      <code class="computeroutput"><span class="identifier">double_</span></code>
480                    </p>
481                  </td>
482<td>
483                    <p>
484                      <code class="computeroutput"><span class="keyword">double</span></code>, attribute
485                      is mandatory (otherwise compilation will fail)
486                    </p>
487                  </td>
488</tr>
489<tr>
490<td>
491                    <p>
492                      <code class="computeroutput"><span class="identifier">double_</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></code>
493                    </p>
494                  </td>
495<td>
496                    <p>
497                      <code class="computeroutput"><span class="keyword">double</span></code>, attribute
498                      is optional, if it is supplied, the generator compares the
499                      attribute with <code class="computeroutput"><span class="identifier">num</span></code>
500                      and succeeds only if both are equal, failing otherwise.
501                    </p>
502                  </td>
503</tr>
504<tr>
505<td>
506                    <p>
507                      <code class="computeroutput"><span class="identifier">long_double</span></code>
508                    </p>
509                  </td>
510<td>
511                    <p>
512                      <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>,
513                      attribute is mandatory (otherwise compilation will fail)
514                    </p>
515                  </td>
516</tr>
517<tr>
518<td>
519                    <p>
520                      <code class="computeroutput"><span class="identifier">long_double</span><span class="special">(</span><span class="identifier">num</span><span class="special">)</span></code>
521                    </p>
522                  </td>
523<td>
524                    <p>
525                      <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>,
526                      attribute is optional, if it is supplied, the generator compares
527                      the attribute with <code class="computeroutput"><span class="identifier">num</span></code>
528                      and succeeds only if both are equal, failing otherwise.
529                    </p>
530                  </td>
531</tr>
532<tr>
533<td>
534                    <p>
535</p>
536<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">real_generator</span><span class="special">&lt;</span>
537    <span class="identifier">Num</span><span class="special">,</span> <span class="identifier">Policies</span>
538<span class="special">&gt;()</span></pre>
539<p>
540                    </p>
541                  </td>
542<td>
543                    <p>
544                      <code class="computeroutput"><span class="identifier">Num</span></code>, attribute
545                      is mandatory (otherwise compilation will fail)
546                    </p>
547                  </td>
548</tr>
549<tr>
550<td>
551                    <p>
552</p>
553<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">real_generator</span><span class="special">&lt;</span>
554    <span class="identifier">Num</span><span class="special">,</span> <span class="identifier">Policies</span>
555<span class="special">&gt;()(</span><span class="identifier">num</span><span class="special">)</span></pre>
556<p>
557                    </p>
558                  </td>
559<td>
560                    <p>
561                      <code class="computeroutput"><span class="identifier">Num</span></code>, attribute
562                      is optional, if it is supplied, the generator compares the
563                      attribute with <code class="computeroutput"><span class="identifier">num</span></code>
564                      and succeeds only if both are equal, failing otherwise.
565                    </p>
566                  </td>
567</tr>
568</tbody>
569</table></div>
570<div class="note"><table border="0" summary="Note">
571<tr>
572<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../images/note.png"></td>
573<th align="left">Note</th>
574</tr>
575<tr><td align="left" valign="top"><p>
576              In addition to their usual attribute of type <code class="computeroutput"><span class="identifier">Num</span></code>
577              all listed generators accept an instance of a <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;</span></code> as well. If the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code> is initialized (holds a value)
578              the generators behave as if their attribute was an instance of <code class="computeroutput"><span class="identifier">Num</span></code> and emit the value stored in
579              the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;&gt;</span></code>.
580              Otherwise the generators will fail.
581            </p></td></tr>
582</table></div>
583<h6>
584<a name="spirit.karma.reference.numeric.real_number.h9"></a>
585            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.real_number_formatting_policies"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.real_number_formatting_policies">Real
586            Number Formatting Policies</a>
587          </h6>
588<p>
589            If special formatting of a real number is needed, overload the policy
590            class <code class="computeroutput"><span class="identifier">real_policies</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;</span></code>
591            and use it as a template parameter to the <code class="computeroutput"><span class="identifier">real_generator</span><span class="special">&lt;&gt;</span></code> real number generator. For instance:
592          </p>
593<pre class="programlisting"><span class="comment">// define a new real number formatting policy</span>
594<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Num</span><span class="special">&gt;</span>
595<span class="keyword">struct</span> <span class="identifier">scientific_policy</span> <span class="special">:</span> <span class="identifier">real_policies</span><span class="special">&lt;</span><span class="identifier">Num</span><span class="special">&gt;</span>
596<span class="special">{</span>
597    <span class="comment">// we want the numbers always to be in scientific format</span>
598    <span class="keyword">static</span> <span class="keyword">int</span> <span class="identifier">floatfield</span><span class="special">(</span><span class="identifier">Num</span> <span class="identifier">n</span><span class="special">)</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">fmtflags</span><span class="special">::</span><span class="identifier">scientific</span><span class="special">;</span> <span class="special">}</span>
599<span class="special">};</span>
600
601<span class="comment">// define a new generator type based on the new policy</span>
602<span class="keyword">typedef</span> <span class="identifier">real_generator</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">,</span> <span class="identifier">scientific_policy</span><span class="special">&lt;</span><span class="keyword">double</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">science_type</span><span class="special">;</span>
603<span class="identifier">science_type</span> <span class="keyword">const</span> <span class="identifier">scientific</span> <span class="special">=</span> <span class="identifier">science_type</span><span class="special">();</span>
604
605<span class="comment">// use the new generator </span>
606<span class="identifier">generate</span><span class="special">(</span><span class="identifier">sink</span><span class="special">,</span> <span class="identifier">science_type</span><span class="special">(),</span> <span class="number">1.0</span><span class="special">);</span>  <span class="comment">// will output: 1.0e00</span>
607<span class="identifier">generate</span><span class="special">(</span><span class="identifier">sink</span><span class="special">,</span> <span class="identifier">scientific</span><span class="special">,</span> <span class="number">0.1</span><span class="special">);</span>      <span class="comment">// will output: 1.0e-01</span>
608</pre>
609<p>
610            The template parameter <code class="computeroutput"><span class="identifier">Num</span></code>
611            should be the type to be formatted using the overloaded policy type.
612            At the same time <code class="computeroutput"><span class="identifier">Num</span></code>
613            will be used as the attribute type of the created real number generator.
614          </p>
615<h6>
616<a name="spirit.karma.reference.numeric.real_number.h10"></a>
617            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.real_number_formatting_policy_expression_semantics"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.real_number_formatting_policy_expression_semantics">Real
618            Number Formatting Policy Expression Semantics</a>
619          </h6>
620<p>
621            A real number formatting policy should expose the following variables
622            and functions:
623          </p>
624<div class="informaltable"><table class="table">
625<colgroup>
626<col>
627<col>
628</colgroup>
629<thead><tr>
630<th>
631                    <p>
632                      Expression
633                    </p>
634                  </th>
635<th>
636                    <p>
637                      Description
638                    </p>
639                  </th>
640</tr></thead>
641<tbody>
642<tr>
643<td>
644                    <p>
645</p>
646<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Inserter</span>
647  <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span>
648  <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Policies</span><span class="special">&gt;</span>
649<span class="keyword">bool</span> <span class="identifier">call</span> <span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span>
650  <span class="special">,</span> <span class="identifier">Policies</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">);</span>
651</pre>
652<p>
653                    </p>
654                  </td>
655<td>
656                    <p>
657                      This is the main function used to generate the output for a
658                      real number. It is called by the real generator in order to
659                      perform the conversion. In theory all of the work can be implemented
660                      here, but the easiest way is to use existing functionality
661                      provided by the type specified by the template parameter <code class="computeroutput"><span class="identifier">Inserter</span></code>. The default implementation
662                      of this functions is:
663</p>
664<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Inserter</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span>
665  <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Policies</span><span class="special">&gt;</span>
666<span class="keyword">static</span> <span class="keyword">bool</span>
667<span class="identifier">call</span> <span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">Policies</span> <span class="keyword">const</span><span class="special">&amp;</span> <span class="identifier">p</span><span class="special">)</span>
668<span class="special">{</span>
669    <span class="keyword">return</span> <span class="identifier">Inserter</span><span class="special">::</span><span class="identifier">call_n</span><span class="special">(</span><span class="identifier">sink</span><span class="special">,</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">p</span><span class="special">);</span>
670<span class="special">}</span>
671</pre>
672<p>
673                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
674                      output iterator to use for generation
675                    </p>
676                    <p>
677                      <code class="computeroutput"><span class="identifier">n</span></code> is the real
678                      number to convert
679                    </p>
680                    <p>
681                      <code class="computeroutput"><span class="identifier">p</span></code> is the instance
682                      of the policy type used to instantiate this real number generator.
683                    </p>
684                  </td>
685</tr>
686<tr>
687<td>
688                    <p>
689</p>
690<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">bool</span> <span class="identifier">force_sign</span><span class="special">(</span><span class="identifier">Num</span> <span class="identifier">n</span><span class="special">);</span>
691</pre>
692<p>
693                    </p>
694                  </td>
695<td>
696                    <p>
697                      The default behavior is to not to require generating a sign.
698                      If the function <code class="computeroutput"><span class="identifier">force_sign</span><span class="special">()</span></code> returns true, then all generated
699                      numbers will have a sign (<code class="computeroutput"><span class="char">'+'</span></code>
700                      or <code class="computeroutput"><span class="char">'-'</span></code>, zeros will
701                      have a space instead of a sign).
702                    </p>
703                    <p>
704                      <code class="computeroutput"><span class="identifier">n</span></code> is the real
705                      number to output. This can be used to adjust the required behavior
706                      depending on the value of this number.
707                    </p>
708                  </td>
709</tr>
710<tr>
711<td>
712                    <p>
713</p>
714<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">bool</span> <span class="identifier">trailing_zeros</span><span class="special">(</span><span class="identifier">Num</span> <span class="identifier">n</span><span class="special">);</span>
715</pre>
716<p>
717                    </p>
718                  </td>
719<td>
720                    <p>
721                      Return whether trailing zero digits have to be emitted in the
722                      fractional part of the output. If set, this flag instructs
723                      the real number generator to emit trailing zeros up to the
724                      required precision digits (as returned by the <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code>
725                      function).
726                    </p>
727                    <p>
728                      <code class="computeroutput"><span class="identifier">n</span></code> is the real
729                      number to output. This can be used to adjust the required behavior
730                      depending on the value of this number.
731                    </p>
732                  </td>
733</tr>
734<tr>
735<td>
736                    <p>
737</p>
738<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">int</span> <span class="identifier">floatfield</span><span class="special">(</span><span class="identifier">Num</span> <span class="identifier">n</span><span class="special">);</span>
739</pre>
740<p>
741                    </p>
742                  </td>
743<td>
744                    <p>
745                      Decide, which representation type to use in the generated output.
746                    </p>
747                    <p>
748                      By default all numbers having an absolute value of zero or
749                      in between <code class="computeroutput"><span class="number">0.001</span></code>
750                      and <code class="computeroutput"><span class="number">100000</span></code> will
751                      be generated using the fixed format, all others will be generated
752                      using the scientific representation.
753                    </p>
754                    <p>
755                      The <code class="computeroutput"><span class="identifier">trailing_zeros</span><span class="special">()</span></code> can be used to force the
756                      output of trailing zeros in the fractional part up to the number
757                      of digits returned by the <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code> member function. The default
758                      is not to generate the trailing zeros.
759                    </p>
760                    <p>
761                      <code class="computeroutput"><span class="identifier">n</span></code> is the real
762                      number to output. This can be used to adjust the formatting
763                      flags depending on the value of this number.
764                    </p>
765                    <p>
766                      The return value has to be either <code class="computeroutput"><span class="identifier">fmtflags</span><span class="special">::</span><span class="identifier">scientific</span></code>
767                      (generate real number values in scientific notation) or <code class="computeroutput"><span class="identifier">fmtflags</span><span class="special">::</span><span class="identifier">fixed</span></code> (generate real number
768                      values in fixed-point notation).
769                    </p>
770                  </td>
771</tr>
772<tr>
773<td>
774                    <p>
775</p>
776<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">unsigned</span> <span class="identifier">precision</span><span class="special">(</span><span class="identifier">Num</span> <span class="identifier">n</span><span class="special">);</span>
777</pre>
778<p>
779                    </p>
780                  </td>
781<td>
782                    <p>
783                      Return the maximum number of decimal digits to generate in
784                      the fractional part of the output.
785                    </p>
786                    <p>
787                      <code class="computeroutput"><span class="identifier">n</span></code> is the real
788                      number to output. This can be used to adjust the required precision
789                      depending on the value of this number. If the trailing zeros
790                      flag is specified the fractional part of the output will be
791                      'filled' with zeros, if appropriate.
792                    </p>
793                    <p>
794                      <span class="bold"><strong>Note:</strong></span> If the trailing_zeros
795                      flag is not in effect additional semantics apply. See the description
796                      for the <code class="computeroutput"><span class="identifier">fraction_part</span><span class="special">()</span></code> function below. Moreover,
797                      this precision will be limited to the value of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">+</span>
798                      <span class="number">1</span></code>.
799                    </p>
800                  </td>
801</tr>
802<tr>
803<td>
804                    <p>
805</p>
806<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
807<span class="keyword">bool</span> <span class="identifier">integer_part</span><span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span>
808  <span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">sign</span><span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">force_sign</span><span class="special">);</span>
809</pre>
810<p>
811                    </p>
812                  </td>
813<td>
814                    <p>
815                      This function is called to generate the integer part of the
816                      real number.
817                    </p>
818                    <p>
819                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
820                      output iterator to use for generation
821                    </p>
822                    <p>
823                      <code class="computeroutput"><span class="identifier">n</span></code> is the absolute
824                      value of the integer part of the real number to convert (always
825                      non-negative)
826                    </p>
827                    <p>
828                      <code class="computeroutput"><span class="identifier">sign</span></code> is the
829                      sign of the overall real number to convert.
830                    </p>
831                    <p>
832                      <code class="computeroutput"><span class="identifier">force_sign</span></code>
833                      is a flag indicating whether a sign has to be generated even
834                      for non-negative numbers (this is the same as has been returned
835                      from the function <code class="computeroutput"><span class="identifier">force_sign</span><span class="special">()</span></code> described above)
836                    </p>
837                    <p>
838                      The return value defines the outcome of the whole generator.
839                      If it is <code class="computeroutput"><span class="keyword">false</span></code>,
840                      no further output is generated, immediately returning <code class="computeroutput"><span class="keyword">false</span></code> from the calling <code class="computeroutput"><span class="identifier">real_generator</span></code> as well. If
841                      it is <code class="computeroutput"><span class="keyword">true</span></code>, normal
842                      output generation continues.
843                    </p>
844                  </td>
845</tr>
846<tr>
847<td>
848                    <p>
849</p>
850<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
851<span class="keyword">bool</span> <span class="identifier">dot</span><span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span><span class="special">,</span>
852  <span class="keyword">unsigned</span> <span class="identifier">precision</span><span class="special">);</span>
853</pre>
854<p>
855                    </p>
856                  </td>
857<td>
858                    <p>
859                      This function is called to generate the decimal point.
860                    </p>
861                    <p>
862                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
863                      output iterator to use for generation
864                    </p>
865                    <p>
866                      <code class="computeroutput"><span class="identifier">n</span></code> is the fractional
867                      part of the real number to convert. Note that this number is
868                      scaled such, that it represents the number of units which correspond
869                      to the value returned from the <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code> function earlier. I.e. a
870                      fractional part of <code class="computeroutput"><span class="number">0.01234</span></code>
871                      is represented as <code class="computeroutput"><span class="number">1234</span></code>
872                      when the function <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code> returned <code class="computeroutput"><span class="number">5</span></code>.
873                    </p>
874                    <p>
875                      <code class="computeroutput"><span class="identifier">precision</span></code> is
876                      the number of digits to emit as returned by the function <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code>
877                      described above
878                    </p>
879                    <p>
880                      This is given to allow to decide, whether a decimal point has
881                      to be generated at all.
882                    </p>
883                    <p>
884                      <span class="bold"><strong>Note:</strong></span> If the <code class="computeroutput"><span class="identifier">trailing_zeros</span></code> flag is not
885                      in effect additional comments apply. See the description for
886                      the <code class="computeroutput"><span class="identifier">fraction_part</span><span class="special">()</span></code> function below.
887                    </p>
888                    <p>
889                      The return value defines the outcome of the whole generator.
890                      If it is <code class="computeroutput"><span class="keyword">false</span></code>,
891                      no further output is generated, immediately returning <code class="computeroutput"><span class="keyword">false</span></code> from the calling <code class="computeroutput"><span class="identifier">real_generator</span></code> as well. If
892                      it is <code class="computeroutput"><span class="keyword">true</span></code>, normal
893                      output generation continues.
894                    </p>
895                  </td>
896</tr>
897<tr>
898<td>
899                    <p>
900</p>
901<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
902<span class="keyword">bool</span> <span class="identifier">fraction_part</span><span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span>
903  <span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">adjprec</span><span class="special">,</span> <span class="keyword">unsigned</span> <span class="identifier">precision</span><span class="special">);</span>
904</pre>
905<p>
906                    </p>
907                  </td>
908<td>
909                    <p>
910                      This function is called to generate the fractional part of
911                      the number.
912                    </p>
913                    <p>
914                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
915                      output iterator to use for generation
916                    </p>
917                    <p>
918                      <code class="computeroutput"><span class="identifier">n</span></code> is the fractional
919                      part of the real number to convert. Note that this number is
920                      scaled such, that it represents the number of units which correspond
921                      to the value returned from the <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code> function earlier. I.e. a
922                      fractional part of <code class="computeroutput"><span class="number">0.01234</span></code>
923                      is represented as <code class="computeroutput"><span class="number">1234</span></code>
924                      when the function <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code> returned <code class="computeroutput"><span class="number">5</span></code>.
925                    </p>
926                    <p>
927                      <code class="computeroutput"><span class="identifier">adjprec</span></code> is
928                      the corrected number of digits to emit (see note below)
929                    </p>
930                    <p>
931                      <code class="computeroutput"><span class="identifier">precision</span></code> is
932                      the number of digits to emit as returned by the function <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code>
933                      described above
934                    </p>
935                    <p>
936                      <span class="bold"><strong>Note:</strong></span> If <code class="computeroutput"><span class="identifier">trailing_zeros</span><span class="special">()</span></code> returns <code class="computeroutput"><span class="keyword">false</span></code>
937                      the <code class="computeroutput"><span class="identifier">adjprec</span></code>
938                      parameter will have been corrected from the value the <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code>
939                      function returned earlier (defining the maximal number of fractional
940                      digits) in the sense, that it takes into account trailing zeros.
941                      I.e. a real number <code class="computeroutput"><span class="number">0.0123</span></code>
942                      and a value of <code class="computeroutput"><span class="number">5</span></code>
943                      returned from <code class="computeroutput"><span class="identifier">precision</span><span class="special">()</span></code> will result in:
944                    </p>
945                    <p>
946                      <code class="computeroutput"><span class="identifier">trailing_zeros</span><span class="special">()</span></code> returned <code class="computeroutput"><span class="keyword">false</span></code>:
947                      <code class="computeroutput"><span class="identifier">n</span></code> will be
948                      <code class="computeroutput"><span class="number">123</span></code>, and <code class="computeroutput"><span class="identifier">adjprec</span></code> will be <code class="computeroutput"><span class="number">4</span></code> (as we need to print <code class="computeroutput"><span class="number">0123</span></code>)
949                    </p>
950                    <p>
951                      <code class="computeroutput"><span class="identifier">trailing_zeros</span><span class="special">()</span></code> returned <code class="computeroutput"><span class="keyword">true</span></code>:
952                      <code class="computeroutput"><span class="identifier">n</span></code> will be
953                      <code class="computeroutput"><span class="number">1230</span></code>, and <code class="computeroutput"><span class="identifier">adjprec</span></code> will be <code class="computeroutput"><span class="number">5</span></code> (as we need to print <code class="computeroutput"><span class="number">01230</span></code>)
954                    </p>
955                    <p>
956                      The missing preceding zeros in the fractional part have to
957                      be supplied by the implementation of this policy function.
958                    </p>
959                    <p>
960                      The return value defines the outcome of the whole generator.
961                      If it is <code class="computeroutput"><span class="keyword">false</span></code>,
962                      no further output is generated, immediately returning <code class="computeroutput"><span class="keyword">false</span></code> from the calling <code class="computeroutput"><span class="identifier">real_generator</span></code> as well. If
963                      it is <code class="computeroutput"><span class="keyword">true</span></code>, normal
964                      output generation continues.
965                    </p>
966                  </td>
967</tr>
968<tr>
969<td>
970                    <p>
971</p>
972<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">CharEncoding</span><span class="special">,</span>
973    <span class="keyword">typename</span> <span class="identifier">Tag</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
974<span class="keyword">bool</span> <span class="identifier">exponent</span><span class="special">(</span>
975    <span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="keyword">long</span> <span class="identifier">n</span><span class="special">);</span>
976</pre>
977<p>
978                    </p>
979                  </td>
980<td>
981                    <p>
982                      This function is called to generate the exponential part of
983                      the number (this is called only if the <code class="computeroutput"><span class="identifier">floatfield</span><span class="special">()</span></code> function returned the <code class="computeroutput"><span class="identifier">fmtflags</span><span class="special">::</span><span class="identifier">scientific</span></code> flag).
984                    </p>
985                    <p>
986                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
987                      output iterator to use for generation
988                    </p>
989                    <p>
990                      <code class="computeroutput"><span class="identifier">n</span></code> is the (signed)
991                      exponential part of the real number to convert.
992                    </p>
993                    <p>
994                      The template parameters <code class="computeroutput"><span class="identifier">CharEncoding</span></code>
995                      and <code class="computeroutput"><span class="identifier">Tag</span></code> are
996                      either of the type <code class="computeroutput"><span class="identifier">unused_type</span></code>
997                      or describe the character class and conversion to be applied
998                      to any output possibly influenced by either the <code class="computeroutput"><span class="identifier">lower</span><span class="special">[]</span></code>
999                      or <code class="computeroutput"><span class="identifier">upper</span><span class="special">[]</span></code>
1000                      directives.
1001                    </p>
1002                    <p>
1003                      The return value defines the outcome of the whole generator.
1004                      If it is <code class="computeroutput"><span class="keyword">false</span></code>,
1005                      no further output is generated, immediately returning <code class="computeroutput"><span class="keyword">false</span></code> from the calling <code class="computeroutput"><span class="identifier">real_generator</span></code> as well. If
1006                      it is <code class="computeroutput"><span class="keyword">true</span></code>, normal
1007                      output generation continues.
1008                    </p>
1009                  </td>
1010</tr>
1011<tr>
1012<td>
1013                    <p>
1014</p>
1015<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">CharEncoding</span>
1016  <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Tag</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
1017<span class="keyword">bool</span> <span class="identifier">nan</span> <span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span>
1018  <span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">force_sign</span><span class="special">);</span>
1019</pre>
1020<p>
1021                    </p>
1022                  </td>
1023<td>
1024                    <p>
1025                      This function is called whenever the number to print is a non-normal
1026                      real number of type <code class="computeroutput"><span class="identifier">NaN</span></code>.
1027                    </p>
1028                    <p>
1029                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
1030                      output iterator to use for generation
1031                    </p>
1032                    <p>
1033                      <code class="computeroutput"><span class="identifier">n</span></code> is the (signed)
1034                      real number to convert
1035                    </p>
1036                    <p>
1037                      <code class="computeroutput"><span class="identifier">force_sign</span></code>
1038                      is a flag indicating whether a sign has to be generated even
1039                      for non-negative numbers (this is the same as has been returned
1040                      from the function <code class="computeroutput"><span class="identifier">force_sign</span><span class="special">()</span></code> described above)
1041                    </p>
1042                    <p>
1043                      The template parameters <code class="computeroutput"><span class="identifier">CharEncoding</span></code>
1044                      and <code class="computeroutput"><span class="identifier">Tag</span></code> are
1045                      either of the type <code class="computeroutput"><span class="identifier">unused_type</span></code>
1046                      or describe the character class and conversion to be applied
1047                      to any output possibly influenced by either the <code class="computeroutput"><span class="identifier">lower</span><span class="special">[]</span></code>
1048                      or <code class="computeroutput"><span class="identifier">upper</span><span class="special">[]</span></code>
1049                      directives.
1050                    </p>
1051                    <p>
1052                      The return value defines the outcome of the whole generator.
1053                      If it is <code class="computeroutput"><span class="keyword">false</span></code>,
1054                      no further output is generated, immediately returning <code class="computeroutput"><span class="keyword">false</span></code> from the calling <code class="computeroutput"><span class="identifier">real_generator</span></code> as well. If
1055                      it is <code class="computeroutput"><span class="keyword">true</span></code>, normal
1056                      output generation continues.
1057                    </p>
1058                  </td>
1059</tr>
1060<tr>
1061<td>
1062                    <p>
1063</p>
1064<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">CharEncoding</span>
1065  <span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Tag</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
1066<span class="keyword">bool</span> <span class="identifier">inf</span> <span class="special">(</span><span class="identifier">OutputIterator</span><span class="special">&amp;</span> <span class="identifier">sink</span><span class="special">,</span> <span class="identifier">Num</span> <span class="identifier">n</span>
1067  <span class="special">,</span> <span class="keyword">bool</span> <span class="identifier">force_sign</span><span class="special">);</span>
1068</pre>
1069<p>
1070                    </p>
1071                  </td>
1072<td>
1073                    <p>
1074                      This function is called whenever the number to print is a non-normal
1075                      real number of type <code class="computeroutput"><span class="identifier">Inf</span></code>.
1076                    </p>
1077                    <p>
1078                      <code class="computeroutput"><span class="identifier">sink</span></code> is the
1079                      output iterator to use for generation
1080                    </p>
1081                    <p>
1082                      <code class="computeroutput"><span class="identifier">n</span></code> is the (signed)
1083                      real number to convert
1084                    </p>
1085                    <p>
1086                      <code class="computeroutput"><span class="identifier">force_sign</span></code>
1087                      is a flag indicating whether a sign has to be generated even
1088                      for non-negative numbers (this is the same as has been returned
1089                      from the function <code class="computeroutput"><span class="identifier">force_sign</span><span class="special">()</span></code> described above)
1090                    </p>
1091                    <p>
1092                      The template parameters <code class="computeroutput"><span class="identifier">CharEncoding</span></code>
1093                      and <code class="computeroutput"><span class="identifier">Tag</span></code> are
1094                      either of the type <code class="computeroutput"><span class="identifier">unused_type</span></code>
1095                      or describe the character class and conversion to be applied
1096                      to any output possibly influenced by either the <code class="computeroutput"><span class="identifier">lower</span><span class="special">[]</span></code>
1097                      or <code class="computeroutput"><span class="identifier">upper</span><span class="special">[]</span></code>
1098                      directives.
1099                    </p>
1100                    <p>
1101                      The return value defines the outcome of the whole generator.
1102                      If it is <code class="computeroutput"><span class="keyword">false</span></code>,
1103                      no further output is generated, immediately returning <code class="computeroutput"><span class="keyword">false</span></code> from the calling <code class="computeroutput"><span class="identifier">real_generator</span></code> as well. If
1104                      it is <code class="computeroutput"><span class="keyword">true</span></code>, normal
1105                      output generation continues.
1106                    </p>
1107                  </td>
1108</tr>
1109</tbody>
1110</table></div>
1111<div class="tip"><table border="0" summary="Tip">
1112<tr>
1113<td rowspan="2" align="center" valign="top" width="25"><img alt="[Tip]" src="../../../../images/tip.png"></td>
1114<th align="left">Tip</th>
1115</tr>
1116<tr><td align="left" valign="top"><p>
1117              The easiest way to implement a proper real number formatting policy
1118              is to derive a new type from the type <code class="computeroutput"><span class="identifier">real_policies</span><span class="special">&lt;&gt;</span></code> while overriding the aspects
1119              of the formatting which need to be changed.
1120            </p></td></tr>
1121</table></div>
1122<h6>
1123<a name="spirit.karma.reference.numeric.real_number.h11"></a>
1124            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.complexity"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.complexity">Complexity</a>
1125          </h6>
1126<div class="blockquote"><blockquote class="blockquote"><p>
1127              O(N), where <code class="computeroutput"><span class="identifier">N</span></code> is the
1128              number of digits needed to represent the generated real number.
1129            </p></blockquote></div>
1130<h6>
1131<a name="spirit.karma.reference.numeric.real_number.h12"></a>
1132            <span class="phrase"><a name="spirit.karma.reference.numeric.real_number.example"></a></span><a class="link" href="real_number.html#spirit.karma.reference.numeric.real_number.example">Example</a>
1133          </h6>
1134<div class="note"><table border="0" summary="Note">
1135<tr>
1136<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../images/note.png"></td>
1137<th align="left">Note</th>
1138</tr>
1139<tr><td align="left" valign="top"><p>
1140              The test harness for the example(s) below is presented in the <a class="link" href="../basics.html#spirit.karma.reference.basics.examples">Basics Examples</a>
1141              section.
1142            </p></td></tr>
1143</table></div>
1144<p>
1145            Some includes:
1146          </p>
1147<p>
1148</p>
1149<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">karma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
1150<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">support_utree</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
1151<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">phoenix_core</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
1152<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">spirit</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">phoenix_operator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
1153<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">fusion</span><span class="special">/</span><span class="identifier">include</span><span class="special">/</span><span class="identifier">std_pair</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
1154<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
1155<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">string</span><span class="special">&gt;</span>
1156</pre>
1157<p>
1158          </p>
1159<p>
1160            Some using declarations:
1161          </p>
1162<p>
1163</p>
1164<pre class="programlisting"><span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">spirit</span><span class="special">::</span><span class="identifier">karma</span><span class="special">::</span><span class="identifier">double_</span><span class="special">;</span>
1165<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">spirit</span><span class="special">::</span><span class="identifier">karma</span><span class="special">::</span><span class="identifier">lit</span><span class="special">;</span>
1166</pre>
1167<p>
1168          </p>
1169<p>
1170            Basic usage of an <code class="computeroutput"><span class="identifier">double_</span></code>
1171            generator:
1172          </p>
1173<p>
1174</p>
1175<pre class="programlisting"><span class="identifier">test_generator</span><span class="special">(</span><span class="string">"2.0"</span><span class="special">,</span> <span class="identifier">lit</span><span class="special">(</span><span class="number">2.0</span><span class="special">));</span>
1176<span class="identifier">test_generator</span><span class="special">(</span><span class="string">"2.0"</span><span class="special">,</span> <span class="identifier">double_</span><span class="special">(</span><span class="number">2</span><span class="special">));</span>
1177<span class="identifier">test_generator_attr</span><span class="special">(</span><span class="string">"2.0"</span><span class="special">,</span> <span class="identifier">double_</span><span class="special">(</span><span class="number">2.0</span><span class="special">),</span> <span class="number">2.0</span><span class="special">);</span>
1178<span class="identifier">test_generator_attr</span><span class="special">(</span><span class="string">""</span><span class="special">,</span> <span class="identifier">double_</span><span class="special">(</span><span class="number">2.0</span><span class="special">),</span> <span class="number">3.0</span><span class="special">);</span>    <span class="comment">// fails (as 2.0 != 3.0)!</span>
1179<span class="identifier">test_generator_attr</span><span class="special">(</span><span class="string">"-2.0"</span><span class="special">,</span> <span class="identifier">double_</span><span class="special">,</span> <span class="special">-</span><span class="number">2.0</span><span class="special">);</span>
1180
1181<span class="identifier">test_generator_attr</span><span class="special">(</span><span class="string">"1.234e05"</span><span class="special">,</span> <span class="identifier">double_</span><span class="special">,</span> <span class="number">1234.0e2</span><span class="special">);</span>
1182<span class="identifier">test_generator_attr</span><span class="special">(</span><span class="string">"1.234e-06"</span><span class="special">,</span> <span class="identifier">double_</span><span class="special">,</span> <span class="number">0.000001234</span><span class="special">);</span>
1183</pre>
1184<p>
1185          </p>
1186</div>
1187<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
1188<td align="left"></td>
1189<td align="right"><div class="copyright-footer">Copyright © 2001-2011 Joel de Guzman, Hartmut Kaiser<p>
1190        Distributed under the Boost Software License, Version 1.0. (See accompanying
1191        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>)
1192      </p>
1193</div></td>
1194</tr></table>
1195<hr>
1196<div class="spirit-nav">
1197<a accesskey="p" href="signed_int.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../numeric.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="boolean.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
1198</div>
1199</body>
1200</html>
1201