<!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>Factorials and gamma functions — 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="Exponential integrals and error functions" href="expintegrals.html" />
<link rel="prev" title="Hyperbolic functions" href="hyperbolic.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="expintegrals.html" title="Exponential integrals and error functions"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="hyperbolic.html" title="Hyperbolic functions"
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="factorials-and-gamma-functions">
<h1>Factorials and gamma functions<a class="headerlink" href="#factorials-and-gamma-functions" title="Permalink to this headline">¶</a></h1>
<p>Factorials and factorial-like sums and products are basic tools of combinatorics and number theory. Much like the exponential function is fundamental to differential equations and analysis in general, the factorial function (and its extension to complex numbers, the gamma function) is fundamental to difference equations and functional equations.</p>
<p>A large selection of factorial-like functions is implemented in mpmath. All functions support complex arguments, and arguments may be arbitrarily large. Results are numerical approximations, so to compute <em>exact</em> values a high enough precision must be set manually:</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="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">fac</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
<span class="go">9.33262154439442e+157</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="nb">int</span><span class="p">(</span><span class="n">_</span><span class="p">)</span> <span class="c"># most digits are wrong</span>
<span class="go">93326215443944150965646704795953882578400970373184098831012889540582227238570431</span>
<span class="go">295066113089288327277825849664006524270554535976289719382852181865895959724032</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">160</span>
<span class="gp">>>> </span><span class="n">fac</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
<span class="go">93326215443944152681699238856266700490715968264381621468592963895217599993229915</span>
<span class="go">608941463976156518286253697920827223758251185210916864000000000000000000000000.0</span>
</pre></div>
</div>
<p>The gamma and polygamma functions are closely related to <a class="reference external" href="zeta.html"><em>Zeta functions, L-series and polylogarithms</em></a>. See also <a class="reference external" href="qfunctions.html"><em>q-functions</em></a> for q-analogs of factorial-like functions.</p>
<div class="section" id="factorials">
<h2>Factorials<a class="headerlink" href="#factorials" title="Permalink to this headline">¶</a></h2>
<div class="section" id="factorial-fac">
<h3><tt class="xref docutils literal"><span class="pre">factorial()</span></tt>/<tt class="xref docutils literal"><span class="pre">fac()</span></tt><a class="headerlink" href="#factorial-fac" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.factorial">
<tt class="descclassname">mpmath.</tt><tt class="descname">factorial</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.factorial" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the factorial, <img class="math" src="../_images/math/2950e3accfad26309bf1ecf6947061171fd2797f.png" alt="x!"/>. For integers <img class="math" src="../_images/math/e2c7d62172af0e738dd12f47f3f8ad8ef70cd65f.png" alt="n \ge 0"/>, we have
<img class="math" src="../_images/math/6c0c4ee2888c6e0414e9ab053b8d38f76275c138.png" alt="n! = 1 \cdot 2 \cdots (n-1) \cdot n"/> and more generally the factorial
is defined for real or complex <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/> by <img class="math" src="../_images/math/1477fc5f4ac968fb66eee11dec059480a0ad146c.png" alt="x! = \Gamma(x+1)"/>.</p>
<p><strong>Examples</strong></p>
<p>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="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="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">k</span><span class="p">,</span> <span class="n">fac</span><span class="p">(</span><span class="n">k</span><span class="p">)))</span>
<span class="gp">...</span>
<span class="go">0 1.0</span>
<span class="go">1 1.0</span>
<span class="go">2 2.0</span>
<span class="go">3 6.0</span>
<span class="go">4 24.0</span>
<span class="go">5 120.0</span>
<span class="gp">>>> </span><span class="n">fac</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">fac</span><span class="p">(</span><span class="mf">0.5</span><span class="p">),</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="go">(0.886226925452758, 0.886226925452758)</span>
</pre></div>
</div>
<p>For large positive <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, <img class="math" src="../_images/math/2950e3accfad26309bf1ecf6947061171fd2797f.png" alt="x!"/> can be approximated by
Stirling’s formula:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="mi">10</span><span class="o">**</span><span class="mi">10</span>
<span class="gp">>>> </span><span class="n">fac</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="go">2.32579620567308e+95657055186</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">pi</span><span class="o">*</span><span class="n">x</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="n">x</span><span class="o">/</span><span class="n">e</span><span class="p">)</span><span class="o">**</span><span class="n">x</span>
<span class="go">2.32579597597705e+95657055186</span>
</pre></div>
</div>
<p><tt class="xref docutils literal"><span class="pre">fac()</span></tt> supports evaluation for astronomically large values:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fac</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">30</span><span class="p">)</span>
<span class="go">6.22311232304258e+29565705518096748172348871081098</span>
</pre></div>
</div>
<p>Reciprocal factorials appear in the Taylor series of the
exponential function (among many other contexts):</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="mi">1</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="n">exp</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(2.71828182845905, 2.71828182845905)</span>
<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="n">exp</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">(23.1406926327793, 23.1406926327793)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="fac2">
<h3><tt class="xref docutils literal"><span class="pre">fac2()</span></tt><a class="headerlink" href="#fac2" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.fac2">
<tt class="descclassname">mpmath.</tt><tt class="descname">fac2</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#mpmath.fac2" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the double factorial <img class="math" src="../_images/math/9dac1ff8fa3c29c29995e14947de1c827e7951ad.png" alt="x!!"/>, defined for integers
<img class="math" src="../_images/math/cae4fd68f44ac9b909f8d91f9d498de5759bb45b.png" alt="x > 0"/> by</p>
<div class="math">
<p><img src="../_images/math/0976200a76e1270d24345b631d6f957aff745b26.png" alt="x!! = \begin{cases}
1 \cdot 3 \cdots (x-2) \cdot x & x \;\mathrm{odd} \\
2 \cdot 4 \cdots (x-2) \cdot x & x \;\mathrm{even}
\end{cases}" /></p>
</div><p>and more generally by [1]</p>
<div class="math">
<p><img src="../_images/math/f339892887fffd06774075144b0e16d966e08d16.png" alt="x!! = 2^{x/2} \left(\frac{\pi}{2}\right)^{(\cos(\pi x)-1)/4}
\Gamma\left(\frac{x}{2}+1\right)." /></p>
</div><p><strong>Examples</strong></p>
<p>The integer sequence of double factorials begins:</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">fac2</span><span class="p">(</span><span class="n">n</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">10</span><span class="p">)])</span>
<span class="go">[1.0, 1.0, 2.0, 3.0, 8.0, 15.0, 48.0, 105.0, 384.0, 945.0]</span>
</pre></div>
</div>
<p>For large <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/>, double factorials follow a Stirling-like asymptotic
approximation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">mpf</span><span class="p">(</span><span class="mi">10000</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">fac2</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="go">5.97272691416282e+17830</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span><span class="o">*</span><span class="n">x</span><span class="o">**</span><span class="p">((</span><span class="n">x</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span><span class="o">*</span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">x</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span>
<span class="go">5.97262736954392e+17830</span>
</pre></div>
</div>
<p>The recurrence formula <img class="math" src="../_images/math/3385eb2e9d54abbd1da197208bd4a0b6dae68ce7.png" alt="x!! = x (x-2)!!"/> can be reversed to
define the double factorial of negative odd integers (but
not negative even integers):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fac2</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span> <span class="n">fac2</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">),</span> <span class="n">fac2</span><span class="p">(</span><span class="o">-</span><span class="mi">5</span><span class="p">),</span> <span class="n">fac2</span><span class="p">(</span><span class="o">-</span><span class="mi">7</span><span class="p">)</span>
<span class="go">(1.0, -1.0, 0.333333333333333, -0.0666666666666667)</span>
<span class="gp">>>> </span><span class="n">fac2</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">ValueError</span>: <span class="n-Identifier">gamma function pole</span>
</pre></div>
</div>
<p>With the exception of the poles at negative even integers,
<a title="mpmath.fac2" class="reference internal" href="#mpmath.fac2"><tt class="xref docutils literal"><span class="pre">fac2()</span></tt></a> supports evaluation for arbitrary complex arguments.
The recurrence formula is valid generally:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fac2</span><span class="p">(</span><span class="n">pi</span><span class="o">+</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span>
<span class="go">(-1.3697207890154e-12 + 3.93665300979176e-12j)</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">pi</span><span class="o">+</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span><span class="o">*</span><span class="n">fac2</span><span class="p">(</span><span class="n">pi</span><span class="o">-</span><span class="mi">2</span><span class="o">+</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span>
<span class="go">(-1.3697207890154e-12 + 3.93665300979176e-12j)</span>
</pre></div>
</div>
<p>Double factorials should not be confused with nested factorials,
which are immensely larger:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fac</span><span class="p">(</span><span class="n">fac</span><span class="p">(</span><span class="mi">20</span><span class="p">))</span>
<span class="go">5.13805976125208e+43675043585825292774</span>
<span class="gp">>>> </span><span class="n">fac2</span><span class="p">(</span><span class="mi">20</span><span class="p">)</span>
<span class="go">3715891200.0</span>
</pre></div>
</div>
<p>Double factorials appear, among other things, in series expansions
of Gaussian functions and the error function. Infinite series
include:</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="mi">1</span><span class="o">/</span><span class="n">fac2</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">3.05940740534258</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="n">e</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="n">sqrt</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="o">*</span><span class="n">erf</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="o">/</span><span class="mi">2</span><span class="p">))</span>
<span class="go">3.05940740534258</span>
<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="mi">2</span><span class="o">**</span><span class="n">k</span><span class="o">/</span><span class="n">fac2</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="n">inf</span><span class="p">])</span>
<span class="go">4.06015693855741</span>
<span class="gp">>>> </span><span class="n">e</span> <span class="o">*</span> <span class="n">erf</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span> <span class="o">*</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">4.06015693855741</span>
</pre></div>
</div>
<p>A beautiful Ramanujan sum:</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="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">**</span><span class="n">k</span><span class="o">*</span><span class="p">(</span><span class="n">fac2</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="n">fac2</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="p">))</span><span class="o">**</span><span class="mi">3</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.90917279454693</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">gamma</span><span class="p">(</span><span class="s">'9/8'</span><span class="p">)</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="s">'5/4'</span><span class="p">)</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="s">'7/8'</span><span class="p">))</span><span class="o">**</span><span class="mi">2</span>
<span class="go">0.90917279454693</span>
</pre></div>
</div>
<p><strong>References</strong></p>
<ol class="arabic simple">
<li><a class="reference external" href="http://functions.wolfram.com/GammaBetaErf/Factorial2/27/01/0002/">http://functions.wolfram.com/GammaBetaErf/Factorial2/27/01/0002/</a></li>
<li><a class="reference external" href="http://mathworld.wolfram.com/DoubleFactorial.html">http://mathworld.wolfram.com/DoubleFactorial.html</a></li>
</ol>
</dd></dl>
</div>
</div>
<div class="section" id="binomial-coefficients">
<h2>Binomial coefficients<a class="headerlink" href="#binomial-coefficients" title="Permalink to this headline">¶</a></h2>
<div class="section" id="binomial">
<h3><tt class="xref docutils literal"><span class="pre">binomial()</span></tt><a class="headerlink" href="#binomial" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.binomial">
<tt class="descclassname">mpmath.</tt><tt class="descname">binomial</tt><big>(</big><em>n</em>, <em>k</em><big>)</big><a class="headerlink" href="#mpmath.binomial" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the binomial coefficient</p>
<div class="math">
<p><img src="../_images/math/bdbb15f258885b2ee7f574265055dbeb86cdebdf.png" alt="{n \choose k} = \frac{n!}{k!(n-k)!}." /></p>
</div><p>The binomial coefficient gives the number of ways that <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/> items
can be chosen from a set of <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> items. More generally, the binomial
coefficient is a well-defined function of arbitrary real or
complex <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> and <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/>, via the gamma function.</p>
<p><strong>Examples</strong></p>
<p>Generate Pascal’s triangle:</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="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">5</span><span class="p">):</span>
<span class="gp">... </span> <span class="n">nprint</span><span class="p">([</span><span class="n">binomial</span><span class="p">(</span><span class="n">n</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="n">n</span><span class="o">+</span><span class="mi">1</span><span class="p">)])</span>
<span class="gp">...</span>
<span class="go">[1.0]</span>
<span class="go">[1.0, 1.0]</span>
<span class="go">[1.0, 2.0, 1.0]</span>
<span class="go">[1.0, 3.0, 3.0, 1.0]</span>
<span class="go">[1.0, 4.0, 6.0, 4.0, 1.0]</span>
</pre></div>
</div>
<p>There is 1 way to select 0 items from the empty set, and 0 ways to
select 1 item from the empty set:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">binomial</span><span class="p">(</span><span class="mi">0</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">binomial</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">0.0</span>
</pre></div>
</div>
<p><a title="mpmath.binomial" class="reference internal" href="#mpmath.binomial"><tt class="xref docutils literal"><span class="pre">binomial()</span></tt></a> supports large arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">binomial</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">20</span><span class="p">,</span> <span class="mi">10</span><span class="o">**</span><span class="mi">20</span><span class="o">-</span><span class="mi">5</span><span class="p">)</span>
<span class="go">8.33333333333333e+97</span>
<span class="gp">>>> </span><span class="n">binomial</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">20</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">2.60784095465201e+104342944813</span>
</pre></div>
</div>
<p>Nonintegral binomial coefficients find use in series
expansions:</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="k">lambda</span> <span class="n">x</span><span class="p">:</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="o">**</span><span class="mf">0.25</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">4</span><span class="p">))</span>
<span class="go">[1.0, 0.25, -0.09375, 0.0546875, -0.0375977]</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">([</span><span class="n">binomial</span><span class="p">(</span><span class="mf">0.25</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">5</span><span class="p">)])</span>
<span class="go">[1.0, 0.25, -0.09375, 0.0546875, -0.0375977]</span>
</pre></div>
</div>
<p>An integral representation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">n</span><span class="p">,</span> <span class="n">k</span> <span class="o">=</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">3</span>
<span class="gp">>>> </span><span class="n">f</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">j</span><span class="o">*</span><span class="n">k</span><span class="o">*</span><span class="n">t</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="n">exp</span><span class="p">(</span><span class="n">j</span><span class="o">*</span><span class="n">t</span><span class="p">))</span><span class="o">**</span><span class="n">n</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">quad</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="p">[</span><span class="o">-</span><span class="n">pi</span><span class="p">,</span><span class="n">pi</span><span class="p">])</span><span class="o">/</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">))</span>
<span class="go">10.0</span>
<span class="gp">>>> </span><span class="n">binomial</span><span class="p">(</span><span class="n">n</span><span class="p">,</span><span class="n">k</span><span class="p">)</span>
<span class="go">10.0</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="gamma-function">
<h2>Gamma function<a class="headerlink" href="#gamma-function" title="Permalink to this headline">¶</a></h2>
<div class="section" id="gamma">
<h3><tt class="xref docutils literal"><span class="pre">gamma()</span></tt><a class="headerlink" href="#gamma" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.gamma">
<tt class="descclassname">mpmath.</tt><tt class="descname">gamma</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.gamma" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the gamma function, <img class="math" src="../_images/math/36edacaf2ec3d06fb117f981d12f42cdee6cf940.png" alt="\Gamma(x)"/>. The gamma function is a
shifted version of the ordinary factorial, satisfying
<img class="math" src="../_images/math/556ae5f6a1c0ceaa5e922ce2b174fd8d6f0ff008.png" alt="\Gamma(n) = (n-1)!"/> for integers <img class="math" src="../_images/math/f3d1431ad346632b25a0e7b3f12ebe19723b3960.png" alt="n > 0"/>. More generally, it
is defined by</p>
<div class="math">
<p><img src="../_images/math/65fc2d2f449e1140920cedf39abf3763a074de02.png" alt="\Gamma(x) = \int_0^{\infty} t^{x-1} e^{-t}\, dt" /></p>
</div><p>for any real or complex <img class="math" src="../_images/math/26eeb5258ca5099acf8fe96b2a1049c48c89a5e6.png" alt="x"/> with <img class="math" src="../_images/math/1c994b344b0ba93fa3d7eb1de7ddbb51c8b57cd7.png" alt="\Re(x) > 0"/> and for <img class="math" src="../_images/math/8123f299b3e71f1d37714e1f3794f955760cfa06.png" alt="\Re(x) < 0"/>
by analytic continuation.</p>
<p><strong>Examples</strong></p>
<p>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="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">1</span><span class="p">,</span> <span class="mi">6</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">k</span><span class="p">,</span> <span class="n">gamma</span><span class="p">(</span><span class="n">k</span><span class="p">)))</span>
<span class="gp">...</span>
<span class="go">1 1.0</span>
<span class="go">2 1.0</span>
<span class="go">3 2.0</span>
<span class="go">4 6.0</span>
<span class="go">5 24.0</span>
<span class="gp">>>> </span><span class="n">gamma</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">gamma</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">ValueError</span>: <span class="n-Identifier">gamma function pole</span>
</pre></div>
</div>
<p>The gamma function of a half-integer is a rational multiple of
<img class="math" src="../_images/math/ee0529202bae221e2a886dbd92ecd50e87f90452.png" alt="\sqrt{\pi}"/>:</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.5</span><span class="p">),</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">(1.77245385090552, 1.77245385090552)</span>
<span class="gp">>>> </span><span class="n">gamma</span><span class="p">(</span><span class="mf">1.5</span><span class="p">),</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="go">(0.886226925452758, 0.886226925452758)</span>
</pre></div>
</div>
<p>We can check the integral definition:</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">3.5</span><span class="p">)</span>
<span class="go">3.32335097044784</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">t</span><span class="o">**</span><span class="mf">2.5</span><span class="o">*</span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">t</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">3.32335097044784</span>
</pre></div>
</div>
<p><a title="mpmath.gamma" class="reference internal" href="#mpmath.gamma"><tt class="xref docutils literal"><span class="pre">gamma()</span></tt></a> supports arbitrary-precision evaluation and
complex arguments:</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">gamma</span><span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>
<span class="go">0.91510229697308632046045539308226554038315280564184</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">gamma</span><span class="p">(</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.009902440080927490985955066 - 0.07595200133501806872408048j)</span>
</pre></div>
</div>
<p>Arguments can also be large. Note that the gamma function grows
very quickly:</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">gamma</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="mi">20</span><span class="p">)</span>
<span class="go">1.9328495143101e+1956570551809674817225</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="rgamma">
<h3><tt class="xref docutils literal"><span class="pre">rgamma()</span></tt><a class="headerlink" href="#rgamma" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.rgamma">
<tt class="descclassname">mpmath.</tt><tt class="descname">rgamma</tt><big>(</big><em>x</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#mpmath.rgamma" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the reciprocal of the gamma function, <img class="math" src="../_images/math/676d67331d364651a578b78ce258e6a24b967f54.png" alt="1/\Gamma(z)"/>. This
function evaluates to zero at the poles
of the gamma function, <img class="math" src="../_images/math/ce90a96c015fb3135d2870b05a853b3c1196f46d.png" alt="z = 0, -1, -2, \ldots"/>.</p>
<p><strong>Examples</strong></p>
<p>Basic examples:</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">rgamma</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">rgamma</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">0.1666666666666666666666667</span>
<span class="gp">>>> </span><span class="n">rgamma</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> <span class="n">rgamma</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">rgamma</span><span class="p">(</span><span class="mi">1000</span><span class="p">)</span>
<span class="go">2.485168143266784862783596e-2565</span>
<span class="gp">>>> </span><span class="n">rgamma</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">0.0</span>
</pre></div>
</div>
<p>A definite integral that can be evaluated in terms of elementary
integrals:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="n">rgamma</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">2.807770242028519365221501</span>
<span class="gp">>>> </span><span class="n">e</span> <span class="o">+</span> <span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="n">t</span><span class="p">)</span><span class="o">/</span><span class="p">(</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="n">t</span><span class="p">)</span><span class="o">**</span><span class="mi">2</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">2.807770242028519365221501</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="gammaprod">
<h3><tt class="xref docutils literal"><span class="pre">gammaprod()</span></tt><a class="headerlink" href="#gammaprod" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.gammaprod">
<tt class="descclassname">mpmath.</tt><tt class="descname">gammaprod</tt><big>(</big><em>a</em>, <em>b</em><big>)</big><a class="headerlink" href="#mpmath.gammaprod" title="Permalink to this definition">¶</a></dt>
<dd><p>Given iterables <img class="math" src="../_images/math/c7d457e388298246adb06c587bccd419ea67f7e8.png" alt="a"/> and <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/>, <tt class="docutils literal"><span class="pre">gammaprod(a,</span> <span class="pre">b)</span></tt> computes the
product / quotient of gamma functions:</p>
<div class="math">
<p><img src="../_images/math/ab622d03541d902f5282d1b80c21fc40ce599d6a.png" alt="\frac{\Gamma(a_0) \Gamma(a_1) \cdots \Gamma(a_p)}
{\Gamma(b_0) \Gamma(b_1) \cdots \Gamma(b_q)}" /></p>
</div><p>Unlike direct calls to <a title="mpmath.gamma" class="reference internal" href="#mpmath.gamma"><tt class="xref docutils literal"><span class="pre">gamma()</span></tt></a>, <a title="mpmath.gammaprod" class="reference internal" href="#mpmath.gammaprod"><tt class="xref docutils literal"><span class="pre">gammaprod()</span></tt></a> considers
the entire product as a limit and evaluates this limit properly if
any of the numerator or denominator arguments are nonpositive
integers such that poles of the gamma function are encountered.
That is, <a title="mpmath.gammaprod" class="reference internal" href="#mpmath.gammaprod"><tt class="xref docutils literal"><span class="pre">gammaprod()</span></tt></a> evaluates</p>
<div class="math">
<p><img src="../_images/math/e37b86e9baef6c51fae50cdb13aba2e3fec400ac.png" alt="\lim_{\epsilon \to 0}
\frac{\Gamma(a_0+\epsilon) \Gamma(a_1+\epsilon) \cdots
\Gamma(a_p+\epsilon)}
{\Gamma(b_0+\epsilon) \Gamma(b_1+\epsilon) \cdots
\Gamma(b_q+\epsilon)}" /></p>
</div><p>In particular:</p>
<ul class="simple">
<li>If there are equally many poles in the numerator and the
denominator, the limit is a rational number times the remaining,
regular part of the product.</li>
<li>If there are more poles in the numerator, <a title="mpmath.gammaprod" class="reference internal" href="#mpmath.gammaprod"><tt class="xref docutils literal"><span class="pre">gammaprod()</span></tt></a>
returns <tt class="docutils literal"><span class="pre">+inf</span></tt>.</li>
<li>If there are more poles in the denominator, <a title="mpmath.gammaprod" class="reference internal" href="#mpmath.gammaprod"><tt class="xref docutils literal"><span class="pre">gammaprod()</span></tt></a>
returns 0.</li>
</ul>
<p><strong>Examples</strong></p>
<p>The reciprocal gamma function <img class="math" src="../_images/math/88acd233f0e0f03bd54278e4a23d853d82f1df69.png" alt="1/\Gamma(x)"/> evaluated at <img class="math" src="../_images/math/2d348bde3e15456e71734dc2c56fc7425c95927f.png" alt="x = 0"/>:</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="gp">>>> </span><span class="n">gammaprod</span><span class="p">([],</span> <span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="go">0.0</span>
</pre></div>
</div>
<p>A limit:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">gammaprod</span><span class="p">([</span><span class="o">-</span><span class="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="mi">3</span><span class="p">])</span>
<span class="go">-0.25</span>
<span class="gp">>>> </span><span class="n">limit</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">gamma</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="n">x</span><span class="p">),</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="n">direction</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">-0.25</span>
<span class="gp">>>> </span><span class="n">limit</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">gamma</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">/</span><span class="n">gamma</span><span class="p">(</span><span class="n">x</span><span class="p">),</span> <span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="n">direction</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">-0.25</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="loggamma">
<h3><tt class="xref docutils literal"><span class="pre">loggamma()</span></tt><a class="headerlink" href="#loggamma" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.loggamma">
<tt class="descclassname">mpmath.</tt><tt class="descname">loggamma</tt><big>(</big><em>x</em><big>)</big><a class="headerlink" href="#mpmath.loggamma" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the principal branch of the log-gamma function,
<img class="math" src="../_images/math/38ece65ede8a19a843ca4ee7971843dca89294d2.png" alt="\ln \Gamma(z)"/>. Unlike <img class="math" src="../_images/math/5eeb6d5fe38d952cd99378c691ab37bc50fa75ed.png" alt="\ln(\Gamma(z))"/>, which has infinitely many
complex branch cuts, the principal log-gamma function only has a single
branch cut along the negative half-axis. The principal branch
continuously matches the asymptotic Stirling expansion</p>
<div class="math">
<p><img src="../_images/math/f4c41d0c9cda4a0a28ea4c423db645a4ab663f1f.png" alt="\ln \Gamma(z) \sim \frac{\ln(2 \pi)}{2} +
\left(z-\frac{1}{2}\right) \ln(z) - z + O(z^{-1})." /></p>
</div><p>The real parts of both functions agree, but their imaginary
parts generally differ by <img class="math" src="../_images/math/f473903036b5a8ba507a9031527374de69966e85.png" alt="2 n \pi"/> for some <img class="math" src="../_images/math/deb2f72d06607835f0e9e8af5587ba8f9abb2cfa.png" alt="n \in \mathbb{Z}"/>.
They coincide for <img class="math" src="../_images/math/3dfc77fff24207d06082b2d9b49b49b23fafd9dd.png" alt="z \in \mathbb{R}, z > 0"/>.</p>
<p>Computationally, it is advantageous to use <a title="mpmath.loggamma" class="reference internal" href="#mpmath.loggamma"><tt class="xref docutils literal"><span class="pre">loggamma()</span></tt></a>
instead of <a title="mpmath.gamma" class="reference internal" href="#mpmath.gamma"><tt class="xref docutils literal"><span class="pre">gamma()</span></tt></a> for extremely large arguments.</p>
<p><strong>Examples</strong></p>
<p>Comparing with <img class="math" src="../_images/math/5eeb6d5fe38d952cd99378c691ab37bc50fa75ed.png" alt="\ln(\Gamma(z))"/>:</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">loggamma</span><span class="p">(</span><span class="s">'13.2'</span><span class="p">);</span> <span class="n">log</span><span class="p">(</span><span class="n">gamma</span><span class="p">(</span><span class="s">'13.2'</span><span class="p">))</span>
<span class="go">20.49400419456603678498394</span>
<span class="go">20.49400419456603678498394</span>
<span class="gp">>>> </span><span class="n">loggamma</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.756626784603784110530604 + 4.742664438034657928194889j)</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">gamma</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.756626784603784110530604 - 1.540520869144928548730397j)</span>
<span class="gp">>>> </span><span class="n">log</span><span class="p">(</span><span class="n">gamma</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="o">+</span> <span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="o">*</span><span class="n">j</span>
<span class="go">(-1.756626784603784110530604 + 4.742664438034657928194889j)</span>
</pre></div>
</div>
<p>Note the imaginary parts for negative arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="o">-</span><span class="mf">0.5</span><span class="p">);</span> <span class="n">loggamma</span><span class="p">(</span><span class="o">-</span><span class="mf">1.5</span><span class="p">);</span> <span class="n">loggamma</span><span class="p">(</span><span class="o">-</span><span class="mf">2.5</span><span class="p">)</span>
<span class="go">(1.265512123484645396488946 - 3.141592653589793238462643j)</span>
<span class="go">(0.8600470153764810145109327 - 6.283185307179586476925287j)</span>
<span class="go">(-0.05624371649767405067259453 - 9.42477796076937971538793j)</span>
</pre></div>
</div>
<p>Some special values:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="mi">1</span><span class="p">);</span> <span class="n">loggamma</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="mi">3</span><span class="p">);</span> <span class="o">+</span><span class="n">ln2</span>
<span class="go">0.6931471805599453094172321</span>
<span class="go">0.6931471805599453094172321</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="mf">3.5</span><span class="p">);</span> <span class="n">log</span><span class="p">(</span><span class="mi">15</span><span class="o">*</span><span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span><span class="mi">8</span><span class="p">)</span>
<span class="go">1.200973602347074224816022</span>
<span class="go">1.200973602347074224816022</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
</pre></div>
</div>
<p>Huge arguments are permitted:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e30'</span><span class="p">)</span>
<span class="go">6.807755278982137052053974e+31</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e300'</span><span class="p">)</span>
<span class="go">6.897755278982137052053974e+302</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e3000'</span><span class="p">)</span>
<span class="go">6.906755278982137052053974e+3003</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e100000000000000000000'</span><span class="p">)</span>
<span class="go">2.302585092994045684007991e+100000000000000000020</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e30j'</span><span class="p">)</span>
<span class="go">(-1.570796326794896619231322e+30 + 6.807755278982137052053974e+31j)</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e300j'</span><span class="p">)</span>
<span class="go">(-1.570796326794896619231322e+300 + 6.897755278982137052053974e+302j)</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="s">'1e3000j'</span><span class="p">)</span>
<span class="go">(-1.570796326794896619231322e+3000 + 6.906755278982137052053974e+3003j)</span>
</pre></div>
</div>
<p>The log-gamma function can be integrated analytically
on any interval of unit length:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="mi">0</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="n">loggamma</span><span class="p">,</span> <span class="p">[</span><span class="n">z</span><span class="p">,</span><span class="n">z</span><span class="o">+</span><span class="mi">1</span><span class="p">]);</span> <span class="n">log</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="go">0.9189385332046727417803297</span>
<span class="go">0.9189385332046727417803297</span>
<span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="mi">3</span><span class="o">+</span><span class="mi">4</span><span class="n">j</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="n">loggamma</span><span class="p">,</span> <span class="p">[</span><span class="n">z</span><span class="p">,</span><span class="n">z</span><span class="o">+</span><span class="mi">1</span><span class="p">]);</span> <span class="p">(</span><span class="n">log</span><span class="p">(</span><span class="n">z</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">*</span><span class="n">z</span> <span class="o">+</span> <span class="n">log</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="go">(-0.9619286014994750641314421 + 5.219637303741238195688575j)</span>
<span class="go">(-0.9619286014994750641314421 + 5.219637303741238195688575j)</span>
</pre></div>
</div>
<p>The derivatives of the log-gamma function are given by the
polygamma function (<a title="mpmath.psi" class="reference internal" href="#mpmath.psi"><tt class="xref docutils literal"><span class="pre">psi()</span></tt></a>):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">loggamma</span><span class="p">,</span> <span class="o">-</span><span class="mi">4</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">);</span> <span class="n">psi</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">4</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="go">(1.688493531222971393607153 + 2.554898911356806978892748j)</span>
<span class="go">(1.688493531222971393607153 + 2.554898911356806978892748j)</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">loggamma</span><span class="p">,</span> <span class="o">-</span><span class="mi">4</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span> <span class="n">psi</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">4</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="go">(-0.1539414829219882371561038 - 0.1020485197430267719746479j)</span>
<span class="go">(-0.1539414829219882371561038 - 0.1020485197430267719746479j)</span>
</pre></div>
</div>
<p>The log-gamma function satisfies an additive form of the
recurrence relation for the ordinary gamma function:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span>
<span class="gp">>>> </span><span class="n">loggamma</span><span class="p">(</span><span class="n">z</span><span class="p">);</span> <span class="n">loggamma</span><span class="p">(</span><span class="n">z</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span> <span class="o">-</span> <span class="n">log</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
<span class="go">(-2.092851753092733349564189 + 2.302396543466867626153708j)</span>
<span class="go">(-2.092851753092733349564189 + 2.302396543466867626153708j)</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="rising-and-falling-factorials">
<h2>Rising and falling factorials<a class="headerlink" href="#rising-and-falling-factorials" title="Permalink to this headline">¶</a></h2>
<div class="section" id="rf">
<h3><tt class="xref docutils literal"><span class="pre">rf()</span></tt><a class="headerlink" href="#rf" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.rf">
<tt class="descclassname">mpmath.</tt><tt class="descname">rf</tt><big>(</big><em>x</em>, <em>n</em><big>)</big><a class="headerlink" href="#mpmath.rf" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the rising factorial or Pochhammer symbol,</p>
<div class="math">
<p><img src="../_images/math/67f964a13dedf170f54b782c302fb461137c0bd5.png" alt="x^{(n)} = x (x+1) \cdots (x+n-1) = \frac{\Gamma(x+n)}{\Gamma(x)}" /></p>
</div><p>where the rightmost expression is valid for nonintegral <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>.</p>
<p><strong>Examples</strong></p>
<p>For integral <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>, the rising factorial is a polynomial:</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="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">5</span><span class="p">):</span>
<span class="gp">... </span> <span class="n">nprint</span><span class="p">(</span><span class="n">taylor</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">rf</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">n</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="n">n</span><span class="p">))</span>
<span class="gp">...</span>
<span class="go">[1.0]</span>
<span class="go">[0.0, 1.0]</span>
<span class="go">[0.0, 1.0, 1.0]</span>
<span class="go">[0.0, 2.0, 3.0, 1.0]</span>
<span class="go">[0.0, 6.0, 11.0, 6.0, 1.0]</span>
</pre></div>
</div>
<p>Evaluation is supported for arbitrary arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">rf</span><span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">,</span> <span class="mf">5.5</span><span class="p">)</span>
<span class="go">(-7202.03920483347 - 3777.58810701527j)</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="ff">
<h3><tt class="xref docutils literal"><span class="pre">ff()</span></tt><a class="headerlink" href="#ff" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.ff">
<tt class="descclassname">mpmath.</tt><tt class="descname">ff</tt><big>(</big><em>x</em>, <em>n</em><big>)</big><a class="headerlink" href="#mpmath.ff" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the falling factorial,</p>
<div class="math">
<p><img src="../_images/math/7b3b0d6b0118a1fd50e3b2a90eb58ec78b475afc.png" alt="(x)_n = x (x-1) \cdots (x-n+1) = \frac{\Gamma(x+1)}{\Gamma(x-n+1)}" /></p>
</div><p>where the rightmost expression is valid for nonintegral <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>.</p>
<p><strong>Examples</strong></p>
<p>For integral <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>, the falling factorial is a polynomial:</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="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">5</span><span class="p">):</span>
<span class="gp">... </span> <span class="n">nprint</span><span class="p">(</span><span class="n">taylor</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">ff</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">n</span><span class="p">),</span> <span class="mi">0</span><span class="p">,</span> <span class="n">n</span><span class="p">))</span>
<span class="gp">...</span>
<span class="go">[1.0]</span>
<span class="go">[0.0, 1.0]</span>
<span class="go">[0.0, -1.0, 1.0]</span>
<span class="go">[0.0, 2.0, -3.0, 1.0]</span>
<span class="go">[0.0, -6.0, 11.0, -6.0, 1.0]</span>
</pre></div>
</div>
<p>Evaluation is supported for arbitrary arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">ff</span><span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">,</span> <span class="mf">5.5</span><span class="p">)</span>
<span class="go">(-720.41085888203 + 316.101124983878j)</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="beta-function">
<h2>Beta function<a class="headerlink" href="#beta-function" title="Permalink to this headline">¶</a></h2>
<div class="section" id="beta">
<h3><tt class="xref docutils literal"><span class="pre">beta()</span></tt><a class="headerlink" href="#beta" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.beta">
<tt class="descclassname">mpmath.</tt><tt class="descname">beta</tt><big>(</big><em>x</em>, <em>y</em><big>)</big><a class="headerlink" href="#mpmath.beta" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the beta function,
<img class="math" src="../_images/math/d581222c803b0c037007450dad532ee5d2d87fea.png" alt="B(x,y) = \Gamma(x) \Gamma(y) / \Gamma(x+y)"/>.
The beta function is also commonly defined by the integral
representation</p>
<div class="math">
<p><img src="../_images/math/ea5243c07eaa244439559c98f772d752a72aeaad.png" alt="B(x,y) = \int_0^1 t^{x-1} (1-t)^{y-1} \, dt" /></p>
</div><p><strong>Examples</strong></p>
<p>For integer and half-integer arguments where all three gamma
functions are finite, the beta function becomes either rational
number or a rational multiple of <img class="math" src="../_images/math/f2ca003a7da0de4994b4733e203b74ff52d42553.png" alt="\pi"/>:</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">beta</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">0.0333333333333333</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="mf">1.5</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">0.266666666666667</span>
<span class="gp">>>> </span><span class="mi">16</span><span class="o">*</span><span class="n">beta</span><span class="p">(</span><span class="mf">2.5</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">)</span>
<span class="go">3.14159265358979</span>
</pre></div>
</div>
<p>Where appropriate, <a title="mpmath.beta" class="reference internal" href="#mpmath.beta"><tt class="xref docutils literal"><span class="pre">beta()</span></tt></a> evaluates limits. A pole
of the beta function is taken to result in <tt class="docutils literal"><span class="pre">+inf</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="o">-</span><span class="mf">0.5</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">-0.333333333333333</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">+inf</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="n">inf</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">beta</span><span class="p">(</span><span class="n">inf</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">nan</span>
</pre></div>
</div>
<p><a title="mpmath.beta" class="reference internal" href="#mpmath.beta"><tt class="xref docutils literal"><span class="pre">beta()</span></tt></a> supports complex numbers and arbitrary precision
evaluation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="mi">1</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">(0.4 - 0.2j)</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">beta</span><span class="p">(</span><span class="n">j</span><span class="p">,</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">(1.079424249270925780135675 - 1.410032405664160838288752j)</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">50</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="n">pi</span><span class="p">,</span> <span class="n">e</span><span class="p">)</span>
<span class="go">0.037890298781212201348153837138927165984170287886464</span>
</pre></div>
</div>
<p>Various integrals can be computed by means of the
beta 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">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">t</span><span class="o">**</span><span class="mf">2.5</span><span class="o">*</span><span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">t</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span><span class="p">,</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">0.0230880230880231</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="mf">3.5</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">0.0230880230880231</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">sin</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">**</span><span class="mi">4</span> <span class="o">*</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">cos</span><span class="p">(</span><span class="n">t</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.319504062596158</span>
<span class="gp">>>> </span><span class="n">beta</span><span class="p">(</span><span class="mf">2.5</span><span class="p">,</span> <span class="mf">0.75</span><span class="p">)</span><span class="o">/</span><span class="mi">2</span>
<span class="go">0.319504062596158</span>
</pre></div>
</div>
</dd></dl>
</div>
<div class="section" id="betainc">
<h3><tt class="xref docutils literal"><span class="pre">betainc()</span></tt><a class="headerlink" href="#betainc" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.betainc">
<tt class="descclassname">mpmath.</tt><tt class="descname">betainc</tt><big>(</big><em>a</em>, <em>b</em>, <em>x1=0</em>, <em>x2=1</em>, <em>regularized=False</em><big>)</big><a class="headerlink" href="#mpmath.betainc" title="Permalink to this definition">¶</a></dt>
<dd><p><tt class="docutils literal"><span class="pre">betainc(a,</span> <span class="pre">b,</span> <span class="pre">x1=0,</span> <span class="pre">x2=1,</span> <span class="pre">regularized=False)</span></tt> gives the generalized
incomplete beta function,</p>
<div class="math">
<p><img src="../_images/math/56b59a35bb071840738a9c2ad27fc5279d33c099.png" alt="I_{x_1}^{x_2}(a,b) = \int_{x_1}^{x_2} t^{a-1} (1-t)^{b-1} dt." /></p>
</div><p>When <img class="math" src="../_images/math/916c3c50ce6e1b060e76035eb005a42bf34e25b9.png" alt="x_1 = 0, x_2 = 1"/>, this reduces to the ordinary (complete)
beta function <img class="math" src="../_images/math/1cf8ee743e58a5766b20106b9d3d4b023c2d6bee.png" alt="B(a,b)"/>; see <a title="mpmath.beta" class="reference internal" href="#mpmath.beta"><tt class="xref docutils literal"><span class="pre">beta()</span></tt></a>.</p>
<p>With the keyword argument <tt class="docutils literal"><span class="pre">regularized=True</span></tt>, <a title="mpmath.betainc" class="reference internal" href="#mpmath.betainc"><tt class="xref docutils literal"><span class="pre">betainc()</span></tt></a>
computes the regularized incomplete beta function
<img class="math" src="../_images/math/e67b0e54be60f8dd1bea7f4ac0e84a083fb2d909.png" alt="I_{x_1}^{x_2}(a,b) / B(a,b)"/>. This is the cumulative distribution of the
beta distribution with parameters <img class="math" src="../_images/math/c7d457e388298246adb06c587bccd419ea67f7e8.png" alt="a"/>, <img class="math" src="../_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/>.</p>
<p><strong>Examples</strong></p>
<p>Verifying that <a title="mpmath.betainc" class="reference internal" href="#mpmath.betainc"><tt class="xref docutils literal"><span class="pre">betainc()</span></tt></a> computes the integral in the
definition:</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">x</span><span class="p">,</span><span class="n">y</span><span class="p">,</span><span class="n">a</span><span class="p">,</span><span class="n">b</span> <span class="o">=</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">6</span>
<span class="gp">>>> </span><span class="n">betainc</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</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">-4010.4</span>
<span class="gp">>>> </span><span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">t</span><span class="o">**</span><span class="p">(</span><span class="n">x</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">t</span><span class="p">)</span><span class="o">**</span><span class="p">(</span><span class="n">y</span><span class="o">-</span><span class="mi">1</span><span class="p">),</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">-4010.4</span>
</pre></div>
</div>
<p>The arguments may be arbitrary complex numbers:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">betainc</span><span class="p">(</span><span class="mf">0.75</span><span class="p">,</span> <span class="mi">1</span><span class="o">-</span><span class="mi">4</span><span class="n">j</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.2241657956955709603655887 + 0.3619619242700451992411724j)</span>
</pre></div>
</div>
<p>With regularization:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">betainc</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="mi">0</span><span class="p">,</span> <span class="mf">0.25</span><span class="p">,</span> <span class="n">regularized</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
<span class="go">0.4375</span>
<span class="gp">>>> </span><span class="n">betainc</span><span class="p">(</span><span class="n">pi</span><span class="p">,</span> <span class="n">e</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">regularized</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span> <span class="c"># Complete</span>
<span class="go">1.0</span>
</pre></div>
</div>
<p>The beta integral satisfies some simple argument transformation
symmetries:</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">betainc</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">),</span> <span class="o">-</span><span class="n">betainc</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">),</span> <span class="n">betainc</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="mi">1</span><span class="o">-</span><span class="mi">5</span><span class="p">,</span><span class="mi">1</span><span class="o">-</span><span class="mi">4</span><span class="p">)</span>
<span class="go">(56.0833333333333, 56.0833333333333, 56.0833333333333)</span>
</pre></div>
</div>
<p>The beta integral can often be evaluated analytically. For integer and
rational arguments, the incomplete beta function typically reduces to a
simple algebraic-logarithmic expression:</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">25</span>
<span class="gp">>>> </span><span class="n">identify</span><span class="p">(</span><span class="n">chop</span><span class="p">(</span><span class="n">betainc</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)))</span>
<span class="go">'-(log((9/8)))'</span>
<span class="gp">>>> </span><span class="n">identify</span><span class="p">(</span><span class="n">betainc</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">))</span>
<span class="go">'(673/12)'</span>
<span class="gp">>>> </span><span class="n">identify</span><span class="p">(</span><span class="n">betainc</span><span class="p">(</span><span class="mf">1.5</span><span class="p">,</span> <span class="mi">1</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="go">'((-12+sqrt(1152))/18)'</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="super-and-hyperfactorials">
<h2>Super- and hyperfactorials<a class="headerlink" href="#super-and-hyperfactorials" title="Permalink to this headline">¶</a></h2>
<div class="section" id="superfac">
<h3><tt class="xref docutils literal"><span class="pre">superfac()</span></tt><a class="headerlink" href="#superfac" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.superfac">
<tt class="descclassname">mpmath.</tt><tt class="descname">superfac</tt><big>(</big><em>z</em><big>)</big><a class="headerlink" href="#mpmath.superfac" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the superfactorial, defined as the product of
consecutive factorials</p>
<div class="math">
<p><img src="../_images/math/0f114b1c06ffaa0decb1a4b6d92652c6105f1a12.png" alt="\mathrm{sf}(n) = \prod_{k=1}^n k!" /></p>
</div><p>For general complex <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>, <img class="math" src="../_images/math/33d6454118973a91f8ac36a7fa6ff615d84d6208.png" alt="\mathrm{sf}(z)"/> is defined
in terms of the Barnes G-function (see <a title="mpmath.barnesg" class="reference internal" href="#mpmath.barnesg"><tt class="xref docutils literal"><span class="pre">barnesg()</span></tt></a>).</p>
<p><strong>Examples</strong></p>
<p>The first few superfactorials are (OEIS A000178):</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="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">10</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">n</span><span class="p">,</span> <span class="n">superfac</span><span class="p">(</span><span class="n">n</span><span class="p">)))</span>
<span class="gp">...</span>
<span class="go">0 1.0</span>
<span class="go">1 1.0</span>
<span class="go">2 2.0</span>
<span class="go">3 12.0</span>
<span class="go">4 288.0</span>
<span class="go">5 34560.0</span>
<span class="go">6 24883200.0</span>
<span class="go">7 125411328000.0</span>
<span class="go">8 5.05658474496e+15</span>
<span class="go">9 1.83493347225108e+21</span>
</pre></div>
</div>
<p>Superfactorials grow very rapidly:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">superfac</span><span class="p">(</span><span class="mi">1000</span><span class="p">)</span>
<span class="go">3.24570818422368e+1177245</span>
<span class="gp">>>> </span><span class="n">superfac</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">2.61398543581249e+467427913956904067453</span>
</pre></div>
</div>
<p>Evaluation is supported for arbitrary arguments:</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">25</span>
<span class="gp">>>> </span><span class="n">superfac</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">17.20051550121297985285333</span>
<span class="gp">>>> </span><span class="n">superfac</span><span class="p">(</span><span class="mi">2</span><span class="o">+</span><span class="mi">3</span><span class="n">j</span><span class="p">)</span>
<span class="go">(-0.005915485633199789627466468 + 0.008156449464604044948738263j)</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">superfac</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">0.2645072034016070205673056</span>
</pre></div>
</div>
<p><strong>References</strong></p>
<ol class="arabic simple">
<li><a class="reference external" href="http://www.research.att.com/~njas/sequences/A000178">http://www.research.att.com/~njas/sequences/A000178</a></li>
</ol>
</dd></dl>
</div>
<div class="section" id="hyperfac">
<h3><tt class="xref docutils literal"><span class="pre">hyperfac()</span></tt><a class="headerlink" href="#hyperfac" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.hyperfac">
<tt class="descclassname">mpmath.</tt><tt class="descname">hyperfac</tt><big>(</big><em>z</em><big>)</big><a class="headerlink" href="#mpmath.hyperfac" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the hyperfactorial, defined for integers as the product</p>
<div class="math">
<p><img src="../_images/math/7c9e270249c95be726fb6edea3abd3553f3e36f9.png" alt="H(n) = \prod_{k=1}^n k^k." /></p>
</div><p>The hyperfactorial satisfies the recurrence formula <img class="math" src="../_images/math/c9c6eca4808acb529f92e91b9b95feef1f29a3a6.png" alt="H(z) = z^z H(z-1)"/>.
It can be defined more generally in terms of the Barnes G-function (see
<a title="mpmath.barnesg" class="reference internal" href="#mpmath.barnesg"><tt class="xref docutils literal"><span class="pre">barnesg()</span></tt></a>) and the gamma function by the formula</p>
<div class="math">
<p><img src="../_images/math/c78c3d470b9110d6f199b46a2a0739054755396e.png" alt="H(z) = \frac{\Gamma(z+1)^z}{G(z)}." /></p>
</div><p>The extension to complex numbers can also be done via
the integral representation</p>
<div class="math">
<p><img src="../_images/math/546fb9b9da21882bfc994bb92af6382fe0b09208.png" alt="H(z) = (2\pi)^{-z/2} \exp \left[
{z+1 \choose 2} + \int_0^z \log(t!)\,dt
\right]." /></p>
</div><p><strong>Examples</strong></p>
<p>The rapidly-growing sequence of hyperfactorials begins
(OEIS A002109):</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="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">10</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">n</span><span class="p">,</span> <span class="n">hyperfac</span><span class="p">(</span><span class="n">n</span><span class="p">)))</span>
<span class="gp">...</span>
<span class="go">0 1.0</span>
<span class="go">1 1.0</span>
<span class="go">2 4.0</span>
<span class="go">3 108.0</span>
<span class="go">4 27648.0</span>
<span class="go">5 86400000.0</span>
<span class="go">6 4031078400000.0</span>
<span class="go">7 3.3197663987712e+18</span>
<span class="go">8 5.56964379417266e+25</span>
<span class="go">9 2.15779412229419e+34</span>
</pre></div>
</div>
<p>Some even larger hyperfactorials are:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="mi">1000</span><span class="p">)</span>
<span class="go">5.46458120882585e+1392926</span>
<span class="gp">>>> </span><span class="n">hyperfac</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">4.60408207642219e+489142638002418704309</span>
</pre></div>
</div>
<p>The hyperfactorial can be evaluated for arbitrary arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">0.880449235173423</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">hyperfac</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">0.581061466795327</span>
<span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">205.211134637462</span>
<span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="o">+</span><span class="mi">1</span><span class="n">j</span><span class="p">)</span>
<span class="go">(3.01144471378225e+46 - 2.45285242480185e+46j)</span>
</pre></div>
</div>
<p>The recurrence property of the hyperfactorial holds
generally:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="mi">3</span><span class="o">-</span><span class="mi">4</span><span class="o">*</span><span class="n">j</span>
<span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
<span class="go">(-4.49795891462086e-7 - 6.33262283196162e-7j)</span>
<span class="gp">>>> </span><span class="n">z</span><span class="o">**</span><span class="n">z</span> <span class="o">*</span> <span class="n">hyperfac</span><span class="p">(</span><span class="n">z</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">(-4.49795891462086e-7 - 6.33262283196162e-7j)</span>
<span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="n">mpf</span><span class="p">(</span><span class="o">-</span><span class="mf">0.6</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">z</span><span class="o">**</span><span class="n">z</span> <span class="o">*</span> <span class="n">hyperfac</span><span class="p">(</span><span class="n">z</span><span class="o">-</span><span class="mi">1</span><span class="p">))</span>
<span class="go">1.28170142849352</span>
<span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
<span class="go">1.28170142849352</span>
</pre></div>
</div>
<p>The hyperfactorial may also be computed using the integral
definition:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="mf">2.5</span>
<span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
<span class="go">15.9842119922237</span>
<span class="gp">>>> </span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span><span class="o">**</span><span class="p">(</span><span class="o">-</span><span class="n">z</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span><span class="o">*</span><span class="n">exp</span><span class="p">(</span><span class="n">binomial</span><span class="p">(</span><span class="n">z</span><span class="o">+</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span>
<span class="gp">... </span> <span class="n">quad</span><span class="p">(</span><span class="k">lambda</span> <span class="n">t</span><span class="p">:</span> <span class="n">loggamma</span><span class="p">(</span><span class="n">t</span><span class="o">+</span><span class="mi">1</span><span class="p">),</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">z</span><span class="p">]))</span>
<span class="go">15.9842119922237</span>
</pre></div>
</div>
<p><a title="mpmath.hyperfac" class="reference internal" href="#mpmath.hyperfac"><tt class="xref docutils literal"><span class="pre">hyperfac()</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">hyperfac</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="go">215779412229418562091680268288000000000000000.0</span>
<span class="gp">>>> </span><span class="n">hyperfac</span><span class="p">(</span><span class="mi">1</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">0.89404818005227001975423476035729076375705084390942</span>
</pre></div>
</div>
<p><strong>References</strong></p>
<ol class="arabic simple">
<li><a class="reference external" href="http://www.research.att.com/~njas/sequences/A002109">http://www.research.att.com/~njas/sequences/A002109</a></li>
<li><a class="reference external" href="http://mathworld.wolfram.com/Hyperfactorial.html">http://mathworld.wolfram.com/Hyperfactorial.html</a></li>
</ol>
</dd></dl>
</div>
<div class="section" id="barnesg">
<h3><tt class="xref docutils literal"><span class="pre">barnesg()</span></tt><a class="headerlink" href="#barnesg" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.barnesg">
<tt class="descclassname">mpmath.</tt><tt class="descname">barnesg</tt><big>(</big><em>z</em><big>)</big><a class="headerlink" href="#mpmath.barnesg" title="Permalink to this definition">¶</a></dt>
<dd><p>Evaluates the Barnes G-function, which generalizes the
superfactorial (<a title="mpmath.superfac" class="reference internal" href="#mpmath.superfac"><tt class="xref docutils literal"><span class="pre">superfac()</span></tt></a>) and by extension also the
hyperfactorial (<a title="mpmath.hyperfac" class="reference internal" href="#mpmath.hyperfac"><tt class="xref docutils literal"><span class="pre">hyperfac()</span></tt></a>) to the complex numbers
in an analogous way to how the gamma function generalizes
the ordinary factorial.</p>
<p>The Barnes G-function may be defined in terms of a Weierstrass
product:</p>
<div class="math">
<p><img src="../_images/math/8c974f0596f88097153c84389f9ce366596aa1a7.png" alt="G(z+1) = (2\pi)^{z/2} e^{-[z(z+1)+\gamma z^2]/2}
\prod_{n=1}^\infty
\left[\left(1+\frac{z}{n}\right)^ne^{-z+z^2/(2n)}\right]" /></p>
</div><p>For positive integers <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>, we have have relation to superfactorials
<img class="math" src="../_images/math/e8bc150856b06ba1d7bebe0dd540c1f2492076be.png" alt="G(n) = \mathrm{sf}(n-2) = 0! \cdot 1! \cdots (n-2)!"/>.</p>
<p><strong>Examples</strong></p>
<p>Some elementary values and limits of the Barnes G-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">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">barnesg</span><span class="p">(</span><span class="mi">1</span><span class="p">),</span> <span class="n">barnesg</span><span class="p">(</span><span class="mi">2</span><span class="p">),</span> <span class="n">barnesg</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">(1.0, 1.0, 1.0)</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">2.0</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">12.0</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">6</span><span class="p">)</span>
<span class="go">288.0</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">7</span><span class="p">)</span>
<span class="go">34560.0</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span>
<span class="go">24883200.0</span>
<span class="gp">>>> </span><span class="n">barnesg</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">barnesg</span><span class="p">(</span><span class="mi">0</span><span class="p">),</span> <span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span> <span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="mi">2</span><span class="p">)</span>
<span class="go">(0.0, 0.0, 0.0)</span>
</pre></div>
</div>
<p>Closed-form values are known for some rational arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="s">'1/2'</span><span class="p">)</span>
<span class="go">0.603244281209446</span>
<span class="gp">>>> </span><span class="n">sqrt</span><span class="p">(</span><span class="n">exp</span><span class="p">(</span><span class="mf">0.25</span><span class="o">+</span><span class="n">log</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span><span class="o">/</span><span class="mi">12</span><span class="p">)</span><span class="o">/</span><span class="n">sqrt</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span><span class="n">glaisher</span><span class="o">**</span><span class="mi">3</span><span class="p">)</span>
<span class="go">0.603244281209446</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="s">'1/4'</span><span class="p">)</span>
<span class="go">0.29375596533861</span>
<span class="gp">>>> </span><span class="n">nthroot</span><span class="p">(</span><span class="n">exp</span><span class="p">(</span><span class="s">'3/8'</span><span class="p">)</span><span class="o">/</span><span class="n">exp</span><span class="p">(</span><span class="n">catalan</span><span class="o">/</span><span class="n">pi</span><span class="p">)</span><span class="o">/</span>
<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="o">**</span><span class="mi">3</span><span class="o">/</span><span class="n">sqrt</span><span class="p">(</span><span class="n">glaisher</span><span class="p">)</span><span class="o">**</span><span class="mi">9</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">0.29375596533861</span>
</pre></div>
</div>
<p>The Barnes G-function satisfies the functional equation
<img class="math" src="../_images/math/4c024189ae474f5542591d00f30357a8b14f896c.png" alt="G(z+1) = \Gamma(z) G(z)"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="n">pi</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="n">z</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
<span class="go">2.39292119327948</span>
<span class="gp">>>> </span><span class="n">gamma</span><span class="p">(</span><span class="n">z</span><span class="p">)</span><span class="o">*</span><span class="n">barnesg</span><span class="p">(</span><span class="n">z</span><span class="p">)</span>
<span class="go">2.39292119327948</span>
</pre></div>
</div>
<p>The asymptotic growth rate of the Barnes G-function is related to
the Glaisher-Kinkelin constant:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">limit</span><span class="p">(</span><span class="k">lambda</span> <span class="n">n</span><span class="p">:</span> <span class="n">barnesg</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="o">/</span><span class="p">(</span><span class="n">n</span><span class="o">**</span><span class="p">(</span><span class="n">n</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="mi">2</span><span class="o">-</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">12</span><span class="p">)</span><span class="o">*</span>
<span class="gp">... </span> <span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">pi</span><span class="p">)</span><span class="o">**</span><span class="p">(</span><span class="n">n</span><span class="o">/</span><span class="mi">2</span><span class="p">)</span><span class="o">*</span><span class="n">exp</span><span class="p">(</span><span class="o">-</span><span class="mi">3</span><span class="o">*</span><span class="n">n</span><span class="o">**</span><span class="mi">2</span><span class="o">/</span><span class="mi">4</span><span class="p">)),</span> <span class="n">inf</span><span class="p">)</span>
<span class="go">0.847536694177301</span>
<span class="gp">>>> </span><span class="n">exp</span><span class="p">(</span><span class="s">'1/12'</span><span class="p">)</span><span class="o">/</span><span class="n">glaisher</span>
<span class="go">0.847536694177301</span>
</pre></div>
</div>
<p>The Barnes G-function can be differentiated in closed form:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">z</span> <span class="o">=</span> <span class="mi">3</span>
<span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="n">barnesg</span><span class="p">,</span> <span class="n">z</span><span class="p">)</span>
<span class="go">0.264507203401607</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="n">z</span><span class="p">)</span><span class="o">*</span><span class="p">((</span><span class="n">z</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span><span class="o">*</span><span class="n">psi</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="n">z</span><span class="p">)</span><span class="o">-</span><span class="n">z</span><span class="o">+</span><span class="p">(</span><span class="n">log</span><span class="p">(</span><span class="mi">2</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="o">/</span><span class="mi">2</span><span class="p">)</span>
<span class="go">0.264507203401607</span>
</pre></div>
</div>
<p>Evaluation is supported for arbitrary arguments and at arbitrary
precision:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mf">6.5</span><span class="p">)</span>
<span class="go">2548.7457695685</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="n">pi</span><span class="p">)</span>
<span class="go">0.00535976768353037</span>
<span class="gp">>>> </span><span class="n">barnesg</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">(-0.000676375932234244 - 4.42236140124728e-5j)</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">50</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">1</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">0.81305501090451340843586085064413533788206204124732</span>
<span class="gp">>>> </span><span class="n">q</span> <span class="o">=</span> <span class="n">barnesg</span><span class="p">(</span><span class="mi">10</span><span class="n">j</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">q</span><span class="o">.</span><span class="n">real</span>
<span class="go">0.000000000021852360840356557241543036724799812371995850552234</span>
<span class="gp">>>> </span><span class="n">q</span><span class="o">.</span><span class="n">imag</span>
<span class="go">-0.00000000000070035335320062304849020654215545839053210041457588</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="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">100</span><span class="p">)</span>
<span class="go">3.10361006263698e+6626</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="mi">101</span><span class="p">)</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="mf">10.5</span><span class="p">)</span>
<span class="go">5.94463017605008e+25</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="mf">10000.5</span><span class="p">)</span>
<span class="go">-6.14322868174828e+167480422</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="mi">1000</span><span class="n">j</span><span class="p">)</span>
<span class="go">(5.21133054865546e-1173597 + 4.27461836811016e-1173597j)</span>
<span class="gp">>>> </span><span class="n">barnesg</span><span class="p">(</span><span class="o">-</span><span class="mi">1000</span><span class="o">+</span><span class="mi">1000</span><span class="n">j</span><span class="p">)</span>
<span class="go">(2.43114569750291e+1026623 + 2.24851410674842e+1026623j)</span>
</pre></div>
</div>
<p><strong>References</strong></p>
<ol class="arabic simple">
<li>Whittaker & Watson, <em>A Course of Modern Analysis</em>,
Cambridge University Press, 4th edition (1927), p.264</li>
<li><a class="reference external" href="http://en.wikipedia.org/wiki/Barnes_G-function">http://en.wikipedia.org/wiki/Barnes_G-function</a></li>
<li><a class="reference external" href="http://mathworld.wolfram.com/BarnesG-Function.html">http://mathworld.wolfram.com/BarnesG-Function.html</a></li>
</ol>
</dd></dl>
</div>
</div>
<div class="section" id="polygamma-functions-and-harmonic-numbers">
<h2>Polygamma functions and harmonic numbers<a class="headerlink" href="#polygamma-functions-and-harmonic-numbers" title="Permalink to this headline">¶</a></h2>
<div class="section" id="psi-digamma">
<h3><tt class="xref docutils literal"><span class="pre">psi()</span></tt>/<tt class="xref docutils literal"><span class="pre">digamma()</span></tt><a class="headerlink" href="#psi-digamma" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.psi">
<tt class="descclassname">mpmath.</tt><tt class="descname">psi</tt><big>(</big><em>m</em>, <em>z</em><big>)</big><a class="headerlink" href="#mpmath.psi" title="Permalink to this definition">¶</a></dt>
<dd><p>Gives the polygamma function of order <img class="math" src="../_images/math/f5047d1e0cbb50ec208923a22cd517c55100fa7b.png" alt="m"/> of <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>, <img class="math" src="../_images/math/380f1b9dc8f1c6d2262593059d498d407e8a4327.png" alt="\psi^{(m)}(z)"/>.
Special cases are known as the <em>digamma function</em> (<img class="math" src="../_images/math/2c6b796723fa215727ba5de0470faf9a5d568eab.png" alt="\psi^{(0)}(z)"/>),
the <em>trigamma function</em> (<img class="math" src="../_images/math/aacf591d0489a2375bfcb346d47b5bee410ec7ca.png" alt="\psi^{(1)}(z)"/>), etc. The polygamma
functions are defined as the logarithmic derivatives of the gamma
function:</p>
<div class="math">
<p><img src="../_images/math/a2be5745437e13871396118829631608e3379bd7.png" alt="\psi^{(m)}(z) = \left(\frac{d}{dz}\right)^{m+1} \log \Gamma(z)" /></p>
</div><p>In particular, <img class="math" src="../_images/math/03436bc0b10eee4ddfec3cecd03854f41c968103.png" alt="\psi^{(0)}(z) = \Gamma'(z)/\Gamma(z)"/>. In the
present implementation of <a title="mpmath.psi" class="reference internal" href="#mpmath.psi"><tt class="xref docutils literal"><span class="pre">psi()</span></tt></a>, the order <img class="math" src="../_images/math/f5047d1e0cbb50ec208923a22cd517c55100fa7b.png" alt="m"/> must be a
nonnegative integer, while the argument <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/> may be an arbitrary
complex number (with exception for the polygamma function’s poles
at <img class="math" src="../_images/math/ce90a96c015fb3135d2870b05a853b3c1196f46d.png" alt="z = 0, -1, -2, \ldots"/>).</p>
<p><strong>Examples</strong></p>
<p>For various rational arguments, the polygamma function reduces to
a combination of standard mathematical constants:</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">psi</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="o">-</span><span class="n">euler</span>
<span class="go">(-0.5772156649015328606065121, -0.5772156649015328606065121)</span>
<span class="gp">>>> </span><span class="n">psi</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s">'1/4'</span><span class="p">),</span> <span class="n">pi</span><span class="o">**</span><span class="mi">2</span><span class="o">+</span><span class="mi">8</span><span class="o">*</span><span class="n">catalan</span>
<span class="go">(17.19732915450711073927132, 17.19732915450711073927132)</span>
<span class="gp">>>> </span><span class="n">psi</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="s">'1/2'</span><span class="p">),</span> <span class="o">-</span><span class="mi">14</span><span class="o">*</span><span class="n">apery</span>
<span class="go">(-16.82879664423431999559633, -16.82879664423431999559633)</span>
</pre></div>
</div>
<p>The polygamma functions are derivatives of each other:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">diff</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">psi</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="n">x</span><span class="p">),</span> <span class="n">pi</span><span class="p">),</span> <span class="n">psi</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">pi</span><span class="p">)</span>
<span class="go">(-0.1105749312578862734526952, -0.1105749312578862734526952)</span>
<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="n">psi</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="n">x</span><span class="p">),</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]),</span> <span class="n">psi</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span><span class="o">-</span><span class="n">psi</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">(-0.375, -0.375)</span>
</pre></div>
</div>
<p>The digamma function diverges logarithmically as <img class="math" src="../_images/math/7731e6f8dabfbe1c1f8e018d07cd3f107fbe0fdd.png" alt="z \to \infty"/>,
while higher orders tend to zero:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">psi</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="n">psi</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">inf</span><span class="p">),</span> <span class="n">psi</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="n">inf</span><span class="p">)</span>
<span class="go">(+inf, 0.0, 0.0)</span>
</pre></div>
</div>
<p>Evaluation for a complex argument:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">psi</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="o">-</span><span class="mi">2</span><span class="n">j</span><span class="p">)</span>
<span class="go">(0.03902435405364952654838445 + 0.1574325240413029954685366j)</span>
</pre></div>
</div>
<p>Evaluation is supported for large orders <img class="math" src="../_images/math/f5047d1e0cbb50ec208923a22cd517c55100fa7b.png" alt="m"/> and/or large
arguments <img class="math" src="../_images/math/b13f21416d84e13708696f34dea81026cda583c9.png" alt="z"/>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">psi</span><span class="p">(</span><span class="mi">3</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">2.0e-300</span>
<span class="gp">>>> </span><span class="n">psi</span><span class="p">(</span><span class="mi">250</span><span class="p">,</span> <span class="mi">10</span><span class="o">**</span><span class="mi">30</span><span class="o">+</span><span class="mi">10</span><span class="o">**</span><span class="mi">20</span><span class="o">*</span><span class="n">j</span><span class="p">)</span>
<span class="go">(-1.293142504363642687204865e-7010 + 3.232856260909107391513108e-7018j)</span>
</pre></div>
</div>
<p><strong>Application to infinite series</strong></p>
<p>Any infinite series where the summand is a rational function of
the index <img class="math" src="../_images/math/8c325612684d41304b9751c175df7bcc0f61f64f.png" alt="k"/> can be evaluated in closed form in terms of polygamma
functions of the roots and poles of the summand:</p>
<div class="highlight-python"><div class="highlight"><pre><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">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">b</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="n">nsum</span><span class="p">(</span><span class="k">lambda</span> <span class="n">k</span><span class="p">:</span> <span class="mi">1</span><span class="o">/</span><span class="p">((</span><span class="n">k</span><span class="o">+</span><span class="n">a</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">k</span><span class="o">+</span><span class="n">b</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.4049668927517857061917531</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">psi</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="n">a</span><span class="p">)</span><span class="o">-</span><span class="n">psi</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="n">b</span><span class="p">)</span><span class="o">-</span><span class="n">a</span><span class="o">*</span><span class="n">psi</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">a</span><span class="p">)</span><span class="o">+</span><span class="n">b</span><span class="o">*</span><span class="n">psi</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">a</span><span class="p">))</span><span class="o">/</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">0.4049668927517857061917531</span>
</pre></div>
</div>
<p>This follows from the series representation (<img class="math" src="../_images/math/1d4f05dbfb8deab8d418a36643fded9383c604eb.png" alt="m > 0"/>)</p>
<div class="math">
<p><img src="../_images/math/ca9016f3372743eafd7ded23526f4cb86f9991a8.png" alt="\psi^{(m)}(z) = (-1)^{m+1} m! \sum_{k=0}^{\infty}
\frac{1}{(z+k)^{m+1}}." /></p>
</div><p>Since the roots of a polynomial may be complex, it is sometimes
necessary to use the complex polygamma function to evaluate
an entirely real-valued sum:</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="mi">1</span><span class="o">/</span><span class="p">(</span><span class="n">k</span><span class="o">**</span><span class="mi">2</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">k</span><span class="o">+</span><span class="mi">3</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">1.694361433907061256154665</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">polyroots</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]))</span>
<span class="go">[(1.0 - 1.41421j), (1.0 + 1.41421j)]</span>
<span class="gp">>>> </span><span class="n">r1</span> <span class="o">=</span> <span class="mi">1</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="n">j</span>
<span class="gp">>>> </span><span class="n">r2</span> <span class="o">=</span> <span class="n">r1</span><span class="o">.</span><span class="n">conjugate</span><span class="p">()</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">psi</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="n">r2</span><span class="p">)</span><span class="o">-</span><span class="n">psi</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="n">r1</span><span class="p">))</span><span class="o">/</span><span class="p">(</span><span class="n">r1</span><span class="o">-</span><span class="n">r2</span><span class="p">)</span>
<span class="go">(1.694361433907061256154665 + 0.0j)</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.digamma">
<tt class="descclassname">mpmath.</tt><tt class="descname">digamma</tt><big>(</big><em>z</em><big>)</big><a class="headerlink" href="#mpmath.digamma" title="Permalink to this definition">¶</a></dt>
<dd>Shortcut for <tt class="docutils literal"><span class="pre">psi(0,z)</span></tt>.</dd></dl>
</div>
<div class="section" id="harmonic">
<h3><tt class="xref docutils literal"><span class="pre">harmonic()</span></tt><a class="headerlink" href="#harmonic" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.harmonic">
<tt class="descclassname">mpmath.</tt><tt class="descname">harmonic</tt><big>(</big><em>z</em><big>)</big><a class="headerlink" href="#mpmath.harmonic" title="Permalink to this definition">¶</a></dt>
<dd><p>If <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/> is an integer, <tt class="docutils literal"><span class="pre">harmonic(n)</span></tt> gives a floating-point
approximation of the <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>-th harmonic number <img class="math" src="../_images/math/58a3a829660a9f4760582b6a696c712b9a464abe.png" alt="H(n)"/>, defined as</p>
<div class="math">
<p><img src="../_images/math/306186c8a1fd38b3f7ae411184a7538561fed918.png" alt="H(n) = 1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}" /></p>
</div><p>The first few harmonic numbers are:</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="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">8</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">n</span><span class="p">,</span> <span class="n">harmonic</span><span class="p">(</span><span class="n">n</span><span class="p">)))</span>
<span class="gp">...</span>
<span class="go">0 0.0</span>
<span class="go">1 1.0</span>
<span class="go">2 1.5</span>
<span class="go">3 1.83333333333333</span>
<span class="go">4 2.08333333333333</span>
<span class="go">5 2.28333333333333</span>
<span class="go">6 2.45</span>
<span class="go">7 2.59285714285714</span>
</pre></div>
</div>
<p>The infinite harmonic series <img class="math" src="../_images/math/291e353af0258dda7e14e507fad50acb1acc36d1.png" alt="1 + 1/2 + 1/3 + \ldots"/> diverges:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">harmonic</span><span class="p">(</span><span class="n">inf</span><span class="p">)</span>
<span class="go">+inf</span>
</pre></div>
</div>
<p><a title="mpmath.harmonic" class="reference internal" href="#mpmath.harmonic"><tt class="xref docutils literal"><span class="pre">harmonic()</span></tt></a> is evaluated using the digamma function rather
than by summing the harmonic series term by term. It can therefore
be computed quickly for arbitrarily large <img class="math" src="../_images/math/174fadd07fd54c9afe288e96558c92e0c1da733a.png" alt="n"/>, and even for
nonintegral arguments:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">harmonic</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">230.835724964306</span>
<span class="gp">>>> </span><span class="n">harmonic</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">0.613705638880109</span>
<span class="gp">>>> </span><span class="n">harmonic</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">(2.24757548223494 + 0.850502209186044j)</span>
</pre></div>
</div>
<p><a title="mpmath.harmonic" class="reference internal" href="#mpmath.harmonic"><tt class="xref docutils literal"><span class="pre">harmonic()</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">harmonic</span><span class="p">(</span><span class="mi">11</span><span class="p">)</span>
<span class="go">3.0198773448773448773448773448773448773448773448773</span>
<span class="gp">>>> </span><span class="n">harmonic</span><span class="p">(</span><span class="n">pi</span><span class="p">)</span>
<span class="go">1.8727388590273302654363491032336134987519132374152</span>
</pre></div>
</div>
<p>The harmonic series diverges, but at a glacial pace. It is possible
to calculate the exact number of terms required before the sum
exceeds a given amount, say 100:</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">v</span> <span class="o">=</span> <span class="mi">10</span><span class="o">**</span><span class="n">findroot</span><span class="p">(</span><span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">harmonic</span><span class="p">(</span><span class="mi">10</span><span class="o">**</span><span class="n">x</span><span class="p">)</span> <span class="o">-</span> <span class="mi">100</span><span class="p">,</span> <span class="mi">10</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">v</span>
<span class="go">15092688622113788323693563264538101449859496.864101</span>
<span class="gp">>>> </span><span class="n">v</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">ceil</span><span class="p">(</span><span class="n">v</span><span class="p">))</span>
<span class="gp">>>> </span><span class="k">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">15092688622113788323693563264538101449859497</span>
<span class="gp">>>> </span><span class="n">harmonic</span><span class="p">(</span><span class="n">v</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">99.999999999999999999999999999999999999999999942747</span>
<span class="gp">>>> </span><span class="n">harmonic</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">100.000000000000000000000000000000000000000000009</span>
</pre></div>
</div>
</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="#">Factorials and gamma functions</a><ul>
<li><a class="reference external" href="#factorials">Factorials</a><ul>
<li><a class="reference external" href="#factorial-fac"><tt class="docutils literal"><span class="pre">factorial()</span></tt>/<tt class="docutils literal"><span class="pre">fac()</span></tt></a></li>
<li><a class="reference external" href="#fac2"><tt class="docutils literal"><span class="pre">fac2()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#binomial-coefficients">Binomial coefficients</a><ul>
<li><a class="reference external" href="#binomial"><tt class="docutils literal"><span class="pre">binomial()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#gamma-function">Gamma function</a><ul>
<li><a class="reference external" href="#gamma"><tt class="docutils literal"><span class="pre">gamma()</span></tt></a></li>
<li><a class="reference external" href="#rgamma"><tt class="docutils literal"><span class="pre">rgamma()</span></tt></a></li>
<li><a class="reference external" href="#gammaprod"><tt class="docutils literal"><span class="pre">gammaprod()</span></tt></a></li>
<li><a class="reference external" href="#loggamma"><tt class="docutils literal"><span class="pre">loggamma()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#rising-and-falling-factorials">Rising and falling factorials</a><ul>
<li><a class="reference external" href="#rf"><tt class="docutils literal"><span class="pre">rf()</span></tt></a></li>
<li><a class="reference external" href="#ff"><tt class="docutils literal"><span class="pre">ff()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#beta-function">Beta function</a><ul>
<li><a class="reference external" href="#beta"><tt class="docutils literal"><span class="pre">beta()</span></tt></a></li>
<li><a class="reference external" href="#betainc"><tt class="docutils literal"><span class="pre">betainc()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#super-and-hyperfactorials">Super- and hyperfactorials</a><ul>
<li><a class="reference external" href="#superfac"><tt class="docutils literal"><span class="pre">superfac()</span></tt></a></li>
<li><a class="reference external" href="#hyperfac"><tt class="docutils literal"><span class="pre">hyperfac()</span></tt></a></li>
<li><a class="reference external" href="#barnesg"><tt class="docutils literal"><span class="pre">barnesg()</span></tt></a></li>
</ul>
</li>
<li><a class="reference external" href="#polygamma-functions-and-harmonic-numbers">Polygamma functions and harmonic numbers</a><ul>
<li><a class="reference external" href="#psi-digamma"><tt class="docutils literal"><span class="pre">psi()</span></tt>/<tt class="docutils literal"><span class="pre">digamma()</span></tt></a></li>
<li><a class="reference external" href="#harmonic"><tt class="docutils literal"><span class="pre">harmonic()</span></tt></a></li>
</ul>
</li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="hyperbolic.html"
title="previous chapter">Hyperbolic functions</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="expintegrals.html"
title="next chapter">Exponential integrals and error functions</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../_sources/functions/gamma.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="expintegrals.html" title="Exponential integrals and error functions"
>next</a> |</li>
<li class="right" >
<a href="hyperbolic.html" title="Hyperbolic functions"
>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
>
1232
