<!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>Contexts — 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="next" title="Utility functions" href="general.html" />
<link rel="prev" title="Basic usage" href="basics.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="general.html" title="Utility functions"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="basics.html" title="Basic usage"
accesskey="P">previous</a> |</li>
<li><a href="index.html">mpmath v0.17 documentation</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="contexts">
<h1>Contexts<a class="headerlink" href="#contexts" title="Permalink to this headline">¶</a></h1>
<p>High-level code in mpmath is implemented as methods on a “context object”. The context implements arithmetic, type conversions and other fundamental operations. The context also holds settings such as precision, and stores cache data. A few different contexts (with a mostly compatible interface) are provided so that the high-level algorithms can be used with different implementations of the underlying arithmetic, allowing different features and speed-accuracy tradeoffs. Currently, mpmath provides the following contexts:</p>
<blockquote>
<ul class="simple">
<li>Arbitrary-precision arithmetic (<tt class="docutils literal"><span class="pre">mp</span></tt>)</li>
<li>A faster Cython-based version of <tt class="docutils literal"><span class="pre">mp</span></tt> (used by default in Sage, and currently only available there)</li>
<li>Arbitrary-precision interval arithmetic (<tt class="docutils literal"><span class="pre">iv</span></tt>)</li>
<li>Double-precision arithmetic using Python’s builtin <tt class="docutils literal"><span class="pre">float</span></tt> and <tt class="docutils literal"><span class="pre">complex</span></tt> types (<tt class="docutils literal"><span class="pre">fp</span></tt>)</li>
</ul>
</blockquote>
<p>Most global functions in the global mpmath namespace are actually methods of the <tt class="docutils literal"><span class="pre">mp</span></tt>
context. This fact is usually transparent to the user, but sometimes shows up in the
form of an initial parameter called “ctx” visible in the help for the function:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">import</span> <span class="nn">mpmath</span>
<span class="gp">>>> </span><span class="n">help</span><span class="p">(</span><span class="n">mpmath</span><span class="o">.</span><span class="n">fsum</span><span class="p">)</span> <span class="c"># doctest:+SKIP</span>
<span class="go">Help on method fsum in module mpmath.ctx_mp_python:</span>
<span class="go">fsum(ctx, terms, absolute=False, squared=False) method of mpmath.ctx_mp.MPContext instance</span>
<span class="go"> Calculates a sum containing a finite number of terms (for infinite</span>
<span class="go"> series, see :func:`~mpmath.nsum`). The terms will be converted to</span>
<span class="gp">...</span>
</pre></div>
</div>
<p>The following operations are equivalent:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mpmath</span><span class="o">.</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">mpmath</span><span class="o">.</span><span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="n">mpmath</span><span class="o">.</span><span class="n">fsum</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">3</span><span class="p">])</span>
<span class="go">mpf('6.0')</span>
<span class="gp">>>> </span><span class="n">mpmath</span><span class="o">.</span><span class="n">mp</span><span class="o">.</span><span class="n">fsum</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">3</span><span class="p">])</span>
<span class="go">mpf('6.0')</span>
</pre></div>
</div>
<p>The corresponding operation using the <tt class="docutils literal"><span class="pre">fp</span></tt> context:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mpmath</span><span class="o">.</span><span class="n">fp</span><span class="o">.</span><span class="n">fsum</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">3</span><span class="p">])</span>
<span class="go">6.0</span>
</pre></div>
</div>
<div class="section" id="common-interface">
<h2>Common interface<a class="headerlink" href="#common-interface" title="Permalink to this headline">¶</a></h2>
<p><tt class="docutils literal"><span class="pre">ctx.mpf</span></tt> creates a real number:</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="n">mp</span><span class="p">,</span> <span class="n">fp</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">mpf('3.0')</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">3.0</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">ctx.mpc</span></tt> creates a complex number:</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">mpc</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="go">mpc(real='2.0', imag='3.0')</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">mpc</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="go">(2+3j)</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">ctx.matrix</span></tt> creates a matrix:</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">matrix</span><span class="p">([[</span><span class="mi">1</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">1</span><span class="p">]])</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '0.0'],</span>
<span class="go"> ['0.0', '1.0']])</span>
<span class="gp">>>> </span><span class="n">_</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">mpf('1.0')</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">matrix</span><span class="p">([[</span><span class="mi">1</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">1</span><span class="p">]])</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '0.0'],</span>
<span class="go"> ['0.0', '1.0']])</span>
<span class="gp">>>> </span><span class="n">_</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>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">ctx.prec</span></tt> holds the current precision (in bits):</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">prec</span>
<span class="go">53</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">prec</span>
<span class="go">53</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">ctx.dps</span></tt> holds the current precision (in digits):</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="go">15</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">dps</span>
<span class="go">15</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">ctx.pretty</span></tt> controls whether objects should be pretty-printed automatically by <tt class="xref docutils literal"><span class="pre">repr()</span></tt>. Pretty-printing for <tt class="docutils literal"><span class="pre">mp</span></tt> numbers is disabled by default so that they can clearly be distinguished from Python numbers and so that <tt class="docutils literal"><span class="pre">eval(repr(x))</span> <span class="pre">==</span> <span class="pre">x</span></tt> works:</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">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">mpf('3.0')</span>
<span class="gp">>>> </span><span class="n">mpf</span> <span class="o">=</span> <span class="n">mp</span><span class="o">.</span><span class="n">mpf</span>
<span class="gp">>>> </span><span class="nb">eval</span><span class="p">(</span><span class="nb">repr</span><span class="p">(</span><span class="n">mp</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)))</span>
<span class="go">mpf('3.0')</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">3.0</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">matrix</span><span class="p">([[</span><span class="mi">1</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">1</span><span class="p">]])</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '0.0'],</span>
<span class="go"> ['0.0', '1.0']])</span>
<span class="gp">>>> </span><span class="n">fp</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">fp</span><span class="o">.</span><span class="n">matrix</span><span class="p">([[</span><span class="mi">1</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">1</span><span class="p">]])</span>
<span class="go">[1.0 0.0]</span>
<span class="go">[0.0 1.0]</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
</pre></div>
</div>
</div>
<div class="section" id="arbitrary-precision-floating-point-mp">
<h2>Arbitrary-precision floating-point (<tt class="docutils literal"><span class="pre">mp</span></tt>)<a class="headerlink" href="#arbitrary-precision-floating-point-mp" title="Permalink to this headline">¶</a></h2>
<p>The <tt class="docutils literal"><span class="pre">mp</span></tt> context is what most users probably want to use most of the time, as it supports the most functions, is most well-tested, and is implemented with a high level of optimization. Nearly all examples in this documentation use <tt class="docutils literal"><span class="pre">mp</span></tt> functions.</p>
<p>See <a class="reference external" href="basics.html"><em>Basic usage</em></a> for a description of basic usage.</p>
</div>
<div class="section" id="arbitrary-precision-interval-arithmetic-iv">
<h2>Arbitrary-precision interval arithmetic (<tt class="docutils literal"><span class="pre">iv</span></tt>)<a class="headerlink" href="#arbitrary-precision-interval-arithmetic-iv" title="Permalink to this headline">¶</a></h2>
<p>The <tt class="docutils literal"><span class="pre">iv.mpf</span></tt> type represents a closed interval <img class="math" src="_images/math/8ecbd1ba3da8f2adef66a63f2ab32c47e63fa734.png" alt="[a,b]"/>; that is, the set <img class="math" src="_images/math/e4a4a489c99fd9377c7eebccabbc85922679f927.png" alt="\{x : a \le x \le b\}"/>, where <img class="math" src="_images/math/c7d457e388298246adb06c587bccd419ea67f7e8.png" alt="a"/> and <img class="math" src="_images/math/8136a7ef6a03334a7246df9097e5bcc31ba33fd2.png" alt="b"/> are arbitrary-precision floating-point values, possibly <img class="math" src="_images/math/0852124cd026a4c2e9855265258fc4b1168f6564.png" alt="\pm \infty"/>. The <tt class="docutils literal"><span class="pre">iv.mpc</span></tt> type represents a rectangular complex interval <img class="math" src="_images/math/2555bb5b70e9fd0c7888335e9251c6320531a551.png" alt="[a,b] + [c,d]i"/>; that is, the set <img class="math" src="_images/math/bd1e7977bd0c1361d1442b9f66ddd7dc9f7ba181.png" alt="\{z = x+iy : a \le x \le b \land c \le y \le d\}"/>.</p>
<p>Interval arithmetic provides rigorous error tracking. If <img class="math" src="_images/math/bb2c93730dbb48558bb3c4738c956c4e8f816437.png" alt="f"/> is a mathematical function and <img class="math" src="_images/math/5fb9731761a5f0e702bedacf9d632f8170597804.png" alt="\hat f"/> is its interval arithmetic version, then the basic guarantee of interval arithmetic is that <img class="math" src="_images/math/b231c80a5bbcf12edfeb9df1d8d9f23bd5aa1559.png" alt="f(v) \subseteq \hat f(v)"/> for any input interval <img class="math" src="_images/math/a9f23bf124b6b2b2a993eb313c72e678664ac74a.png" alt="v"/>. Put differently, if an interval represents the known uncertainty for a fixed number, any sequence of interval operations will produce an interval that contains what would be the result of applying the same sequence of operations to the exact number. The principal drawbacks of interval arithmetic are speed (<tt class="docutils literal"><span class="pre">iv</span></tt> arithmetic is typically at least two times slower than <tt class="docutils literal"><span class="pre">mp</span></tt> arithmetic) and that it sometimes provides far too pessimistic bounds.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">The support for interval arithmetic in mpmath is still experimental, and many functions
do not yet properly support intervals. Please use this feature with caution.</p>
</div>
<p>Intervals can be created from single numbers (treated as zero-width intervals) or pairs of endpoint numbers. Strings are treated as exact decimal numbers. Note that a Python float like <tt class="docutils literal"><span class="pre">0.1</span></tt> generally does not represent the same number as its literal; use <tt class="docutils literal"><span class="pre">'0.1'</span></tt> instead:</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="n">iv</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">iv</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">mpi('3.0', '3.0')</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">[3.0, 3.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</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="go">[2.0, 3.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mf">0.1</span><span class="p">)</span> <span class="c"># probably not intended</span>
<span class="go">[0.10000000000000000555, 0.10000000000000000555]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="s">'0.1'</span><span class="p">)</span> <span class="c"># good, gives a containing interval</span>
<span class="go">[0.099999999999999991673, 0.10000000000000000555]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="s">'0.1'</span><span class="p">,</span> <span class="s">'0.2'</span><span class="p">])</span>
<span class="go">[0.099999999999999991673, 0.2000000000000000111]</span>
</pre></div>
</div>
<p>The fact that <tt class="docutils literal"><span class="pre">'0.1'</span></tt> results in an interval of nonzero width indicates that 1/10 cannot be represented using binary floating-point numbers at this precision level (in fact, it cannot be represented exactly at any precision).</p>
<p>Intervals may be infinite or half-infinite:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="mi">1</span> <span class="o">/</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span> <span class="s">'inf'</span><span class="p">])</span>
<span class="go">[0.0, 0.5]</span>
</pre></div>
</div>
<p>The equality testing operators <tt class="docutils literal"><span class="pre">==</span></tt> and <tt class="docutils literal"><span class="pre">!=</span></tt> check whether their operands are identical as intervals; that is, have the same endpoints. The ordering operators <tt class="docutils literal"><span class="pre"><</span> <span class="pre"><=</span> <span class="pre">></span> <span class="pre">>=</span></tt> permit inequality testing using triple-valued logic: a guaranteed inequality returns <tt class="xref docutils literal"><span class="pre">True</span></tt> or <tt class="xref docutils literal"><span class="pre">False</span></tt> while an indeterminate inequality returns <tt class="xref docutils literal"><span class="pre">None</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</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="o">==</span> <span class="n">iv</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="mi">2</span><span class="p">])</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o">!=</span> <span class="n">iv</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="mi">2</span><span class="p">])</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o"><=</span> <span class="mi">2</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o">></span> <span class="mi">0</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o"><</span> <span class="mi">1</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o"><</span> <span class="mi">2</span> <span class="c"># returns None</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span> <span class="o"><</span> <span class="mi">2</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o"><=</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</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="go">True</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o"><</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</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="c"># returns None</span>
<span class="gp">>>> </span><span class="n">iv</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="mi">2</span><span class="p">])</span> <span class="o"><</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">])</span>
<span class="go">False</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">in</span></tt> operator tests whether a number or interval is contained in another interval:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">])</span> <span class="ow">in</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">10</span><span class="p">])</span>
<span class="go">True</span>
<span class="gp">>>> </span><span class="mi">3</span> <span class="ow">in</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="s">'-inf'</span><span class="p">,</span> <span class="mi">0</span><span class="p">])</span>
<span class="go">False</span>
</pre></div>
</div>
<p>Intervals have the properties <tt class="docutils literal"><span class="pre">.a</span></tt>, <tt class="docutils literal"><span class="pre">.b</span></tt> (endpoints), <tt class="docutils literal"><span class="pre">.mid</span></tt>, and <tt class="docutils literal"><span class="pre">.delta</span></tt> (width):</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">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span> <span class="mi">5</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">x</span><span class="o">.</span><span class="n">a</span>
<span class="go">[2.0, 2.0]</span>
<span class="gp">>>> </span><span class="n">x</span><span class="o">.</span><span class="n">b</span>
<span class="go">[5.0, 5.0]</span>
<span class="gp">>>> </span><span class="n">x</span><span class="o">.</span><span class="n">mid</span>
<span class="go">[3.5, 3.5]</span>
<span class="gp">>>> </span><span class="n">x</span><span class="o">.</span><span class="n">delta</span>
<span class="go">[3.0, 3.0]</span>
</pre></div>
</div>
<p>Some transcendental functions are supported:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="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">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mf">0.5</span><span class="p">,</span><span class="mf">1.5</span><span class="p">])</span> <span class="o">**</span> <span class="n">iv</span><span class="o">.</span><span class="n">mpf</span><span class="p">([</span><span class="mf">0.5</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">])</span>
<span class="go">[0.35355339059327373086, 1.837117307087383633]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="go">[1.0, 1.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">([</span><span class="s">'-inf'</span><span class="p">,</span><span class="s">'inf'</span><span class="p">])</span>
<span class="go">[0.0, +inf]</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">([</span><span class="s">'-inf'</span><span class="p">,</span><span class="mi">0</span><span class="p">])</span>
<span class="go">[0.0, 1.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="s">'inf'</span><span class="p">])</span>
<span class="go">[1.0, +inf]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">])</span>
<span class="go">[1.0, 2.7182818284590455349]</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">log</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="go">[0.0, 0.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">log</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">[-inf, 0.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">log</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="s">'inf'</span><span class="p">])</span>
<span class="go">[-inf, +inf]</span>
<span class="gp">>>> </span><span class="n">iv</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="go">[0.69314718055994528623, 0.69314718055994539725]</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">sin</span><span class="p">([</span><span class="mi">100</span><span class="p">,</span><span class="s">'inf'</span><span class="p">])</span>
<span class="go">[-1.0, 1.0]</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">cos</span><span class="p">([</span><span class="s">'-0.1'</span><span class="p">,</span><span class="s">'0.1'</span><span class="p">])</span>
<span class="go">[0.99500416527802570954, 1.0]</span>
</pre></div>
</div>
<p>Interval arithmetic is useful for proving inequalities involving irrational numbers.
Naive use of <tt class="docutils literal"><span class="pre">mp</span></tt> arithmetic may result in wrong conclusions, such as the following:</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">x</span> <span class="o">=</span> <span class="n">mp</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">mp</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="n">mp</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">163</span><span class="p">))</span>
<span class="gp">>>> </span><span class="n">y</span> <span class="o">=</span> <span class="n">mp</span><span class="o">.</span><span class="n">mpf</span><span class="p">(</span><span class="mi">640320</span><span class="o">**</span><span class="mi">3</span><span class="o">+</span><span class="mi">744</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">x</span>
<span class="go">262537412640768744.0000001</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">y</span>
<span class="go">262537412640768744.0</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">></span> <span class="n">y</span>
<span class="go">True</span>
</pre></div>
</div>
<p>But the correct result is <img class="math" src="_images/math/3992d082ae7d3efe53c017446944cc399ef24621.png" alt="e^{\pi \sqrt{163}} < 262537412640768744"/>, as can be
seen by increasing the precision:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">50</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">mp</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">mp</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="n">mp</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">163</span><span class="p">))</span>
<span class="go">262537412640768743.99999999999925007259719818568888</span>
</pre></div>
</div>
<p>With interval arithmetic, the comparison returns <tt class="xref docutils literal"><span class="pre">None</span></tt> until the precision
is large enough for <img class="math" src="_images/math/643e1765342cf3807fd7d130ee679b71ecd4789b.png" alt="x-y"/> to have a definite sign:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">iv</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="n">iv</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">163</span><span class="p">))</span> <span class="o">></span> <span class="p">(</span><span class="mi">640320</span><span class="o">**</span><span class="mi">3</span><span class="o">+</span><span class="mi">744</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">30</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">iv</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="n">iv</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">163</span><span class="p">))</span> <span class="o">></span> <span class="p">(</span><span class="mi">640320</span><span class="o">**</span><span class="mi">3</span><span class="o">+</span><span class="mi">744</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">60</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">iv</span><span class="o">.</span><span class="n">pi</span><span class="o">*</span><span class="n">iv</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">163</span><span class="p">))</span> <span class="o">></span> <span class="p">(</span><span class="mi">640320</span><span class="o">**</span><span class="mi">3</span><span class="o">+</span><span class="mi">744</span><span class="p">)</span>
<span class="go">False</span>
<span class="gp">>>> </span><span class="n">iv</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span>
</pre></div>
</div>
</div>
<div class="section" id="fast-low-precision-arithmetic-fp">
<h2>Fast low-precision arithmetic (<tt class="docutils literal"><span class="pre">fp</span></tt>)<a class="headerlink" href="#fast-low-precision-arithmetic-fp" title="Permalink to this headline">¶</a></h2>
<p>Although mpmath is generally designed for arbitrary-precision arithmetic, many of the high-level algorithms work perfectly well with ordinary Python <tt class="docutils literal"><span class="pre">float</span></tt> and <tt class="docutils literal"><span class="pre">complex</span></tt> numbers, which use hardware double precision (on most systems, this corresponds to 53 bits of precision). Whereas the global functions (which are methods of the <tt class="docutils literal"><span class="pre">mp</span></tt> object) always convert inputs to mpmath numbers, the <tt class="docutils literal"><span class="pre">fp</span></tt> object instead converts them to <tt class="docutils literal"><span class="pre">float</span></tt> or <tt class="docutils literal"><span class="pre">complex</span></tt>, and in some cases employs basic functions optimized for double precision. When large amounts of function evaluations (numerical integration, plotting, etc) are required, and when <tt class="docutils literal"><span class="pre">fp</span></tt> arithmetic provides sufficient accuracy, this can give a significant speedup over <tt class="docutils literal"><span class="pre">mp</span></tt> arithmetic.</p>
<p>To take advantage of this feature, simply use the <tt class="docutils literal"><span class="pre">fp</span></tt> prefix, i.e. write <tt class="docutils literal"><span class="pre">fp.func</span></tt> instead of <tt class="docutils literal"><span class="pre">func</span></tt> or <tt class="docutils literal"><span class="pre">mp.func</span></tt>:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">u</span> <span class="o">=</span> <span class="n">fp</span><span class="o">.</span><span class="n">erfc</span><span class="p">(</span><span class="mf">2.5</span><span class="p">)</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">u</span>
<span class="go">0.000406952017445</span>
<span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">u</span><span class="p">)</span>
<span class="go"><type 'float'></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="k">print</span> <span class="n">mp</span><span class="o">.</span><span class="n">erfc</span><span class="p">(</span><span class="mf">2.5</span><span class="p">)</span>
<span class="go">0.000406952017444959</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">matrix</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">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]])</span> <span class="o">**</span> <span class="mi">2</span>
<span class="go">matrix(</span>
<span class="go">[['7.0', '10.0'],</span>
<span class="go"> ['15.0', '22.0']])</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">_</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"><type 'float'></span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">fp</span><span class="o">.</span><span class="n">quad</span><span class="p">(</span><span class="n">fp</span><span class="o">.</span><span class="n">sin</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="n">fp</span><span class="o">.</span><span class="n">pi</span><span class="p">])</span> <span class="c"># numerical integration</span>
<span class="go">2.0</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">fp</span></tt> context wraps Python’s <tt class="docutils literal"><span class="pre">math</span></tt> and <tt class="docutils literal"><span class="pre">cmath</span></tt> modules for elementary functions. It supports both real and complex numbers and automatically generates complex results for real inputs (<tt class="docutils literal"><span class="pre">math</span></tt> raises an exception):</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">2.2360679774997898</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="o">-</span><span class="mi">5</span><span class="p">)</span>
<span class="go">2.2360679774997898j</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="go">-0.54402111088936977</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">power</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mf">0.25</span><span class="p">)</span>
<span class="go">(0.70710678118654757+0.70710678118654746j)</span>
<span class="gp">>>> </span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="o">**</span> <span class="mf">0.25</span>
<span class="gt">Traceback (most recent call last):</span>
<span class="c">...</span>
<span class="nc">ValueError</span>: <span class="n-Identifier">negative number cannot be raised to a fractional power</span>
</pre></div>
</div>
<p>The <tt class="docutils literal"><span class="pre">prec</span></tt> and <tt class="docutils literal"><span class="pre">dps</span></tt> attributes can be changed (for interface compatibility with the <tt class="docutils literal"><span class="pre">mp</span></tt> context) but this has no effect:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">prec</span>
<span class="go">53</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">dps</span>
<span class="go">15</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">prec</span> <span class="o">=</span> <span class="mi">80</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">prec</span>
<span class="go">53</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">dps</span>
<span class="go">15</span>
</pre></div>
</div>
<p>Due to intermediate rounding and cancellation errors, results computed with <tt class="docutils literal"><span class="pre">fp</span></tt> arithmetic may be much less accurate than those computed with <tt class="docutils literal"><span class="pre">mp</span></tt> using an equivalent precision (<tt class="docutils literal"><span class="pre">mp.prec</span> <span class="pre">=</span> <span class="pre">53</span></tt>), since the latter often uses increased internal precision. The accuracy is highly problem-dependent: for some functions, <tt class="docutils literal"><span class="pre">fp</span></tt> almost always gives 14-15 correct digits; for others, results can be accurate to only 2-3 digits or even completely wrong. The recommended use for <tt class="docutils literal"><span class="pre">fp</span></tt> is therefore to speed up large-scale computations where accuracy can be verified in advance on a subset of the input set, or where results can be verified afterwards.</p>
</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="#">Contexts</a><ul>
<li><a class="reference external" href="#common-interface">Common interface</a></li>
<li><a class="reference external" href="#arbitrary-precision-floating-point-mp">Arbitrary-precision floating-point (<tt class="docutils literal"><span class="pre">mp</span></tt>)</a></li>
<li><a class="reference external" href="#arbitrary-precision-interval-arithmetic-iv">Arbitrary-precision interval arithmetic (<tt class="docutils literal"><span class="pre">iv</span></tt>)</a></li>
<li><a class="reference external" href="#fast-low-precision-arithmetic-fp">Fast low-precision arithmetic (<tt class="docutils literal"><span class="pre">fp</span></tt>)</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="basics.html"
title="previous chapter">Basic usage</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="general.html"
title="next chapter">Utility functions</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/contexts.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="general.html" title="Utility functions"
>next</a> |</li>
<li class="right" >
<a href="basics.html" title="Basic usage"
>previous</a> |</li>
<li><a href="index.html">mpmath v0.17 documentation</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
>
1226
