generic-library/boost
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] add v1.76.0

Browse Source
This commit is contained in:
Edouard DUPIN
2021-10-05 21:37:46 +02:00
parent a97e9ae7d4
commit d0115b733d
45133 changed files with 4744437 additions and 1026325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
libs/math/doc/html/math_toolkit/powers/log1p.html
View File

@@ -1,10 +1,10 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>log1p</title>
<link rel="stylesheet" href="../../math.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="Math Toolkit 2.6.0">
<link rel="home" href="../../index.html" title="Math Toolkit 3.0.0">
<link rel="up" href="../powers.html" title="Basic Functions">
<link rel="prev" href="cos_pi.html" title="cos_pi">
<link rel="next" href="expm1.html" title="expm1">
@@ -33,13 +33,13 @@
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">log1p</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">log1p</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <a class="link" href="../../policy.html" title="Chapter 21. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&gt;</span>
<a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>calculated-result-type</em></span></a> <span class="identifier">log1p</span><span class="special">(</span><span class="identifier">T</span> <span class="identifier">x</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="../../policy.html" title="Chapter 21. Policies: Controlling Precision, Error Handling etc">Policy</a><span class="special">&amp;);</span>
<span class="special">}}</span> <span class="comment">// namespaces</span>
</pre>
<p>
Returns the natural logarithm of <code class="computeroutput"><span class="identifier">x</span><span class="special">+</span><span class="number">1</span></code>.
Returns the natural logarithm of <span class="emphasis"><em>x+1</em></span>.
</p>
<p>
The return type of this function is computed using the <a class="link" href="../result_type.html" title="Calculation of the Type of the Result"><span class="emphasis"><em>result
@@ -47,25 +47,25 @@
when <span class="emphasis"><em>x</em></span> is an integer type and T otherwise.
</p>
<p>
The final <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
The final <a class="link" href="../../policy.html" title="Chapter 21. Policies: Controlling Precision, Error Handling etc">Policy</a> argument is optional and can
be used to control the behaviour of the function: how it handles errors,
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter&#160;18.&#160;Policies: Controlling Precision, Error Handling etc">policy
what level of precision to use etc. Refer to the <a class="link" href="../../policy.html" title="Chapter 21. Policies: Controlling Precision, Error Handling etc">policy
documentation for more details</a>.
</p>
<p>
There are many situations where it is desirable to compute <code class="computeroutput"><span class="identifier">log</span><span class="special">(</span><span class="identifier">x</span><span class="special">+</span><span class="number">1</span><span class="special">)</span></code>.
However, for small <code class="computeroutput"><span class="identifier">x</span></code> then
<code class="computeroutput"><span class="identifier">x</span><span class="special">+</span><span class="number">1</span></code> suffers from catastrophic cancellation errors
so that <code class="computeroutput"><span class="identifier">x</span><span class="special">+</span><span class="number">1</span> <span class="special">==</span> <span class="number">1</span></code>
and <code class="computeroutput"><span class="identifier">log</span><span class="special">(</span><span class="identifier">x</span><span class="special">+</span><span class="number">1</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span></code>,
when in fact for very small x, the best approximation to <code class="computeroutput"><span class="identifier">log</span><span class="special">(</span><span class="identifier">x</span><span class="special">+</span><span class="number">1</span><span class="special">)</span></code> would be
<code class="computeroutput"><span class="identifier">x</span></code>. <code class="computeroutput"><span class="identifier">log1p</span></code>
calculates the best approximation to <code class="computeroutput"><span class="identifier">log</span><span class="special">(</span><span class="number">1</span><span class="special">+</span><span class="identifier">x</span><span class="special">)</span></code> using
a Taylor series expansion for accuracy (less than 2&#603;). Alternatively note that
there are faster methods available, for example using the equivalence:
However, for small <span class="emphasis"><em>x</em></span> then <span class="emphasis"><em>x+1</em></span> suffers
from catastrophic cancellation errors so that <span class="emphasis"><em>x+1 == 1</em></span>
and <span class="emphasis"><em>log(x+1) == 0</em></span>, when in fact for very small x, the
best approximation to <span class="emphasis"><em>log(x+1)</em></span> would be <span class="emphasis"><em>x</em></span>.
<code class="computeroutput"><span class="identifier">log1p</span></code> calculates the best
approximation to <code class="computeroutput"><span class="identifier">log</span><span class="special">(</span><span class="number">1</span><span class="special">+</span><span class="identifier">x</span><span class="special">)</span></code> using a Taylor series expansion for accuracy
(less than 2ɛ). Alternatively note that there are faster methods available,
for example using the equivalence:
</p>
<pre class="programlisting"><span class="identifier">log</span><span class="special">(</span><span class="number">1</span><span class="special">+</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="special">(</span><span class="identifier">log</span><span class="special">(</span><span class="number">1</span><span class="special">+</span><span class="identifier">x</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">/</span> <span class="special">((</span><span class="number">1</span><span class="special">+</span><span class="identifier">x</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span><span class="special">)</span>
</pre>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="emphasis"><em>log(1+x) == (log(1+x) * x) / ((1+x) - 1)</em></span>
</p></blockquote></div>
<p>
However, experience has shown that these methods tend to fail quite spectacularly
once the compiler's optimizations are turned on, consequently they are used
@@ -74,26 +74,28 @@
errors.
</p>
<p>
Finally when BOOST_HAS_LOG1P is defined then the <code class="computeroutput"><span class="keyword">float</span><span class="special">/</span><span class="keyword">double</span><span class="special">/</span><span class="keyword">long</span> <span class="keyword">double</span></code>
Finally when macro BOOST_HAS_LOG1P is defined then the <code class="computeroutput"><span class="keyword">float</span><span class="special">/</span><span class="keyword">double</span><span class="special">/</span><span class="keyword">long</span> <span class="keyword">double</span></code>
specializations of this template simply forward to the platform's native
(POSIX) implementation of this function.
</p>
<p>
The following graph illustrates the behaviour of log1p:
</p>
<p>
<span class="inlinemediaobject"><img src="../../../graphs/log1p.svg" align="middle"></span>
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
<span class="inlinemediaobject"><img src="../../../graphs/log1p.svg" align="middle"></span>
</p></blockquote></div>
<h5>
<a name="math_toolkit.powers.log1p.h0"></a>
<span class="phrase"><a name="math_toolkit.powers.log1p.accuracy"></a></span><a class="link" href="log1p.html#math_toolkit.powers.log1p.accuracy">Accuracy</a>
</h5>
<p>
For built in floating point types <code class="computeroutput"><span class="identifier">log1p</span></code>
should have approximately 1 epsilon accuracy.
should have approximately 1 <a href="http://en.wikipedia.org/wiki/Machine_epsilon" target="_top">machine
epsilon</a> accuracy.
</p>
<div class="table">
<a name="math_toolkit.powers.log1p.table_log1p"></a><p class="title"><b>Table&#160;6.78.&#160;Error rates for log1p</b></p>
<a name="math_toolkit.powers.log1p.table_log1p"></a><p class="title"><b>Table 8.81. Error rates for log1p</b></p>
<div class="table-contents"><table class="table" summary="Error rates for log1p">
<colgroup>
<col>
@@ -107,22 +109,22 @@
</th>
<th>
<p>
Microsoft Visual C++ version 12.0<br> Win32<br> double
GNU C++ version 7.1.0<br> linux<br> long double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> double
GNU C++ version 7.1.0<br> linux<br> double
</p>
</th>
<th>
<p>
GNU C++ version 5.1.0<br> linux<br> long double
Sun compiler version 0x5150<br> Sun Solaris<br> long double
</p>
</th>
<th>
<p>
Sun compiler version 0x5130<br> Sun Solaris<br> long double
Microsoft Visual C++ version 14.1<br> Win32<br> double
</p>
</th>
</tr></thead>
@@ -134,28 +136,27 @@
</td>
<td>
<p>
<span class="blue">Max = 0.509&#949; (Mean = 0.057&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.509&#949; (Mean = 0.057&#949;))
<span class="blue">Max = 0.818ε (Mean = 0.227ε)</span><br> <br>
(<span class="emphasis"><em>&lt;cmath&gt;:</em></span> Max = 0.818ε (Mean = 0.227ε))<br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.818ε (Mean = 0.227ε))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.846&#949; (Mean = 0.153&#949;)</span><br> <br>
(<span class="emphasis"><em>Rmath 3.0.2:</em></span> Max = 0.846&#949; (Mean = 0.153&#949;))<br>
(<span class="emphasis"><em>Cephes:</em></span> Max = 0.799&#949; (Mean = 0.122&#949;))
<span class="blue">Max = 0.846ε (Mean = 0.153ε)</span><br> <br>
(<span class="emphasis"><em>Rmath 3.2.3:</em></span> Max = 0.846ε (Mean = 0.153ε))
</p>
</td>
<td>
<p>
<span class="blue">Max = 0.818&#949; (Mean = 0.227&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;tr1/cmath&gt;:</em></span> Max = 0.818&#949; (Mean = 0.227&#949;))<br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.818&#949; (Mean = 0.227&#949;))
<span class="blue">Max = 2.3ε (Mean = 0.66ε)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.818ε (Mean = 0.249ε))
</p>
</td>
<td>
<p>
<span class="blue">Max = 1.53&#949; (Mean = 0.627&#949;)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.818&#949; (Mean = 0.249&#949;))
<span class="blue">Max = 0.509ε (Mean = 0.057ε)</span><br> <br>
(<span class="emphasis"><em>&lt;math.h&gt;:</em></span> Max = 0.509ε (Mean = 0.057ε))
</p>
</td>
</tr></tbody>
@@ -172,11 +173,11 @@
</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 &#169; 2006-2010, 2012-2014, 2017 Nikhar
Agrawal, Anton Bikineev, Paul A. Bristow, Marco Guazzone, Christopher Kormanyos,
Hubert Holin, Bruno Lalande, John Maddock, Jeremy Murphy, Johan R&#229;de, Gautam
Sewani, Benjamin Sobotta, Nicholas Thompson, Thijs van den Berg, Daryle Walker
and Xiaogang Zhang<p>
<td align="right"><div class="copyright-footer">Copyright © 2006-2021 Nikhar Agrawal, Anton Bikineev, Matthew Borland,
Paul A. Bristow, Marco Guazzone, Christopher Kormanyos, Hubert Holin, Bruno
Lalande, John Maddock, Evan Miller, Jeremy Murphy, Matthew Pulver, Johan Råde,
Gautam Sewani, Benjamin Sobotta, Nicholas Thompson, Thijs van den Berg, Daryle
Walker and Xiaogang Zhang<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>