generic-library/boost
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
boost/libs/multiprecision/doc/html/boost_multiprecision/tut/floats/float128.html
Edouard DUPIN d0115b733d [DEV] add v1.76.0
2021-10-05 21:37:46 +02:00

270 lines
32 KiB
HTML
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>float128</title>
<link rel="stylesheet" href="../../../multiprecision.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../floats.html" title="Floating-point Types">
<link rel="prev" href="mpfr_float.html" title="mpfr_float">
<link rel="next" href="fp_eg.html" title="Examples">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.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="fp_eg.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_multiprecision.tut.floats.float128"></a><a class="link" href="float128.html" title="float128">float128</a>
</h4></div></div></div>
<p>
<code class="computeroutput"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
<pre class="programlisting"><span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">{</span> <span class="keyword">namespace</span> <span class="identifier">multiprecision</span><span class="special">{</span>
<span class="keyword">class</span> <span class="identifier">float128_backend</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">number</span><span class="special">&lt;</span><span class="identifier">float128_backend</span><span class="special">,</span> <span class="identifier">et_off</span><span class="special">&gt;</span> <span class="identifier">float128</span><span class="special">;</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
The <code class="computeroutput"><span class="identifier">float128</span></code> number type
is a very thin wrapper around GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
or Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data types
and provides an real-number type that is a drop-in replacement for the
native C++ floating-point types, but with a 113 bit mantissa, and compatible
with FORTRAN's 128-bit QUAD real.
</p>
<p>
All the usual standard library and <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
support are available, performance should be equivalent to the underlying
native types: for example the LINPACK benchmarks for GCC's <code class="computeroutput"><span class="identifier">__float128</span></code> and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">float128</span></code>
both achieved 5.6 MFLOPS<a href="#ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote" name="boost_multiprecision.tut.floats.float128.f0"><sup class="footnote">[3]</sup></a>.
</p>
<p>
As well as the usual conversions from arithmetic and string types, instances
of <code class="computeroutput"><span class="identifier">float128</span></code> are copy constructible
and assignable from GCC's <code class="computeroutput"><span class="identifier">__float128</span></code>
and Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code> data
types.
</p>
<p>
It's also possible to access the underlying <code class="computeroutput"><span class="identifier">__float128</span></code>
or <code class="computeroutput"><span class="identifier">_Quad</span></code> type via the
<code class="computeroutput"><span class="identifier">data</span><span class="special">()</span></code>
member function of <code class="computeroutput"><span class="identifier">float128_backend</span></code>.
</p>
<p>
Things you should know when using this type:
</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
Default constructed <code class="computeroutput"><span class="identifier">float128</span></code>s
have the value zero.
</li>
<li class="listitem">
This backend supports rvalue-references and is move-aware, making instantiations
of <code class="computeroutput"><span class="identifier">number</span></code> on this backend
move aware.
</li>
<li class="listitem">
This type is fully <code class="computeroutput"><span class="keyword">constexpr</span></code>
aware - basic constexpr arithmetic is supported from C++14 and onwards,
comparisons, plus the functions <code class="computeroutput"><span class="identifier">fabs</span></code>,
<code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">fpclassify</span></code>, <code class="computeroutput"><span class="identifier">isnormal</span></code>,
<code class="computeroutput"><span class="identifier">isfinite</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code> and <code class="computeroutput"><span class="identifier">isnan</span></code>
are also supported if either the compiler implements C++20's <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_constant_evaluated</span><span class="special">()</span></code>,
or if the compiler is GCC.
</li>
<li class="listitem">
It is not possible to round-trip objects of this type to and from a
string and get back exactly the same value when compiled with Intel's
C++ compiler and using <code class="computeroutput"><span class="identifier">_Quad</span></code>
as the underlying type: this is a current limitation of our code. Round
tripping when using <code class="computeroutput"><span class="identifier">__float128</span></code>
as the underlying type is possible (both for GCC and Intel).
</li>
<li class="listitem">
Conversion from a string results in a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">runtime_error</span></code>
being thrown if the string can not be interpreted as a valid floating-point
number.
</li>
<li class="listitem">
Division by zero results in an infinity being produced.
</li>
<li class="listitem">
Type <code class="computeroutput"><span class="identifier">float128</span></code> can be
used as a literal type (constexpr support).
</li>
<li class="listitem">
Type <code class="computeroutput"><span class="identifier">float128</span></code> can be
used for full <code class="computeroutput"><span class="keyword">constexpr</span></code>
arithmetic from C++14 and later with GCC. The functions <code class="computeroutput"><span class="identifier">abs</span></code>, <code class="computeroutput"><span class="identifier">fabs</span></code>,
<code class="computeroutput"><span class="identifier">fpclassify</span></code>, <code class="computeroutput"><span class="identifier">isnan</span></code>, <code class="computeroutput"><span class="identifier">isinf</span></code>,
<code class="computeroutput"><span class="identifier">isfinite</span></code> and <code class="computeroutput"><span class="identifier">isnormal</span></code> are also <code class="computeroutput"><span class="keyword">constexpr</span></code>,
but the transcendental functions are not.
</li>
<li class="listitem">
When using the Intel compiler, the underlying type defaults to <code class="computeroutput"><span class="identifier">__float128</span></code> if it's available and
<code class="computeroutput"><span class="identifier">_Quad</span></code> if not. You can
override the default by defining either <code class="computeroutput"><span class="identifier">BOOST_MP_USE_FLOAT128</span></code>
or <code class="computeroutput"><span class="identifier">BOOST_MP_USE_QUAD</span></code>.
</li>
<li class="listitem">
When the underlying type is Intel's <code class="computeroutput"><span class="identifier">_Quad</span></code>
type, the code must be compiled with the compiler option <code class="computeroutput"><span class="special">-</span><span class="identifier">Qoption</span><span class="special">,</span><span class="identifier">cpp</span><span class="special">,--</span><span class="identifier">extended_float_type</span></code>.
</li>
<li class="listitem">
When compiling with <code class="computeroutput"><span class="identifier">gcc</span></code>,
you need to use the flag <code class="computeroutput"><span class="special">--</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">gnu</span><span class="special">++</span><span class="number">11</span><span class="special">/</span><span class="number">14</span><span class="special">/</span><span class="number">17</span></code>,
as the suffix 'Q' is a GNU extension. Compilation fails with the flag
<code class="computeroutput"><span class="special">--</span><span class="identifier">std</span><span class="special">=</span><span class="identifier">c</span><span class="special">++</span><span class="number">11</span><span class="special">/</span><span class="number">14</span><span class="special">/</span><span class="number">17</span></code> unless you also use <code class="computeroutput"><span class="special">-</span><span class="identifier">fext</span><span class="special">-</span><span class="identifier">numeric</span><span class="special">-</span><span class="identifier">literals</span></code>.
</li>
<li class="listitem">
You will need to link to <code class="computeroutput"><span class="identifier">libquadmath</span><span class="special">.</span><span class="identifier">dll</span></code>
with the link command <code class="computeroutput"><span class="special">-</span><span class="identifier">lquadmath</span></code> and ensure that the DLL
is visible by the linker. If you are using the B2/bjam build system
then commands<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">linkflags</span><span class="special">&gt;-</span><span class="identifier">lQUADMATH</span></code>
and <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">linkflags</span><span class="special">&gt;-</span><span class="identifier">L</span><span class="string">"path/to/lib"</span></code> will be needed.
</li>
<li class="listitem">
The values shown by <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">float128</span><span class="special">&gt;</span></code> and extremely close <span class="emphasis"><em>but
not identical</em></span> to those from the equivalent precision and
range multiprecision types <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">cpp_bin_float_quad</span><span class="special">&gt;</span></code> and <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">cpp_dec_float_quad</span><span class="special">&gt;</span></code>.
</li>
</ul></div>
<h6>
<a name="boost_multiprecision.tut.floats.float128.h0"></a>
<span class="phrase"><a name="boost_multiprecision.tut.floats.float128.float128_example"></a></span><a class="link" href="float128.html#boost_multiprecision.tut.floats.float128.float128_example">float128
example:</a>
</h6>
<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">multiprecision</span><span class="special">/</span><span class="identifier">float128</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</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">gamma</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">;</span> <span class="comment">// Potential to cause name collisions?</span>
<span class="comment">// using boost::multiprecision::float128; // is safer.</span>
</pre>
<p>
The type float128 provides operations at 128-bit precision with <a href="https://en.wikipedia.org/wiki/Quadruple-precision_floating-point_format#IEEE_754_quadruple-precision_binary_floating-point_format:_binary128" target="_top">Quadruple-precision
floating-point format</a> and have full <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span></code>
support:
</p>
<pre class="programlisting"><span class="identifier">float128</span> <span class="identifier">b</span> <span class="special">=</span> <span class="number">2</span><span class="special">;</span>
</pre>
<p>
There are 15 bits of (biased) binary exponent and 113-bits of significand
precision
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
or 33 decimal places:
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">digits10</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
We can use any C++ std library function, so let's show all the at-most
36 potentially significant digits, and any trailing zeros, as well:
</p>
<pre class="programlisting"> <span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">.</span><span class="identifier">setf</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">ios_base</span><span class="special">::</span><span class="identifier">showpoint</span><span class="special">);</span> <span class="comment">// Include any trailing zeros.</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">setprecision</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">)</span>
<span class="special">&lt;&lt;</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">// Shows log(2) = 0.693147180559945309417232121458176575</span>
</pre>
<p>
We can also use any function from Boost.Math, for example, the 'true gamma'
function <code class="computeroutput"><span class="identifier">tgamma</span></code>:
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">b</span><span class="special">)</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
And since we have an extended exponent range, we can generate some really
large numbers here (4.02387260077093773543702433923004111e+2564):
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">math</span><span class="special">::</span><span class="identifier">tgamma</span><span class="special">(</span><span class="identifier">float128</span><span class="special">(</span><span class="number">1000</span><span class="special">))</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
</pre>
<p>
We can declare constants using GCC or Intel's native types, and literals
with the Q suffix, and these can be declared <code class="computeroutput"><span class="keyword">constexpr</span></code>
if required:
</p>
<pre class="programlisting"><span class="comment">// std::numeric_limits&lt;float128&gt;::max_digits10 = 36</span>
<span class="keyword">constexpr</span> <span class="identifier">float128</span> <span class="identifier">pi</span> <span class="special">=</span> <span class="number">3.14159265358979323846264338327950288</span><span class="identifier">Q</span><span class="special">;</span>
<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">&lt;</span><span class="identifier">float128</span><span class="special">&gt;::</span><span class="identifier">max_digits10</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"pi = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">pi</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span> <span class="comment">//pi = 3.14159265358979323846264338327950280</span>
</pre>
<p>
Values for <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">float128</span><span class="special">&gt;</span></code>
are:
</p>
<pre class="programlisting"><span class="identifier">GCC</span> <span class="number">8.1</span><span class="special">.</span><span class="number">0</span>
<span class="identifier">Type</span> <span class="identifier">name</span> <span class="identifier">is</span> <span class="identifier">float128_t</span><span class="special">:</span>
<span class="identifier">Type</span> <span class="identifier">is</span> <span class="identifier">g</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_fundamental</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_signed</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_unsigned</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">multiprecision</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_arithmetic</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_const</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_trivial</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_standard_layout</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">is_pod</span><span class="special">&lt;&gt;</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_exact</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is</span> <span class="identifier">bounded</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_modulo</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">is_iec559</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">traps</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">tinyness_before</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.18973149535723176508575932662800702e+4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">min</span><span class="special">()</span> <span class="special">=</span> <span class="number">3.36210314311209350626267781732175260e-4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">lowest</span><span class="special">()</span> <span class="special">=</span> <span class="special">-</span><span class="number">1.18973149535723176508575932662800702e+4932</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">min_exponent</span> <span class="special">=</span> <span class="special">-</span><span class="number">16381</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max_exponent</span> <span class="special">=</span> <span class="number">16384</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">epsilon</span><span class="special">()</span> <span class="special">=</span> <span class="number">1.92592994438723585305597794258492732e-34</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">radix</span> <span class="special">=</span> <span class="number">2</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">digits</span> <span class="special">=</span> <span class="number">113</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">digits10</span> <span class="special">=</span> <span class="number">33</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">max_digits10</span> <span class="special">=</span> <span class="number">36</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">has</span> <span class="identifier">denorm</span> <span class="special">=</span> <span class="keyword">true</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">denorm</span> <span class="identifier">min</span> <span class="special">=</span> <span class="number">6.47517511943802511092443895822764655e-4966</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">denorm_loss</span> <span class="special">=</span> <span class="keyword">false</span>
<span class="identifier">limits</span><span class="special">::</span><span class="identifier">has_signaling_NaN</span> <span class="special">==</span> <span class="keyword">false</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">quiet_NaN</span> <span class="special">=</span> <span class="identifier">nan</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">numeric_limits</span><span class="special">::&lt;&gt;</span><span class="identifier">infinity</span> <span class="special">=</span> <span class="identifier">inf</span>
</pre>
<div class="footnotes">
<br><hr style="width:100; text-align:left;margin-left: 0">
<div id="ftn.boost_multiprecision.tut.floats.float128.f0" class="footnote"><p><a href="#boost_multiprecision.tut.floats.float128.f0" class="para"><sup class="para">[3] </sup></a>
On 64-bit Ubuntu 11.10, GCC-4.8.0, Intel Core 2 Duo T5800.
</p></div>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2002-2020 John
Maddock and Christopher Kormanyos<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
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>)
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mpfr_float.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../floats.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="fp_eg.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink