<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Powers and logarithms — mpmath v0.17 documentation</title>
<link rel="stylesheet" href="../_static/default.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '0.17',
COLLAPSE_MODINDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<link rel="top" title="mpmath v0.17 documentation" href="../index.html" />
<link rel="up" title="Mathematical functions" href="index.html" />
<link rel="next" title="Trigonometric functions" href="trigonometric.html" />
<link rel="prev" title="Mathematical constants" href="constants.html" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../modindex.html" title="Global Module Index"
accesskey="M">modules</a> |</li>
<li class="right" >
<a href="trigonometric.html" title="Trigonometric functions"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="constants.html" title="Mathematical constants"
accesskey="P">previous</a> |</li>
<li><a href="../index.html">mpmath v0.17 documentation</a> »</li>
<li><a href="index.html" accesskey="U">Mathematical functions</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="powers-and-logarithms">
<h1>Powers and logarithms<a class="headerlink" href="#powers-and-logarithms" title="Permalink to this headline">¶</a></h1>
<div class="section" id="nth-roots">
<h2>Nth roots<a class="headerlink" href="#nth-roots" title="Permalink to this headline">¶</a></h2>
<div class="section" id="sqrt">
<h3><tt class="xref docutils literal"><span class="pre">sqrt()</span></tt><a class="headerlink" href="#sqrt" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.sqrt">
<tt class="descclassname">mpmath.</tt><tt class="descname">sqrt</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.sqrt" title="Permalink to this definition">¶</a></dt>
<dd><p><tt class="docutils literal"><span class="pre">sqrt(x)</span></tt> gives the principal square root of <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/4aa027abf288d84604eb02f64f3b9485aa648ed7.png" alt="\sqrt x"/>.
For positive real numbers, the principal root is simply the
positive square root. For arbitrary complex numbers, the principal
square root is defined to satisfy <img class="math" src="../_images/math/c029e0366a469e4e92b174d25c5c98bec0c787e6.png" alt="\sqrt x = \exp(\log(x)/2)"/>.
The function thus has a branch cut along the negative half real axis.</p>
<p>For all mpmath numbers <tt class="docutils literal"><span class="pre">x</span></tt>, calling <tt class="docutils literal"><span class="pre">sqrt(x)</span></tt> is equivalent to
performing <tt class="docutils literal"><span class="pre">x**0.5</span></tt>.</p>
<p><strong>Examples</strong></p>
<p>Basic examples and limits:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="go">3.16227766016838</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
<span class="go">10.0</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="o">-</span><span class="mi">4</span><span class="p">)</span>
<span class="go">(0.0 + 2.0j)</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="mi">1</span><span class="n">j</span><span class="p">)</span>
<span class="go">(1.09868411346781 + 0.455089860562227j)</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
</pre></div>
</div>
<p>Square root evaluation is fast at huge precision:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">50000</span>
<span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="n">sqrt</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">a</span><span class="p">)[</span><span class="o">-</span><span class="mi">10</span><span class="p">:]</span>
<span class="go">'9329332814'</span>
</pre></div>
</div>
<p><tt class="xref docutils literal"><span class="pre">mpmath.iv.sqrt()</span></tt> supports interval arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">iv</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">sqrt</span><span class="p">([</span><span class="mi">16</span><span class="p">,</span><span class="mi">100</span><span class="p">])</span>
<span class="go">[4.0, 10.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">[1.4142135623730949234, 1.4142135623730951455]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="o">**</span> <span class="mi">2</span>
<span class="go">[1.9999999999999995559, 2.0000000000000004441]</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="hypot">
<h3><tt class="xref docutils literal"><span class="pre">hypot()</span></tt><a class="headerlink" href="#hypot" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.hypot">
<tt class="descclassname">mpmath.</tt><tt class="descname">hypot</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#mpmath.hypot" title="Permalink to this definition">¶</a></dt>
<dd>Computes the Euclidean norm of the vector <img class="math" src="../_images/math/adfd9ae8a3fac031d3b8b470a52a709a23d4d6d2.png" alt="(x, y)"/>, equal
to <img class="math" src="../_images/math/c0688227c7a4c52edfc3dfbb79cf828c9e555c94.png" alt="\sqrt{x^2 + y^2}"/>. Both <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/> and <img class="math" src="../_images/math/092e364e1d9d19ad5fffb0b46ef4cc7f2da02c1c.png" alt="y"/> must be real.</dd></dl>
</div>
<div class="section" id="cbrt">
<h3><tt class="xref docutils literal"><span class="pre">cbrt()</span></tt><a class="headerlink" href="#cbrt" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.cbrt">
<tt class="descclassname">mpmath.</tt><tt class="descname">cbrt</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.cbrt" title="Permalink to this definition">¶</a></dt>
<dd><p><tt class="docutils literal"><span class="pre">cbrt(x)</span></tt> computes the cube root of <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/211fe368f21e7e87a497012b64962b2dae135c3d.png" alt="x^{1/3}"/>. This
function is faster and more accurate than raising to a floating-point
fraction:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="mi">125</span><span class="o">**</span><span class="p">(</span><span class="n">mpf</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="mi">3</span><span class="p">)</span>
<span class="go">mpf('4.9999999999999991')</span>
<span class="gp">>>> </span><span class="n">cbrt</span><span class="p">(</span><span class="mi">125</span><span class="p">)</span>
<span class="go">mpf('5.0')</span>
</pre></div>
</div>
<p>Every nonzero complex number has three cube roots. This function
returns the cube root defined by <img class="math" src="../_images/math/595023734d9ab251444ec4facc4d0b56b2d169cd.png" alt="\exp(\log(x)/3)"/> where the
principal branch of the natural logarithm is used. Note that this
does not give a real cube root for negative real numbers:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">cbrt</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(0.5 + 0.866025403784439j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="root">
<h3><tt class="xref docutils literal"><span class="pre">root()</span></tt><a class="headerlink" href="#root" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.root">
<tt class="descclassname">mpmath.</tt><tt class="descname">root</tt><big>(</big><em>z</em>, <em>n</em>, <em>k=0</em><big>)</big><a class="headerlink" href="#mpmath.root" title="Permalink to this definition">¶</a></dt>
<dd><p><tt class="docutils literal"><span class="pre">root(z,</span> <span class="pre">n,</span> <span class="pre">k=0)</span></tt> computes an <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th root of <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>, i.e. returns a number
<img class="math" src="../_images/math/b55ca7a0aa88ab7d58f4fc035317fdac39b17861.png" alt="r"/> that (up to possible approximation error) satisfies <img class="math" src="../_images/math/ac3a0ed7ca9c9e1363980137c533255ac92010c0.png" alt="r^n = z"/>.
(<tt class="docutils literal"><span class="pre">nthroot</span></tt> is available as an alias for <tt class="docutils literal"><span class="pre">root</span></tt>.)</p>
<p>Every complex number <img class="math" src="../_images/math/769d369d053ebcc9421b5bc1d3b913b62c888d8f.png" alt="z \ne 0"/> has <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> distinct <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th roots, which are
equidistant points on a circle with radius <img class="math" src="../_images/math/57cd260d3d04c5a65468c97f968157fe6031b424.png" alt="|z|^{1/n}"/>, centered around the
origin. A specific root may be selected using the optional index
<img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/>. The roots are indexed counterclockwise, starting with <img class="math" src="../_images/math/84574de7797bc7b4e1fc52075f4d265ba60a8bce.png" alt="k = 0"/> for the root
closest to the positive real half-axis.</p>
<p>The <img class="math" src="../_images/math/84574de7797bc7b4e1fc52075f4d265ba60a8bce.png" alt="k = 0"/> root is the so-called principal <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th root, often denoted by
<img class="math" src="../_images/math/f8a433ff3bb0e1b43756c3395a450502a96febe5.png" alt="\sqrt[n]{z}"/> or <img class="math" src="../_images/math/a4950085ba0899ed17232f4e90bd570683b24d85.png" alt="z^{1/n}"/>, and also given by <img class="math" src="../_images/math/a2fe9a87acce2d91350c36915cfdfd1a20b89de4.png" alt="\exp(\log(z) / n)"/>. If <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/> is
a positive real number, the principal root is just the unique positive
<img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th root of <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>. Under some circumstances, non-principal real roots exist:
for positive real <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>, <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> even, there is a negative root given by <img class="math" src="../_images/math/540a8f47dc506fc392b4f0fbda5316b193ec69cf.png" alt="k = n/2"/>;
for negative real <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>, <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> odd, there is a negative root given by <img class="math" src="../_images/math/43d87ab49c47eca6554d5abfb95263bd23f356f4.png" alt="k = (n-1)/2"/>.</p>
<p>To obtain all roots with a simple expression, use
<tt class="docutils literal"><span class="pre">[root(z,n,k)</span> <span class="pre">for</span> <span class="pre">k</span> <span class="pre">in</span> <span class="pre">range(n)]</span></tt>.</p>
<p>An important special case, <tt class="docutils literal"><span class="pre">root(1,</span> <span class="pre">n,</span> <span class="pre">k)</span></tt> returns the <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/>-th <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th root of
unity, <img class="math" src="../_images/math/c27faf6fb766cc1cf901c46f2ca93b8a034e3d80.png" alt="\zeta_k = e^{2 \pi i k / n}"/>. Alternatively, <a title="mpmath.unitroots" class="reference internal" href="#mpmath.unitroots"><tt class="xref docutils literal"><span class="pre">unitroots()</span></tt></a>
provides a slightly more convenient way to obtain the roots of unity,
including the option to compute only the primitive roots of unity.</p>
<p>Both <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/> and <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> should be integers; <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/> outside of <tt class="docutils literal"><span class="pre">range(n)</span></tt> will be
reduced modulo <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>. If <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> is negative, <img class="math" src="../_images/math/2e1e41e1075edaa5c4b4f7a3713596edb708b29d.png" alt="x^{-1/n} = 1/x^{1/n}"/> (or
the equivalent reciprocal for a non-principal root with <img class="math" src="../_images/math/7433902f1c6bf3e4c381454a4202825ce425f0e0.png" alt="k \ne 0"/>) is computed.</p>
<p><a title="mpmath.root" class="reference internal" href="#mpmath.root"><tt class="xref docutils literal"><span class="pre">root()</span></tt></a> is implemented to use Newton’s method for small
<img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>. At high precision, this makes <img class="math" src="../_images/math/150f22361f31a17a5319a3984b1708b9978fec12.png" alt="x^{1/n}"/> not much more
expensive than the regular exponentiation, <img class="math" src="../_images/math/8c72f3acf1f7744cfe76edaf47e45d62432cf28b.png" alt="x^n"/>. For very large
<img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>, <tt class="xref docutils literal"><span class="pre">nthroot()</span></tt> falls back to use the exponential function.</p>
<p><strong>Examples</strong></p>
<p><tt class="xref docutils literal"><span class="pre">nthroot()</span></tt>/<a title="mpmath.root" class="reference internal" href="#mpmath.root"><tt class="xref docutils literal"><span class="pre">root()</span></tt></a> is faster and more accurate than raising to a
floating-point fraction:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="mi">16807</span> <span class="o">**</span> <span class="p">(</span><span class="n">mpf</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="mi">5</span><span class="p">)</span>
<span class="go">mpf('7.0000000000000009')</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="mi">16807</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="go">mpf('7.0')</span>
<span class="gp">>>> </span><span class="n">nthroot</span><span class="p">(</span><span class="mi">16807</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span> <span class="c"># Alias</span>
<span class="go">mpf('7.0')</span>
</pre></div>
</div>
<p>A high-precision root:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">50</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">nthroot</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="go">1.584893192461113485202101373391507013269442133825</span>
<span class="gp">>>> </span><span class="n">nthroot</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span> <span class="o">**</span> <span class="mi">5</span>
<span class="go">10.0</span>
</pre></div>
</div>
<p>Computing principal and non-principal square and cube roots:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">3.16227766016838</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">-3.16227766016838</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">(1.07721734501594 + 1.86579517236206j)</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">-2.15443469003188</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">(1.07721734501594 - 1.86579517236206j)</span>
</pre></div>
</div>
<p>All the 7th roots of a complex number:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="p">[</span><span class="n">root</span><span class="p">(</span><span class="mi">3</span><span class="o">+</span><span class="mi">4</span><span class="n">j</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="n">k</span><span class="p">)</span> <span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">7</span><span class="p">)]:</span>
<span class="gp">... </span> <span class="k">print</span><span class="p">(</span><span class="s">"</span><span class="si">%s</span><span class="s"> </span><span class="si">%s</span><span class="s">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">r</span><span class="p">,</span> <span class="n">r</span><span class="o">**</span><span class="mi">7</span><span class="p">))</span>
<span class="gp">...</span>
<span class="go">(1.24747270589553 + 0.166227124177353j) (3.0 + 4.0j)</span>
<span class="go">(0.647824911301003 + 1.07895435170559j) (3.0 + 4.0j)</span>
<span class="go">(-0.439648254723098 + 1.17920694574172j) (3.0 + 4.0j)</span>
<span class="go">(-1.19605731775069 + 0.391492658196305j) (3.0 + 4.0j)</span>
<span class="go">(-1.05181082538903 - 0.691023585965793j) (3.0 + 4.0j)</span>
<span class="go">(-0.115529328478668 - 1.25318497558335j) (3.0 + 4.0j)</span>
<span class="go">(0.907748109144957 - 0.871672518271819j) (3.0 + 4.0j)</span>
</pre></div>
</div>
<p>Cube roots of unity:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">3</span><span class="p">):</span> <span class="k">print</span><span class="p">(</span><span class="n">root</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="n">k</span><span class="p">))</span>
<span class="gp">...</span>
<span class="go">1.0</span>
<span class="go">(-0.5 + 0.866025403784439j)</span>
<span class="go">(-0.5 - 0.866025403784439j)</span>
</pre></div>
</div>
<p>Some exact high order roots:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="mi">75</span><span class="o">**</span><span class="mi">210</span><span class="p">,</span> <span class="mi">105</span><span class="p">)</span>
<span class="go">5625.0</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span> <span class="mi">96</span><span class="p">)</span>
<span class="go">(0.0 - 1.0j)</span>
<span class="gp">>>> </span><span class="n">root</span><span class="p">(</span><span class="mi">4</span><span class="o">**</span><span class="mi">128</span><span class="p">,</span> <span class="mi">128</span><span class="p">,</span> <span class="mi">96</span><span class="p">)</span>
<span class="go">(0.0 - 4.0j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="unitroots">
<h3><tt class="xref docutils literal"><span class="pre">unitroots()</span></tt><a class="headerlink" href="#unitroots" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.unitroots">
<tt class="descclassname">mpmath.</tt><tt class="descname">unitroots</tt><big>(</big><em>n</em>, <em>primitive=False</em><big>)</big><a class="headerlink" href="#mpmath.unitroots" title="Permalink to this definition">¶</a></dt>
<dd><p><tt class="docutils literal"><span class="pre">unitroots(n)</span></tt> returns <img class="math" src="../_images/math/c9c73956dcc128dec9b2f2c357b09b82c863302f.png" alt="\zeta_0, \zeta_1, \ldots, \zeta_{n-1}"/>,
all the distinct <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th roots of unity, as a list. If the option
<em>primitive=True</em> is passed, only the primitive roots are returned.</p>
<p>Every <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th root of unity satisfies <img class="math" src="../_images/math/0cedb41f560e6168c13dbc132566bc2c9079c46c.png" alt="(\zeta_k)^n = 1"/>. There are <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> distinct
roots for each <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> (<img class="math" src="../_images/math/62bcc94096039059cc863669926ee8bc0ea5e6f4.png" alt="\zeta_k"/> and <img class="math" src="../_images/math/e98169ad5f7dd9742ab178db052d17ed4e2af60b.png" alt="\zeta_j"/> are the same when
<img class="math" src="../_images/math/5d3c70c80f9f983985bf4720ccf4220fb571c714.png" alt="k = j \pmod n"/>), which form a regular polygon with vertices on the unit
circle. They are ordered counterclockwise with increasing <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/>, starting
with <img class="math" src="../_images/math/d3549fbbb212be66a763533518cfe04c5a860e48.png" alt="\zeta_0 = 1"/>.</p>
<p><strong>Examples</strong></p>
<p>The roots of unity up to <img class="math" src="../_images/math/5218af40079081e694d8b82eeac2d368ef6ea76a.png" alt="n = 4"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span>
<span class="go">[1.0]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span>
<span class="go">[1.0, -1.0]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>
<span class="go">[1.0, (-0.5 + 0.866025j), (-0.5 - 0.866025j)]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">4</span><span class="p">))</span>
<span class="go">[1.0, (0.0 + 1.0j), -1.0, (0.0 - 1.0j)]</span>
</pre></div>
</div>
<p>Roots of unity form a geometric series that sums to 0:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">50</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">fsum</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">25</span><span class="p">)))</span>
<span class="go">0.0</span>
</pre></div>
</div>
<p>Primitive roots up to <img class="math" src="../_images/math/5218af40079081e694d8b82eeac2d368ef6ea76a.png" alt="n = 4"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
<span class="go">[1.0]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
<span class="go">[-1.0]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
<span class="go">[(-0.5 + 0.866025j), (-0.5 - 0.866025j)]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
<span class="go">[(0.0 + 1.0j), (0.0 - 1.0j)]</span>
</pre></div>
</div>
<p>There are only four primitive 12th roots:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="mi">12</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span>
<span class="go">[(0.866025 + 0.5j), (-0.866025 + 0.5j), (-0.866025 - 0.5j), (0.866025 - 0.5j)]</span>
</pre></div>
</div>
<p>The <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th roots of unity form a group, the cyclic group of order <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>.
Any primitive root <img class="math" src="../_images/math/b55ca7a0aa88ab7d58f4fc035317fdac39b17861.png" alt="r"/> is a generator for this group, meaning that
<img class="math" src="../_images/math/b1daa4d2f67830bf961a8da3d1040af8cd33d84a.png" alt="r^0, r^1, \ldots, r^{n-1}"/> gives the whole set of unit roots (in
some permuted order):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">for</span> <span class="n">r</span> <span class="ow">in</span> <span class="n">unitroots</span><span class="p">(</span><span class="mi">6</span><span class="p">):</span> <span class="k">print</span><span class="p">(</span><span class="n">r</span><span class="p">)</span>
<span class="gp">...</span>
<span class="go">1.0</span>
<span class="go">(0.5 + 0.866025403784439j)</span>
<span class="go">(-0.5 + 0.866025403784439j)</span>
<span class="go">-1.0</span>
<span class="go">(-0.5 - 0.866025403784439j)</span>
<span class="go">(0.5 - 0.866025403784439j)</span>
<span class="gp">>>> </span><span class="n">r</span> <span class="o">=</span> <span class="n">unitroots</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">)[</span><span class="mi">1</span><span class="p">]</span>
<span class="gp">>>> </span><span class="k">for</span> <span class="n">k</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">6</span><span class="p">):</span> <span class="k">print</span><span class="p">(</span><span class="n">chop</span><span class="p">(</span><span class="n">r</span><span class="o">**</span><span class="n">k</span><span class="p">))</span>
<span class="gp">...</span>
<span class="go">1.0</span>
<span class="go">(0.5 - 0.866025403784439j)</span>
<span class="go">(-0.5 - 0.866025403784439j)</span>
<span class="go">-1.0</span>
<span class="go">(-0.5 + 0.866025403784438j)</span>
<span class="go">(0.5 + 0.866025403784438j)</span>
</pre></div>
</div>
<p>The number of primitive roots equals the Euler totient function <img class="math" src="../_images/math/edae70ddedf89e790936ed4035c5ca1480212e0f.png" alt="\phi(n)"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">unitroots</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">primitive</span><span class="o">=</span><span class="bp">True</span><span class="p">))</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">20</span><span class="p">)]</span>
<span class="go">[1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16, 6, 18]</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="exponentiation">
<h2>Exponentiation<a class="headerlink" href="#exponentiation" title="Permalink to this headline">¶</a></h2>
<div class="section" id="exp">
<h3><tt class="xref docutils literal"><span class="pre">exp()</span></tt><a class="headerlink" href="#exp" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.exp">
<tt class="descclassname">mpmath.</tt><tt class="descname">exp</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.exp" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the exponential function,</p>
<div class="math">
<p><img src="../_images/math/191e3b6500085050523a95232a0c311379947732.png" alt="\exp(x) = e^x = \sum_{k=0}^{\infty} \frac{x^k}{k!}." /></p>
</div><p>For complex numbers, the exponential function also satisfies</p>
<div class="math">
<p><img src="../_images/math/82ed5034ab40005bac4264139bc4e1987874dfcf.png" alt="\exp(x+yi) = e^x (\cos y + i \sin y)." /></p>
</div><p><strong>Basic examples</strong></p>
<p>Some values of the exponential function:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">1.0</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">2.718281828459045235360287</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">0.3678794411714423215955238</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">inf</span><span class="p">)</span>
<span class="go">0.0</span>
</pre></div>
</div>
<p>Arguments can be arbitrarily large:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="mi">10000</span><span class="p">)</span>
<span class="go">8.806818225662921587261496e+4342</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="mi">10000</span><span class="p">)</span>
<span class="go">1.135483865314736098540939e-4343</span>
</pre></div>
</div>
<p>Evaluation is supported for interval arguments via
<tt class="xref docutils literal"><span class="pre">mpmath.iv.exp()</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span><span class="p">;</span> <span class="n">iv</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">([</span><span class="o">-</span><span class="n">inf</span><span class="p">,</span><span class="mi">0</span><span class="p">])</span>
<span class="go">[0.0, 1.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">])</span>
<span class="go">[1.0, 2.71828182845904523536028749558]</span>
</pre></div>
</div>
<p>The exponential function can be evaluated efficiently to arbitrary
precision:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">10000</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span> <span class="c">#doctest: +ELLIPSIS</span>
<span class="go">23.140692632779269005729...8984304016040616</span>
</pre></div>
</div>
<p><strong>Functional properties</strong></p>
<p>Numerical verification of Euler’s identity for the complex
exponential function:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="n">j</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span>
<span class="go">(0.0 + 1.22464679914735e-16j)</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">exp</span><span class="p">(</span><span class="n">j</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
<span class="go">0.0</span>
</pre></div>
</div>
<p>This recovers the coefficients (reciprocal factorials) in the
Maclaurin series expansion of exp:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">taylor</span><span class="p">(</span><span class="n">exp</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">))</span>
<span class="go">[1.0, 1.0, 0.5, 0.166667, 0.0416667, 0.00833333]</span>
</pre></div>
</div>
<p>The exponential function is its own derivative and antiderivative:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">23.1406926327793</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">exp</span><span class="p">,</span> <span class="n">pi</span><span class="p">)</span>
<span class="go">23.1406926327793</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="n">exp</span><span class="p">,</span> <span class="p">[</span><span class="o">-</span><span class="n">inf</span><span class="p">,</span> <span class="n">pi</span><span class="p">])</span>
<span class="go">23.1406926327793</span>
</pre></div>
</div>
<p>The exponential function can be evaluated using various methods,
including direct summation of the series, limits, and solving
the defining differential equation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nsum</span><span class="p">(</span><span class="k">lambda</span> <span class="n">k</span><span class="p">:</span> <span class="n">pi</span><span class="o">**</span><span class="n">k</span><span class="o">/</span><span class="n">fac</span><span class="p">(</span><span class="n">k</span><span class="p">),</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="n">inf</span><span class="p">])</span>
<span class="go">23.1406926327793</span>
<span class="gp">>>> </span><span class="n">limit</span><span class="p">(</span><span class="k">lambda</span> <span class="n">k</span><span class="p">:</span> <span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="n">pi</span><span class="o">/</span><span class="n">k</span><span class="p">)</span><span class="o">**</span><span class="n">k</span><span class="p">,</span> <span class="n">inf</span><span class="p">)</span>
<span class="go">23.1406926327793</span>
<span class="gp">>>> </span><span class="n">odefun</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">,</span> <span class="n">x</span><span class="p">:</span> <span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">23.1406926327793</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="power">
<h3><tt class="xref docutils literal"><span class="pre">power()</span></tt><a class="headerlink" href="#power" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.power">
<tt class="descclassname">mpmath.</tt><tt class="descname">power</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#mpmath.power" title="Permalink to this definition">¶</a></dt>
<dd><p>Converts <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/> and <img class="math" src="../_images/math/092e364e1d9d19ad5fffb0b46ef4cc7f2da02c1c.png" alt="y"/> to mpmath numbers and evaluates
<img class="math" src="../_images/math/4c4a6df8d2bc2bfb583c11bc20504938026f6aa8.png" alt="x^y = \exp(y \log(x))"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">30</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">power</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">)</span>
<span class="go">1.41421356237309504880168872421</span>
</pre></div>
</div>
<p>This shows the leading few digits of a large Mersenne prime
(performing the exact calculation <tt class="docutils literal"><span class="pre">2**43112609-1</span></tt> and
displaying the result in Python would be very slow):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">power</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">43112609</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span>
<span class="go">3.16470269330255923143453723949e+12978188</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="expj">
<h3><tt class="xref docutils literal"><span class="pre">expj()</span></tt><a class="headerlink" href="#expj" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.expj">
<tt class="descclassname">mpmath.</tt><tt class="descname">expj</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.expj" title="Permalink to this definition">¶</a></dt>
<dd><p>Convenience function for computing <img class="math" src="../_images/math/3a05bb2d3214a6f7d27a70c01fb6cb2dbae72138.png" alt="e^{ix}"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">expj</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">(1.0 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">expj</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(0.5403023058681397174009366 - 0.8414709848078965066525023j)</span>
<span class="gp">>>> </span><span class="n">expj</span><span class="p">(</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.3678794411714423215955238 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">expj</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.1987661103464129406288032 + 0.3095598756531121984439128j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="expjpi">
<h3><tt class="xref docutils literal"><span class="pre">expjpi()</span></tt><a class="headerlink" href="#expjpi" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.expjpi">
<tt class="descclassname">mpmath.</tt><tt class="descname">expjpi</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.expjpi" title="Permalink to this definition">¶</a></dt>
<dd><p>Convenience function for computing <img class="math" src="../_images/math/81839687cfd9f7e622b9eae993a6f0fe99669969.png" alt="e^{i \pi x}"/>.
Evaluation is accurate near zeros (see also <a title="mpmath.cospi" class="reference external" href="trigonometric.html#mpmath.cospi"><tt class="xref docutils literal"><span class="pre">cospi()</span></tt></a>,
<a title="mpmath.sinpi" class="reference external" href="trigonometric.html#mpmath.sinpi"><tt class="xref docutils literal"><span class="pre">sinpi()</span></tt></a>):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">expjpi</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">(1.0 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">expjpi</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(-1.0 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">expjpi</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">(0.0 + 1.0j)</span>
<span class="gp">>>> </span><span class="n">expjpi</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(-1.0 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">expjpi</span><span class="p">(</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.04321391826377224977441774 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">expjpi</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="n">j</span><span class="p">)</span>
<span class="go">(-0.04321391826377224977441774 + 0.0j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="expm1">
<h3><tt class="xref docutils literal"><span class="pre">expm1()</span></tt><a class="headerlink" href="#expm1" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.expm1">
<tt class="descclassname">mpmath.</tt><tt class="descname">expm1</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#mpmath.expm1" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <img class="math" src="../_images/math/098c246388f0885ccaf6d2f885703c34f4da2470.png" alt="e^x - 1"/>, accurately for small <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>.</p>
<p>Unlike the expression <tt class="docutils literal"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></tt>, <tt class="docutils literal"><span class="pre">expm1(x)</span></tt> does not suffer from
potentially catastrophic cancellation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="mf">1e-10</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="k">print</span><span class="p">(</span><span class="n">expm1</span><span class="p">(</span><span class="mf">1e-10</span><span class="p">))</span>
<span class="go">1.00000008274037e-10</span>
<span class="go">1.00000000005e-10</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="mf">1e-20</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">;</span> <span class="k">print</span><span class="p">(</span><span class="n">expm1</span><span class="p">(</span><span class="mf">1e-20</span><span class="p">))</span>
<span class="go">0.0</span>
<span class="go">1.0e-20</span>
<span class="gp">>>> </span><span class="mi">1</span><span class="o">/</span><span class="p">(</span><span class="n">exp</span><span class="p">(</span><span class="mf">1e-20</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">ZeroDivisionError</span>
<span class="gp">>>> </span><span class="mi">1</span><span class="o">/</span><span class="n">expm1</span><span class="p">(</span><span class="mf">1e-20</span><span class="p">)</span>
<span class="go">1.0e+20</span>
</pre></div>
</div>
<p>Evaluation works for extremely tiny values:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">expm1</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">expm1</span><span class="p">(</span><span class="s">'1e-10000000'</span><span class="p">)</span>
<span class="go">1.0e-10000000</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="powm1">
<h3><tt class="xref docutils literal"><span class="pre">powm1()</span></tt><a class="headerlink" href="#powm1" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.powm1">
<tt class="descclassname">mpmath.</tt><tt class="descname">powm1</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#mpmath.powm1" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <img class="math" src="../_images/math/af550b5f60ea00e76399ea6c6d0adbede50b1ef7.png" alt="x^y - 1"/>, accurately when <img class="math" src="../_images/math/8f9af910fe749481919573c0dd2b132118f19d19.png" alt="x^y"/> is very close to 1.</p>
<p>This avoids potentially catastrophic cancellation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">power</span><span class="p">(</span><span class="mf">0.99999995</span><span class="p">,</span> <span class="mf">1e-10</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">powm1</span><span class="p">(</span><span class="mf">0.99999995</span><span class="p">,</span> <span class="mf">1e-10</span><span class="p">)</span>
<span class="go">-5.00000012791934e-18</span>
</pre></div>
</div>
<p>Powers exactly equal to 1, and only those powers, yield 0 exactly:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">powm1</span><span class="p">(</span><span class="o">-</span><span class="n">j</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">(0.0 + 0.0j)</span>
<span class="gp">>>> </span><span class="n">powm1</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">powm1</span><span class="p">(</span><span class="n">fadd</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mf">1e-100</span><span class="p">,</span> <span class="n">exact</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">-4.0e-100</span>
</pre></div>
</div>
<p>Evaluation works for extremely tiny <img class="math" src="../_images/math/092e364e1d9d19ad5fffb0b46ef4cc7f2da02c1c.png" alt="y"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">powm1</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="s">'1e-100000'</span><span class="p">)</span>
<span class="go">6.93147180559945e-100001</span>
<span class="gp">>>> </span><span class="n">powm1</span><span class="p">(</span><span class="n">j</span><span class="p">,</span> <span class="s">'1e-1000'</span><span class="p">)</span>
<span class="go">(-1.23370055013617e-2000 + 1.5707963267949e-1000j)</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="logarithms">
<h2>Logarithms<a class="headerlink" href="#logarithms" title="Permalink to this headline">¶</a></h2>
<div class="section" id="log">
<h3><tt class="xref docutils literal"><span class="pre">log()</span></tt><a class="headerlink" href="#log" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.log">
<tt class="descclassname">mpmath.</tt><tt class="descname">log</tt><big>(</big><em>x</em>, <em>b=None</em><big>)</big><a class="headerlink" href="#mpmath.log" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the base-<img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> logarithm of <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/7d77c6dd8aa838083121ba5452c6a3d65b9388ae.png" alt="\log_b(x)"/>. If <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> is
unspecified, <a title="mpmath.log" class="reference internal" href="#mpmath.log"><tt class="xref docutils literal"><span class="pre">log()</span></tt></a> computes the natural (base <img class="math" src="../_images/math/a3a59bb1293ee3f6dec19de4019a7178874219ae.png" alt="e"/>) logarithm
and is equivalent to <a title="mpmath.ln" class="reference internal" href="#mpmath.ln"><tt class="xref docutils literal"><span class="pre">ln()</span></tt></a>. In general, the base <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> logarithm
is defined in terms of the natural logarithm as
<img class="math" src="../_images/math/15cd1efc4e2252c7a722d2a13386b43ce6ecfa10.png" alt="\log_b(x) = \ln(x)/\ln(b)"/>.</p>
<p>By convention, we take <img class="math" src="../_images/math/831e4536400418726f42c728d469c9ac9457c65e.png" alt="\log(0) = -\infty"/>.</p>
<p>The natural logarithm is real if <img class="math" src="../_images/math/cae4fd68f44ac9b909f8d91f9d498de5759bb45b.png" alt="x > 0"/> and complex if <img class="math" src="../_images/math/36a68e8aa6ec6f48231ad80a4851f84bacf641b3.png" alt="x < 0"/> or if
<img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/> is complex. The principal branch of the complex logarithm is
used, meaning that <img class="math" src="../_images/math/e56f17c32f52ac3c0c98c0a4ac5a4efbd4087987.png" alt="\Im(\ln(x)) = -\pi < \arg(x) \le \pi"/>.</p>
<p><strong>Examples</strong></p>
<p>Some basic values and limits:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">0.693147180559945</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">1000</span><span class="p">,</span><span class="mi">10</span><span class="p">)</span>
<span class="go">3.0</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">16</span><span class="p">)</span>
<span class="go">0.5</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.0 + 1.5707963267949j)</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(0.0 + 3.14159265358979j)</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">-inf</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
</pre></div>
</div>
<p>The natural logarithm is the antiderivative of <img class="math" src="../_images/math/d172d3d8333a9c1740b123ea13d5b44f22446869.png" alt="1/x"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="mi">1</span><span class="o">/</span><span class="n">x</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">5</span><span class="p">])</span>
<span class="go">1.6094379124341</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">1.6094379124341</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">log</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
<span class="go">0.1</span>
</pre></div>
</div>
<p>The Taylor series expansion of the natural logarithm around
<img class="math" src="../_images/math/34310f2f36ed6d724838edb08788ee62acb33386.png" alt="x = 1"/> has coefficients <img class="math" src="../_images/math/b8d4b1feff73224a9c61996d83573e0fdc6ab673.png" alt="(-1)^{n+1}/n"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">taylor</span><span class="p">(</span><span class="n">log</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">7</span><span class="p">))</span>
<span class="go">[0.0, 1.0, -0.5, 0.333333, -0.25, 0.2, -0.166667, 0.142857]</span>
</pre></div>
</div>
<p><a title="mpmath.log" class="reference internal" href="#mpmath.log"><tt class="xref docutils literal"><span class="pre">log()</span></tt></a> supports arbitrary precision evaluation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">50</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">1.1447298858494001741434273513530587116472948129153</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">pi</span><span class="p">,</span> <span class="n">pi</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span>
<span class="go">0.33333333333333333333333333333333333333333333333333</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">3</span><span class="o">+</span><span class="mi">4</span><span class="n">j</span><span class="p">)</span>
<span class="go">(1.609437912434100374600759 + 0.9272952180016122324285125j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="ln">
<h3><tt class="xref docutils literal"><span class="pre">ln()</span></tt><a class="headerlink" href="#ln" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.ln">
<tt class="descclassname">mpmath.</tt><tt class="descname">ln</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.ln" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the base-<img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> logarithm of <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/7d77c6dd8aa838083121ba5452c6a3d65b9388ae.png" alt="\log_b(x)"/>. If <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> is
unspecified, <a title="mpmath.log" class="reference internal" href="#mpmath.log"><tt class="xref docutils literal"><span class="pre">log()</span></tt></a> computes the natural (base <img class="math" src="../_images/math/a3a59bb1293ee3f6dec19de4019a7178874219ae.png" alt="e"/>) logarithm
and is equivalent to <a title="mpmath.ln" class="reference internal" href="#mpmath.ln"><tt class="xref docutils literal"><span class="pre">ln()</span></tt></a>. In general, the base <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> logarithm
is defined in terms of the natural logarithm as
<img class="math" src="../_images/math/15cd1efc4e2252c7a722d2a13386b43ce6ecfa10.png" alt="\log_b(x) = \ln(x)/\ln(b)"/>.</p>
<p>By convention, we take <img class="math" src="../_images/math/831e4536400418726f42c728d469c9ac9457c65e.png" alt="\log(0) = -\infty"/>.</p>
<p>The natural logarithm is real if <img class="math" src="../_images/math/cae4fd68f44ac9b909f8d91f9d498de5759bb45b.png" alt="x > 0"/> and complex if <img class="math" src="../_images/math/36a68e8aa6ec6f48231ad80a4851f84bacf641b3.png" alt="x < 0"/> or if
<img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/> is complex. The principal branch of the complex logarithm is
used, meaning that <img class="math" src="../_images/math/e56f17c32f52ac3c0c98c0a4ac5a4efbd4087987.png" alt="\Im(\ln(x)) = -\pi < \arg(x) \le \pi"/>.</p>
<p><strong>Examples</strong></p>
<p>Some basic values and limits:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">0.693147180559945</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">1000</span><span class="p">,</span><span class="mi">10</span><span class="p">)</span>
<span class="go">3.0</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">16</span><span class="p">)</span>
<span class="go">0.5</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.0 + 1.5707963267949j)</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(0.0 + 3.14159265358979j)</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">-inf</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
</pre></div>
</div>
<p>The natural logarithm is the antiderivative of <img class="math" src="../_images/math/d172d3d8333a9c1740b123ea13d5b44f22446869.png" alt="1/x"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="mi">1</span><span class="o">/</span><span class="n">x</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">5</span><span class="p">])</span>
<span class="go">1.6094379124341</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">1.6094379124341</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">log</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
<span class="go">0.1</span>
</pre></div>
</div>
<p>The Taylor series expansion of the natural logarithm around
<img class="math" src="../_images/math/34310f2f36ed6d724838edb08788ee62acb33386.png" alt="x = 1"/> has coefficients <img class="math" src="../_images/math/b8d4b1feff73224a9c61996d83573e0fdc6ab673.png" alt="(-1)^{n+1}/n"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">taylor</span><span class="p">(</span><span class="n">log</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">7</span><span class="p">))</span>
<span class="go">[0.0, 1.0, -0.5, 0.333333, -0.25, 0.2, -0.166667, 0.142857]</span>
</pre></div>
</div>
<p><a title="mpmath.log" class="reference internal" href="#mpmath.log"><tt class="xref docutils literal"><span class="pre">log()</span></tt></a> supports arbitrary precision evaluation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">50</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">1.1447298858494001741434273513530587116472948129153</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">pi</span><span class="p">,</span> <span class="n">pi</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span>
<span class="go">0.33333333333333333333333333333333333333333333333333</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="mi">3</span><span class="o">+</span><span class="mi">4</span><span class="n">j</span><span class="p">)</span>
<span class="go">(1.609437912434100374600759 + 0.9272952180016122324285125j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="log10">
<h3><tt class="xref docutils literal"><span class="pre">log10()</span></tt><a class="headerlink" href="#log10" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.log10">
<tt class="descclassname">mpmath.</tt><tt class="descname">log10</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#mpmath.log10" title="Permalink to this definition">¶</a></dt>
<dd>Computes the base-10 logarithm of <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/c179b3d2cf0aedab4cf71b933222a1ad8ae14ad4.png" alt="\log_{10}(x)"/>. <tt class="docutils literal"><span class="pre">log10(x)</span></tt>
is equivalent to <tt class="docutils literal"><span class="pre">log(x,</span> <span class="pre">10)</span></tt>.</dd></dl>
</div>
</div>
<div class="section" id="lambert-w-function">
<h2>Lambert W function<a class="headerlink" href="#lambert-w-function" title="Permalink to this headline">¶</a></h2>
<div class="section" id="lambertw">
<h3><tt class="xref docutils literal"><span class="pre">lambertw()</span></tt><a class="headerlink" href="#lambertw" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.lambertw">
<tt class="descclassname">mpmath.</tt><tt class="descname">lambertw</tt><big>(</big><em>z</em>, <em>k=0</em><big>)</big><a class="headerlink" href="#mpmath.lambertw" title="Permalink to this definition">¶</a></dt>
<dd><p>The Lambert W function <img class="math" src="../_images/math/d9f092163480eadf6f5084b9223116e5ee02f709.png" alt="W(z)"/> is defined as the inverse function
of <img class="math" src="../_images/math/4f14b8f56034ac47a737c7a68d61849c9468570f.png" alt="w \exp(w)"/>. In other words, the value of <img class="math" src="../_images/math/d9f092163480eadf6f5084b9223116e5ee02f709.png" alt="W(z)"/> is such that
<img class="math" src="../_images/math/453b5e9b62a3f5ffa964b35fe3d393cfcd78c6c0.png" alt="z = W(z) \exp(W(z))"/> for any complex number <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>.</p>
<p>The Lambert W function is a multivalued function with infinitely
many branches <img class="math" src="../_images/math/578e4ec96360467f116bebdd930be0937ebb8ce4.png" alt="W_k(z)"/>, indexed by <img class="math" src="../_images/math/29238f408d8cb5806f06cc03446dde0084ffe09d.png" alt="k \in \mathbb{Z}"/>. Each branch
gives a different solution <img class="math" src="../_images/math/9ee4b825a2e36ae093ed7be5e4851ef453b34914.png" alt="w"/> of the equation <img class="math" src="../_images/math/1f1003d7c208af706b64150dfa07610b53e0e40d.png" alt="z = w \exp(w)"/>.
All branches are supported by <a title="mpmath.lambertw" class="reference internal" href="#mpmath.lambertw"><tt class="xref docutils literal"><span class="pre">lambertw()</span></tt></a>:</p>
<ul class="simple">
<li><tt class="docutils literal"><span class="pre">lambertw(z)</span></tt> gives the principal solution (branch 0)</li>
<li><tt class="docutils literal"><span class="pre">lambertw(z,</span> <span class="pre">k)</span></tt> gives the solution on branch <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/></li>
</ul>
<p>The Lambert W function has two partially real branches: the
principal branch (<img class="math" src="../_images/math/84574de7797bc7b4e1fc52075f4d265ba60a8bce.png" alt="k = 0"/>) is real for real <img class="math" src="../_images/math/371d182c625a220a79513c1dcaef4adba922738f.png" alt="z > -1/e"/>, and the
<img class="math" src="../_images/math/a82f7b76d2e16054f75df1ea45cb2a043f09ffad.png" alt="k = -1"/> branch is real for <img class="math" src="../_images/math/638a0971d2f3dc23d1dcb42c54cfa5b3daa4376c.png" alt="-1/e < z < 0"/>. All branches except
<img class="math" src="../_images/math/84574de7797bc7b4e1fc52075f4d265ba60a8bce.png" alt="k = 0"/> have a logarithmic singularity at <img class="math" src="../_images/math/aa9f0d97d2f39f78f05e05da40bf04f5a7c0726c.png" alt="z = 0"/>.</p>
<p>The definition, implementation and choice of branches
is based on <a class="reference external" href="../references.html#corless">[Corless]</a>.</p>
<p><strong>Plots</strong></p>
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Branches 0 and -1 of the Lambert W function</span>
<span class="n">plot</span><span class="p">([</span><span class="n">lambertw</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">lambertw</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="o">-</span><span class="mi">1</span><span class="p">)],</span> <span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="mi">5</span><span class="p">,</span><span class="mi">2</span><span class="p">],</span> <span class="n">points</span><span class="o">=</span><span class="mi">2000</span><span class="p">)</span>
</pre></div>
</div>
<img alt="../_images/lambertw.png" src="../_images/lambertw.png" />
<div class="highlight-python"><div class="highlight"><pre><span class="c"># Principal branch of the Lambert W function W(z)</span>
<span class="n">cplot</span><span class="p">(</span><span class="n">lambertw</span><span class="p">,</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">],</span> <span class="n">points</span><span class="o">=</span><span class="mi">50000</span><span class="p">)</span>
</pre></div>
</div>
<img alt="../_images/lambertw_c.png" src="../_images/lambertw_c.png" />
<p><strong>Basic examples</strong></p>
<p>The Lambert W function is the inverse of <img class="math" src="../_images/math/4f14b8f56034ac47a737c7a68d61849c9468570f.png" alt="w \exp(w)"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">25</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">w</span> <span class="o">=</span> <span class="n">lambertw</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">w</span>
<span class="go">0.5671432904097838729999687</span>
<span class="gp">>>> </span><span class="n">w</span><span class="o">*</span><span class="n">exp</span><span class="p">(</span><span class="n">w</span><span class="p">)</span>
<span class="go">1.0</span>
</pre></div>
</div>
<p>Any branch gives a valid inverse:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">w</span> <span class="o">=</span> <span class="n">lambertw</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">w</span>
<span class="go">(-2.853581755409037807206819 + 17.11353553941214591260783j)</span>
<span class="gp">>>> </span><span class="n">w</span> <span class="o">=</span> <span class="n">lambertw</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">25</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">w</span>
<span class="go">(-5.047020464221569709378686 + 155.4763860949415867162066j)</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">w</span><span class="o">*</span><span class="n">exp</span><span class="p">(</span><span class="n">w</span><span class="p">))</span>
<span class="go">1.0</span>
</pre></div>
</div>
<p><strong>Applications to equation-solving</strong></p>
<p>The Lambert W function may be used to solve various kinds of
equations, such as finding the value of the infinite power
tower <img class="math" src="../_images/math/addf38dabe925cedd5b0dd1ec0f4ebf76bc4970f.png" alt="z^{z^{z^{\ldots}}}"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">def</span> <span class="nf">tower</span><span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="n">n</span><span class="p">):</span>
<span class="gp">... </span> <span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">z</span>
<span class="gp">... </span> <span class="k">return</span> <span class="n">z</span> <span class="o">**</span> <span class="n">tower</span><span class="p">(</span><span class="n">z</span><span class="p">,</span> <span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">...</span>
<span class="gp">>>> </span><span class="n">tower</span><span class="p">(</span><span class="n">mpf</span><span class="p">(</span><span class="mf">0.5</span><span class="p">),</span> <span class="mi">100</span><span class="p">)</span>
<span class="go">0.6411857445049859844862005</span>
<span class="gp">>>> </span><span class="o">-</span><span class="n">lambertw</span><span class="p">(</span><span class="o">-</span><span class="n">log</span><span class="p">(</span><span class="mf">0.5</span><span class="p">))</span><span class="o">/</span><span class="n">log</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">0.6411857445049859844862005</span>
</pre></div>
</div>
<p><strong>Properties</strong></p>
<p>The Lambert W function grows roughly like the natural logarithm
for large arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="mi">1000</span><span class="p">);</span> <span class="n">log</span><span class="p">(</span><span class="mi">1000</span><span class="p">)</span>
<span class="go">5.249602852401596227126056</span>
<span class="go">6.907755278982137052053974</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">100</span><span class="p">);</span> <span class="n">log</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">100</span><span class="p">)</span>
<span class="go">224.8431064451185015393731</span>
<span class="go">230.2585092994045684017991</span>
</pre></div>
</div>
<p>The principal branch of the Lambert W function has a rational
Taylor series expansion around <img class="math" src="../_images/math/aa9f0d97d2f39f78f05e05da40bf04f5a7c0726c.png" alt="z = 0"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">taylor</span><span class="p">(</span><span class="n">lambertw</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">6</span><span class="p">),</span> <span class="mi">10</span><span class="p">)</span>
<span class="go">[0.0, 1.0, -1.0, 1.5, -2.666666667, 5.208333333, -10.8]</span>
</pre></div>
</div>
<p>Some special values and limits are:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">0.5671432904097838729999687</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="n">e</span><span class="p">)</span>
<span class="go">1.0</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">k</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">-inf</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="go">-inf</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="n">inf</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="go">(+inf + 12.56637061435917295385057j)</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="n">inf</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="go">(+inf + 18.84955592153875943077586j)</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="o">-</span><span class="n">inf</span><span class="p">,</span> <span class="n">k</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="go">(+inf + 21.9911485751285526692385j)</span>
</pre></div>
</div>
<p>The <img class="math" src="../_images/math/84574de7797bc7b4e1fc52075f4d265ba60a8bce.png" alt="k = 0"/> and <img class="math" src="../_images/math/a82f7b76d2e16054f75df1ea45cb2a043f09ffad.png" alt="k = -1"/> branches join at <img class="math" src="../_images/math/b87eeae0e16a9f455c33ea11b80738764425b62d.png" alt="z = -1/e"/> where
<img class="math" src="../_images/math/c8f915f0cf1bd473190da32d8ffebe485b7761ae.png" alt="W(z) = -1"/> for both branches. Since <img class="math" src="../_images/math/57f1ee23691a5f2ed1e11109820ee928ceaeef65.png" alt="-1/e"/> can only be represented
approximately with binary floating-point numbers, evaluating the
Lambert W function at this point only gives <img class="math" src="../_images/math/bae5aba07d37ff6ff813107e76260fb31ad5794e.png" alt="-1"/> approximately:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="o">/</span><span class="n">e</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">-0.9999999999998371330228251</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="o">/</span><span class="n">e</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">-1.000000000000162866977175</span>
</pre></div>
</div>
<p>If <img class="math" src="../_images/math/57f1ee23691a5f2ed1e11109820ee928ceaeef65.png" alt="-1/e"/> happens to round in the negative direction, there might be
a small imaginary part:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="o">/</span><span class="n">e</span><span class="p">)</span>
<span class="go">(-1.0 + 8.22007971483662e-9j)</span>
<span class="gp">>>> </span><span class="n">lambertw</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="o">/</span><span class="n">e</span><span class="o">+</span><span class="n">eps</span><span class="p">)</span>
<span class="go">-0.999999966242188</span>
</pre></div>
</div>
<p><strong>References</strong></p>
<ol class="arabic simple">
<li><a class="reference external" href="../references.html#corless">[Corless]</a></li>
</ol>
</dd></dl>
</div>
</div>
<div class="section" id="arithmetic-geometric-mean">
<h2>Arithmetic-geometric mean<a class="headerlink" href="#arithmetic-geometric-mean" title="Permalink to this headline">¶</a></h2>
<div class="section" id="agm">
<h3><tt class="xref docutils literal"><span class="pre">agm()</span></tt><a class="headerlink" href="#agm" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.agm">
<tt class="descclassname">mpmath.</tt><tt class="descname">agm</tt><big>(</big><em>a</em>, <em>b=1</em><big>)</big><a class="headerlink" href="#mpmath.agm" title="Permalink to this definition">¶</a></dt>
<dd><p><tt class="docutils literal"><span class="pre">agm(a,</span> <span class="pre">b)</span></tt> computes the arithmetic-geometric mean of <img class="math" src="../_images/math/c7d457e388298246adb06c587bccd419ea67f7e8.png" alt="a"/> and
<img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/>, defined as the limit of the following iteration:</p>
<div class="math">
<p><img src="../_images/math/8a1590a455bc984da91424d957f5f94dff23cac2.png" alt="a_0 = a
b_0 = b
a_{n+1} = \frac{a_n+b_n}{2}
b_{n+1} = \sqrt{a_n b_n}" /></p>
</div><p>This function can be called with a single argument, computing
<img class="math" src="../_images/math/123faed9086f29247221027e0b0abe89def0c6c5.png" alt="\mathrm{agm}(a,1) = \mathrm{agm}(1,a)"/>.</p>
<p><strong>Examples</strong></p>
<p>It is a well-known theorem that the geometric mean of
two distinct positive numbers is less than the arithmetic
mean. It follows that the arithmetic-geometric mean lies
between the two means:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">mpf</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="n">a</span><span class="o">*</span><span class="n">b</span><span class="p">)</span>
<span class="go">3.46410161513775</span>
<span class="gp">>>> </span><span class="n">agm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">)</span>
<span class="go">3.48202767635957</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">a</span><span class="o">+</span><span class="n">b</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="go">3.5</span>
</pre></div>
</div>
<p>The arithmetic-geometric mean is scale-invariant:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">agm</span><span class="p">(</span><span class="mi">10</span><span class="o">*</span><span class="n">e</span><span class="p">,</span> <span class="mi">10</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span>
<span class="go">29.261085515723</span>
<span class="gp">>>> </span><span class="mi">10</span><span class="o">*</span><span class="n">agm</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">pi</span><span class="p">)</span>
<span class="go">29.261085515723</span>
</pre></div>
</div>
<p>As an order-of-magnitude estimate, <img class="math" src="../_images/math/2e042873df5ea9063793fa27d00ca660862a7806.png" alt="\mathrm{agm}(1,x) \approx x"/>
for large <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">agm</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">10</span><span class="p">)</span>
<span class="go">643448704.760133</span>
<span class="gp">>>> </span><span class="n">agm</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">50</span><span class="p">)</span>
<span class="go">1.34814309345871e+48</span>
</pre></div>
</div>
<p>For tiny <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/9713f6e0ad4bc38c4bb9b33c84311828627ad139.png" alt="\mathrm{agm}(1,x) \approx -\pi/(2 \log(x/4))"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">agm</span><span class="p">(</span><span class="s">'0.01'</span><span class="p">)</span>
<span class="go">0.262166887202249</span>
<span class="gp">>>> </span><span class="o">-</span><span class="n">pi</span><span class="o">/</span><span class="mi">2</span><span class="o">/</span><span class="n">log</span><span class="p">(</span><span class="s">'0.0025'</span><span class="p">)</span>
<span class="go">0.262172347753122</span>
</pre></div>
</div>
<p>The arithmetic-geometric mean can also be computed for complex
numbers:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">agm</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="o">+</span><span class="n">j</span><span class="p">)</span>
<span class="go">(2.51055133276184 + 0.547394054060638j)</span>
</pre></div>
</div>
<p>The AGM iteration converges very quickly (each step doubles
the number of correct digits), so <a title="mpmath.agm" class="reference internal" href="#mpmath.agm"><tt class="xref docutils literal"><span class="pre">agm()</span></tt></a> supports efficient
high-precision evaluation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">10000</span>
<span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="n">agm</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">a</span><span class="p">)[</span><span class="o">-</span><span class="mi">10</span><span class="p">:]</span>
<span class="go">'1679581912'</span>
</pre></div>
</div>
<p><strong>Mathematical relations</strong></p>
<p>The arithmetic-geometric mean may be used to evaluate the
following two parametric definite integrals:</p>
<div class="math">
<p><img src="../_images/math/a176929675b1657b4fa9a9bab0d781828f64072c.png" alt="I_1 = \int_0^{\infty}
\frac{1}{\sqrt{(x^2+a^2)(x^2+b^2)}} \,dx
I_2 = \int_0^{\pi/2}
\frac{1}{\sqrt{a^2 \cos^2(x) + b^2 \sin^2(x)}} \,dx" /></p>
</div><p>We have:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="mi">3</span>
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="mi">4</span>
<span class="gp">>>> </span><span class="n">f1</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="p">((</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="o">+</span><span class="n">a</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="n">x</span><span class="o">**</span><span class="mi">2</span><span class="o">+</span><span class="n">b</span><span class="o">**</span><span class="mi">2</span><span class="p">))</span><span class="o">**-</span><span class="mf">0.5</span>
<span class="gp">>>> </span><span class="n">f2</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="p">((</span><span class="n">a</span><span class="o">*</span><span class="n">cos</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="o">**</span><span class="mi">2</span> <span class="o">+</span> <span class="p">(</span><span class="n">b</span><span class="o">*</span><span class="n">sin</span><span class="p">(</span><span class="n">x</span><span class="p">))</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span><span class="o">**-</span><span class="mf">0.5</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="n">f1</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">inf</span><span class="p">])</span>
<span class="go">0.451115405388492</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="n">f2</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">pi</span><span class="o">/</span><span class="mi">2</span><span class="p">])</span>
<span class="go">0.451115405388492</span>
<span class="gp">>>> </span><span class="n">pi</span><span class="o">/</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">agm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">))</span>
<span class="go">0.451115405388492</span>
</pre></div>
</div>
<p>A formula for <img class="math" src="../_images/math/c13d390a75aea6c20cb4b2d0ba24cfe0582fa13a.png" alt="\Gamma(1/4)"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">gamma</span><span class="p">(</span><span class="mf">0.25</span><span class="p">)</span>
<span class="go">3.62560990822191</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span><span class="o">/</span><span class="n">agm</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">2</span><span class="p">)))</span>
<span class="go">3.62560990822191</span>
</pre></div>
</div>
<p><strong>Possible issues</strong></p>
<p>The branch cut chosen for complex <img class="math" src="../_images/math/c7d457e388298246adb06c587bccd419ea67f7e8.png" alt="a"/> and <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> is somewhat
arbitrary.</p>
</dd></dl>
</div>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../index.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference external" href="#">Powers and logarithms</a><ul>
<li><a class="reference external" href="#nth-roots">Nth roots</a><ul>
<li><a class="reference external" href="#sqrt"><tt class="docutils literal"><span class="pre">sqrt()</span></tt></a></li>
<li><a class="reference external" href="#hypot"><tt class="docutils literal"><span class="pre">hypot()</span></tt></a></li>
<li><a class="reference external" href="#cbrt"><tt class="docutils literal"><span class="pre">cbrt()</span></tt></a></li>
<li><a class="reference external" href="#root"><tt class="docutils literal"><span class="pre">root()</span></tt></a></li>
<li><a class="reference external" href="#unitroots"><tt class="docutils literal"><span class="pre">unitroots()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#exponentiation">Exponentiation</a><ul>
<li><a class="reference external" href="#exp"><tt class="docutils literal"><span class="pre">exp()</span></tt></a></li>
<li><a class="reference external" href="#power"><tt class="docutils literal"><span class="pre">power()</span></tt></a></li>
<li><a class="reference external" href="#expj"><tt class="docutils literal"><span class="pre">expj()</span></tt></a></li>
<li><a class="reference external" href="#expjpi"><tt class="docutils literal"><span class="pre">expjpi()</span></tt></a></li>
<li><a class="reference external" href="#expm1"><tt class="docutils literal"><span class="pre">expm1()</span></tt></a></li>
<li><a class="reference external" href="#powm1"><tt class="docutils literal"><span class="pre">powm1()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#logarithms">Logarithms</a><ul>
<li><a class="reference external" href="#log"><tt class="docutils literal"><span class="pre">log()</span></tt></a></li>
<li><a class="reference external" href="#ln"><tt class="docutils literal"><span class="pre">ln()</span></tt></a></li>
<li><a class="reference external" href="#log10"><tt class="docutils literal"><span class="pre">log10()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#lambert-w-function">Lambert W function</a><ul>
<li><a class="reference external" href="#lambertw"><tt class="docutils literal"><span class="pre">lambertw()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#arithmetic-geometric-mean">Arithmetic-geometric mean</a><ul>
<li><a class="reference external" href="#agm"><tt class="docutils literal"><span class="pre">agm()</span></tt></a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="constants.html"
title="previous chapter">Mathematical constants</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="trigonometric.html"
title="next chapter">Trigonometric functions</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/functions/powers.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../modindex.html" title="Global Module Index"
>modules</a> |</li>
<li class="right" >
<a href="trigonometric.html" title="Trigonometric functions"
>next</a> |</li>
<li class="right" >
<a href="constants.html" title="Mathematical constants"
>previous</a> |</li>
<li><a href="../index.html">mpmath v0.17 documentation</a> »</li>
<li><a href="index.html" >Mathematical functions</a> »</li>
</ul>
</div>
<div class="footer">
© Copyright 2010, Fredrik Johansson.
Last updated on Feb 06, 2011.
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.6.6.
</div>
</body>
</html>
distrib
>
Fedora
>
13
>
i386
>
media
>
updates
>
by-pkgid
>
f3eb4c16ba6256fe5a10e54bf649f01f
>
files
>
1238
