<!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>Matrices — 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="Number identification" href="identification.html" />
<link rel="prev" title="Function approximation" href="calculus/approximation.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="identification.html" title="Number identification"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="calculus/approximation.html" title="Function approximation"
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="matrices">
<h1>Matrices<a class="headerlink" href="#matrices" title="Permalink to this headline">¶</a></h1>
<div class="section" id="creating-matrices">
<h2>Creating matrices<a class="headerlink" href="#creating-matrices" title="Permalink to this headline">¶</a></h2>
<div class="section" id="basic-methods">
<h3>Basic methods<a class="headerlink" href="#basic-methods" title="Permalink to this headline">¶</a></h3>
<p>Matrices in mpmath are implemented using dictionaries. Only non-zero values are
stored, so it is cheap to represent sparse matrices.</p>
<p>The most basic way to create one is to use the <tt class="docutils literal"><span class="pre">matrix</span></tt> class directly. You
can create an empty matrix specifying the dimensions:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="n">matrix</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
<span class="gp">>>> </span><span class="n">matrix</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">matrix(</span>
<span class="go">[['0.0', '0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0', '0.0']])</span>
</pre></div>
</div>
<p>Calling <tt class="docutils literal"><span class="pre">matrix</span></tt> with one dimension will create a square matrix.</p>
<p>To access the dimensions of a matrix, use the <tt class="docutils literal"><span class="pre">rows</span></tt> or <tt class="docutils literal"><span class="pre">cols</span></tt> keyword:</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">matrix</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="gp">>>> </span><span class="n">A</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
<span class="gp">>>> </span><span class="n">A</span><span class="o">.</span><span class="n">rows</span>
<span class="go">3</span>
<span class="gp">>>> </span><span class="n">A</span><span class="o">.</span><span class="n">cols</span>
<span class="go">2</span>
</pre></div>
</div>
<p>You can also change the dimension of an existing matrix. This will set the
new elements to 0. If the new dimension is smaller than before, the
concerning elements are discarded:</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">rows</span> <span class="o">=</span> <span class="mi">2</span>
<span class="gp">>>> </span><span class="n">A</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
</pre></div>
</div>
<p>Internally <tt class="docutils literal"><span class="pre">convert</span></tt> is applied every time an element is set. This is
done using the syntax A[row,column], counting from 0:</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">matrix</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">A</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="o">=</span> <span class="mi">1</span> <span class="o">+</span> <span class="mi">1</span><span class="n">j</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">A</span>
<span class="go">[0.0 0.0]</span>
<span class="go">[0.0 (1.0 + 1.0j)]</span>
</pre></div>
</div>
<p>A more comfortable way to create a matrix lets you use nested lists:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </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="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]])</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '2.0'],</span>
<span class="go"> ['3.0', '4.0']])</span>
</pre></div>
</div>
</div>
<div class="section" id="advanced-methods">
<h3>Advanced methods<a class="headerlink" href="#advanced-methods" title="Permalink to this headline">¶</a></h3>
<p>Convenient functions are available for creating various standard matrices:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">zeros</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
<span class="gp">>>> </span><span class="n">ones</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '1.0'],</span>
<span class="go"> ['1.0', '1.0']])</span>
<span class="gp">>>> </span><span class="n">diag</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="c"># diagonal matrix</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '0.0', '0.0'],</span>
<span class="go"> ['0.0', '2.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0', '3.0']])</span>
<span class="gp">>>> </span><span class="n">eye</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="c"># identity matrix</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '0.0'],</span>
<span class="go"> ['0.0', '1.0']])</span>
</pre></div>
</div>
<p>You can even create random matrices:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">randmatrix</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span> <span class="c"># doctest:+SKIP</span>
<span class="go">matrix(</span>
<span class="go">[['0.53491598236191806', '0.57195669543302752'],</span>
<span class="go"> ['0.85589992269513615', '0.82444367501382143']])</span>
</pre></div>
</div>
</div>
<div class="section" id="vectors">
<h3>Vectors<a class="headerlink" href="#vectors" title="Permalink to this headline">¶</a></h3>
<p>Vectors may also be represented by the <tt class="docutils literal"><span class="pre">matrix</span></tt> class (with rows = 1 or cols = 1).
For vectors there are some things which make life easier. A column vector can
be created using a flat list, a row vectors using an almost flat nested list:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </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="go">matrix(</span>
<span class="go">[['1.0'],</span>
<span class="go"> ['2.0'],</span>
<span class="go"> ['3.0']])</span>
<span class="gp">>>> </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="go">matrix(</span>
<span class="go">[['1.0', '2.0', '3.0']])</span>
</pre></div>
</div>
<p>Optionally vectors can be accessed like lists, using only a single index:</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">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="gp">>>> </span><span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
<span class="go">mpf('2.0')</span>
<span class="gp">>>> </span><span class="n">x</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="go">mpf('2.0')</span>
</pre></div>
</div>
</div>
<div class="section" id="other">
<h3>Other<a class="headerlink" href="#other" title="Permalink to this headline">¶</a></h3>
<p>Like you probably expected, matrices can be printed:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="k">print</span> <span class="n">randmatrix</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c"># doctest:+SKIP</span>
<span class="go">[ 0.782963853573023 0.802057689719883 0.427895717335467]</span>
<span class="go">[0.0541876859348597 0.708243266653103 0.615134039977379]</span>
<span class="go">[ 0.856151514955773 0.544759264818486 0.686210904770947]</span>
</pre></div>
</div>
<p>Use <tt class="docutils literal"><span class="pre">nstr</span></tt> or <tt class="docutils literal"><span class="pre">nprint</span></tt> to specify the number of digits to print:</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">randmatrix</span><span class="p">(</span><span class="mi">5</span><span class="p">),</span> <span class="mi">3</span><span class="p">)</span> <span class="c"># doctest:+SKIP</span>
<span class="go">[2.07e-1 1.66e-1 5.06e-1 1.89e-1 8.29e-1]</span>
<span class="go">[6.62e-1 6.55e-1 4.47e-1 4.82e-1 2.06e-2]</span>
<span class="go">[4.33e-1 7.75e-1 6.93e-2 2.86e-1 5.71e-1]</span>
<span class="go">[1.01e-1 2.53e-1 6.13e-1 3.32e-1 2.59e-1]</span>
<span class="go">[1.56e-1 7.27e-2 6.05e-1 6.67e-2 2.79e-1]</span>
</pre></div>
</div>
<p>As matrices are mutable, you will need to copy them sometimes:</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">matrix</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">A</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
<span class="gp">>>> </span><span class="n">B</span> <span class="o">=</span> <span class="n">A</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="gp">>>> </span><span class="n">B</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="o">=</span> <span class="mi">1</span>
<span class="gp">>>> </span><span class="n">B</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
<span class="gp">>>> </span><span class="n">A</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '0.0'],</span>
<span class="go"> ['0.0', '0.0']])</span>
</pre></div>
</div>
<p>Finally, it is possible to convert a matrix to a nested list. This is very useful,
as most Python libraries involving matrices or arrays (namely NumPy or SymPy)
support this format:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">B</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
<span class="go">[[mpf('1.0'), mpf('0.0')], [mpf('0.0'), mpf('0.0')]]</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="matrix-operations">
<h2>Matrix operations<a class="headerlink" href="#matrix-operations" title="Permalink to this headline">¶</a></h2>
<p>You can add and substract matrices of compatible dimensions:</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">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="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">B</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">9</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">+</span> <span class="n">B</span>
<span class="go">matrix(</span>
<span class="go">[['-1.0', '6.0'],</span>
<span class="go"> ['8.0', '13.0']])</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">-</span> <span class="n">B</span>
<span class="go">matrix(</span>
<span class="go">[['3.0', '-2.0'],</span>
<span class="go"> ['-2.0', '-5.0']])</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">+</span> <span class="n">ones</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c"># doctest:+ELLIPSIS</span>
<span class="gt">Traceback (most recent call last):</span>
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n-Identifier"><module></span>
File <span class="nb">"..."</span>, line <span class="m">238</span>, in <span class="n-Identifier">__add__</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s">'incompatible dimensions for addition'</span><span class="p">)</span>
<span class="nc">ValueError</span>: <span class="n-Identifier">incompatible dimensions for addition</span>
</pre></div>
</div>
<p>It is possible to multiply or add matrices and scalars. In the latter case the
operation will be done element-wise:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">A</span> <span class="o">*</span> <span class="mi">2</span>
<span class="go">matrix(</span>
<span class="go">[['2.0', '4.0'],</span>
<span class="go"> ['6.0', '8.0']])</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">/</span> <span class="mi">4</span>
<span class="go">matrix(</span>
<span class="go">[['0.25', '0.5'],</span>
<span class="go"> ['0.75', '1.0']])</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">-</span> <span class="mi">1</span>
<span class="go">matrix(</span>
<span class="go">[['0.0', '1.0'],</span>
<span class="go"> ['2.0', '3.0']])</span>
</pre></div>
</div>
<p>Of course you can perform matrix multiplication, if the dimensions are
compatible:</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">B</span>
<span class="go">matrix(</span>
<span class="go">[['8.0', '22.0'],</span>
<span class="go"> ['14.0', '48.0']])</span>
<span class="gp">>>> </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="o">*</span> <span class="n">matrix</span><span class="p">([[</span><span class="o">-</span><span class="mi">6</span><span class="p">],</span> <span class="p">[</span><span class="mi">7</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="mi">2</span><span class="p">]])</span>
<span class="go">matrix(</span>
<span class="go">[['2.0']])</span>
</pre></div>
</div>
<p>You can raise powers of square matrices:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">A</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>
</pre></div>
</div>
<p>Negative powers will calculate the inverse:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">A</span><span class="o">**-</span><span class="mi">1</span>
<span class="go">matrix(</span>
<span class="go">[['-2.0', '1.0'],</span>
<span class="go"> ['1.5', '-0.5']])</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">A</span> <span class="o">*</span> <span class="n">A</span><span class="o">**-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">[ 1.0 1.08e-19]</span>
<span class="go">[-2.17e-19 1.0]</span>
</pre></div>
</div>
<p>Matrix transposition is straightforward:</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">ones</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="gp">>>> </span><span class="n">A</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '1.0', '1.0'],</span>
<span class="go"> ['1.0', '1.0', '1.0']])</span>
<span class="gp">>>> </span><span class="n">A</span><span class="o">.</span><span class="n">T</span>
<span class="go">matrix(</span>
<span class="go">[['1.0', '1.0'],</span>
<span class="go"> ['1.0', '1.0'],</span>
<span class="go"> ['1.0', '1.0']])</span>
</pre></div>
</div>
<div class="section" id="norms">
<h3>Norms<a class="headerlink" href="#norms" title="Permalink to this headline">¶</a></h3>
<p>Sometimes you need to know how “large” a matrix or vector is. Due to their
multidimensional nature it’s not possible to compare them, but there are
several functions to map a matrix or a vector to a positive real number, the
so called norms.</p>
<dl class="function">
<dt id="mpmath.norm">
<tt class="descclassname">mpmath.</tt><tt class="descname">norm</tt><big>(</big><em>ctx</em>, <em>x</em>, <em>p=2</em><big>)</big><a class="headerlink" href="#mpmath.norm" title="Permalink to this definition">¶</a></dt>
<dd><p>Gives the entrywise <img class="math" src="_images/math/36f73fc1312ee0349b3f3a0f3bd9eb5504339011.png" alt="p"/>-norm of an iterable <em>x</em>, i.e. the vector norm
<img class="math" src="_images/math/f93d4f96e853780721fd3f0bdbd9c0beff6ac0d9.png" alt="\left(\sum_k |x_k|^p\right)^{1/p}"/>, for any given <img class="math" src="_images/math/fbdfe77d15141724eb478aad6ee4c12fb05ff874.png" alt="1 \le p \le \infty"/>.</p>
<p>Special cases:</p>
<p>If <em>x</em> is not iterable, this just returns <tt class="docutils literal"><span class="pre">absmax(x)</span></tt>.</p>
<p><tt class="docutils literal"><span class="pre">p=1</span></tt> gives the sum of absolute values.</p>
<p><tt class="docutils literal"><span class="pre">p=2</span></tt> is the standard Euclidean vector norm.</p>
<p><tt class="docutils literal"><span class="pre">p=inf</span></tt> gives the magnitude of the largest element.</p>
<p>For <em>x</em> a matrix, <tt class="docutils literal"><span class="pre">p=2</span></tt> is the Frobenius norm.
For operator matrix norms, use <a title="mpmath.mnorm" class="reference internal" href="#mpmath.mnorm"><tt class="xref docutils literal"><span class="pre">mnorm()</span></tt></a> instead.</p>
<p>You can use the string ‘inf’ as well as float(‘inf’) or mpf(‘inf’)
to specify the infinity norm.</p>
<p><strong>Examples</strong></p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">100</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">norm</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">mpf('112.0')</span>
<span class="gp">>>> </span><span class="n">norm</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">mpf('100.5186549850325')</span>
<span class="gp">>>> </span><span class="n">norm</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">inf</span><span class="p">)</span>
<span class="go">mpf('100.0')</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.mnorm">
<tt class="descclassname">mpmath.</tt><tt class="descname">mnorm</tt><big>(</big><em>ctx</em>, <em>A</em>, <em>p=1</em><big>)</big><a class="headerlink" href="#mpmath.mnorm" title="Permalink to this definition">¶</a></dt>
<dd><p>Gives the matrix (operator) <img class="math" src="_images/math/36f73fc1312ee0349b3f3a0f3bd9eb5504339011.png" alt="p"/>-norm of A. Currently <tt class="docutils literal"><span class="pre">p=1</span></tt> and <tt class="docutils literal"><span class="pre">p=inf</span></tt>
are supported:</p>
<p><tt class="docutils literal"><span class="pre">p=1</span></tt> gives the 1-norm (maximal column sum)</p>
<p><tt class="docutils literal"><span class="pre">p=inf</span></tt> gives the <img class="math" src="_images/math/b671f1bb7e4ee86584347d5d22f1dc8abdb5bef2.png" alt="\infty"/>-norm (maximal row sum).
You can use the string ‘inf’ as well as float(‘inf’) or mpf(‘inf’)</p>
<p><tt class="docutils literal"><span class="pre">p=2</span></tt> (not implemented) for a square matrix is the usual spectral
matrix norm, i.e. the largest singular value.</p>
<p><tt class="docutils literal"><span class="pre">p='f'</span></tt> (or ‘F’, ‘fro’, ‘Frobenius, ‘frobenius’) gives the
Frobenius norm, which is the elementwise 2-norm. The Frobenius norm is an
approximation of the spectral norm and satisfies</p>
<div class="math">
<p><img src="_images/math/424f83eda2a3acdae490f8e78126eb1fb9e63108.png" alt="\frac{1}{\sqrt{\mathrm{rank}(A)}} \|A\|_F \le \|A\|_2 \le \|A\|_F" /></p>
</div><p>The Frobenius norm lacks some mathematical properties that might
be expected of a norm.</p>
<p>For general elementwise <img class="math" src="_images/math/36f73fc1312ee0349b3f3a0f3bd9eb5504339011.png" alt="p"/>-norms, use <a title="mpmath.norm" class="reference internal" href="#mpmath.norm"><tt class="xref docutils literal"><span class="pre">norm()</span></tt></a> instead.</p>
<p><strong>Examples</strong></p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">False</span>
<span class="gp">>>> </span><span class="n">A</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="o">-</span><span class="mi">1000</span><span class="p">],</span> <span class="p">[</span><span class="mi">100</span><span class="p">,</span> <span class="mi">50</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">mnorm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">mpf('1050.0')</span>
<span class="gp">>>> </span><span class="n">mnorm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">inf</span><span class="p">)</span>
<span class="go">mpf('1001.0')</span>
<span class="gp">>>> </span><span class="n">mnorm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="s">'F'</span><span class="p">)</span>
<span class="go">mpf('1006.2310867787777')</span>
</pre></div>
</div>
</dd></dl>
</div>
</div>
<div class="section" id="linear-algebra">
<h2>Linear algebra<a class="headerlink" href="#linear-algebra" title="Permalink to this headline">¶</a></h2>
<div class="section" id="decompositions">
<h3>Decompositions<a class="headerlink" href="#decompositions" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="mpmath.cholesky">
<tt class="descclassname">mpmath.</tt><tt class="descname">cholesky</tt><big>(</big><em>ctx</em>, <em>A</em>, <em>tol=None</em><big>)</big><a class="headerlink" href="#mpmath.cholesky" title="Permalink to this definition">¶</a></dt>
<dd><p>Cholesky decomposition of a symmetric positive-definite matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>.
Returns a lower triangular matrix <img class="math" src="_images/math/859ccf4cd60c7bc6b8fa1afc9a42dc811a826d6f.png" alt="L"/> such that <img class="math" src="_images/math/c60af0b1e6cf1ca00619a475d550a564114b29cb.png" alt="A = L \times L^T"/>.
More generally, for a complex Hermitian positive-definite matrix,
a Cholesky decomposition satisfying <img class="math" src="_images/math/b0b05898d791732cd5afa89229f4520c8db49f18.png" alt="A = L \times L^H"/> is returned.</p>
<p>The Cholesky decomposition can be used to solve linear equation
systems twice as efficiently as LU decomposition, or to
test whether <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/> is positive-definite.</p>
<p>The optional parameter <tt class="docutils literal"><span class="pre">tol</span></tt> determines the tolerance for
verifying positive-definiteness.</p>
<p><strong>Examples</strong></p>
<p>Cholesky decomposition of a positive-definite symmetric matrix:</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">A</span> <span class="o">=</span> <span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="n">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">[ 2.0 0.5 0.333333]</span>
<span class="go">[ 0.5 1.33333 0.25]</span>
<span class="go">[0.333333 0.25 1.2]</span>
<span class="gp">>>> </span><span class="n">L</span> <span class="o">=</span> <span class="n">cholesky</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">L</span><span class="p">)</span>
<span class="go">[ 1.41421 0.0 0.0]</span>
<span class="go">[0.353553 1.09924 0.0]</span>
<span class="go">[0.235702 0.15162 1.05899]</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">A</span> <span class="o">-</span> <span class="n">L</span><span class="o">*</span><span class="n">L</span><span class="o">.</span><span class="n">T</span><span class="p">)</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="go">[0.0 0.0 0.0]</span>
</pre></div>
</div>
<p>Cholesky decomposition of a Hermitian matrix:</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">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="n">matrix</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span><span class="mf">0.25</span><span class="n">j</span><span class="p">,</span><span class="o">-</span><span class="mf">0.5</span><span class="n">j</span><span class="p">],[</span><span class="o">-</span><span class="mf">0.25</span><span class="n">j</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="mf">0.5</span><span class="n">j</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="gp">>>> </span><span class="n">L</span> <span class="o">=</span> <span class="n">cholesky</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">L</span><span class="p">)</span>
<span class="go">[ 1.0 0.0 0.0]</span>
<span class="go">[(0.0 - 0.25j) (0.968246 + 0.0j) 0.0]</span>
<span class="go">[ (0.0 + 0.5j) (0.129099 + 0.0j) (0.856349 + 0.0j)]</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">A</span> <span class="o">-</span> <span class="n">L</span><span class="o">*</span><span class="n">L</span><span class="o">.</span><span class="n">H</span><span class="p">)</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="go">[0.0 0.0 0.0]</span>
</pre></div>
</div>
<p>Attempted Cholesky decomposition of a matrix that is not positive
definite:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">A</span> <span class="o">=</span> <span class="o">-</span><span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="n">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">L</span> <span class="o">=</span> <span class="n">cholesky</span><span class="p">(</span><span class="n">A</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">matrix is not positive-definite</span>
</pre></div>
</div>
<p><strong>References</strong></p>
<ol class="arabic simple">
<li><a class="reference external" href="references.html#wikipedia">[Wikipedia]</a> <a class="reference external" href="http://en.wikipedia.org/wiki/Cholesky_decomposition">http://en.wikipedia.org/wiki/Cholesky_decomposition</a></li>
</ol>
</dd></dl>
</div>
<div class="section" id="linear-equations">
<h3>Linear equations<a class="headerlink" href="#linear-equations" title="Permalink to this headline">¶</a></h3>
<p>Basic linear algebra is implemented; you can for example solve the linear
equation system:</p>
<div class="highlight-python"><pre> x + 2*y = -10
3*x + 4*y = 10</pre>
</div>
<p>using <tt class="docutils literal"><span class="pre">lu_solve</span></tt>:</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">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="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">x</span> <span class="o">=</span> <span class="n">lu_solve</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="gp">>>> </span><span class="n">x</span>
<span class="go">matrix(</span>
<span class="go">[['30.0'],</span>
<span class="go"> ['-20.0']])</span>
</pre></div>
</div>
<p>If you don’t trust the result, use <tt class="docutils literal"><span class="pre">residual</span></tt> to calculate the residual ||A*x-b||:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">residual</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">matrix(</span>
<span class="go">[['3.46944695195361e-18'],</span>
<span class="go"> ['3.46944695195361e-18']])</span>
<span class="gp">>>> </span><span class="nb">str</span><span class="p">(</span><span class="n">eps</span><span class="p">)</span>
<span class="go">'2.22044604925031e-16'</span>
</pre></div>
</div>
<p>As you can see, the solution is quite accurate. The error is caused by the
inaccuracy of the internal floating point arithmetic. Though, it’s even smaller
than the current machine epsilon, which basically means you can trust the
result.</p>
<p>If you need more speed, use NumPy, or use <tt class="docutils literal"><span class="pre">fp</span></tt> instead <tt class="docutils literal"><span class="pre">mp</span></tt> matrices
and methods:</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">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="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">fp</span><span class="o">.</span><span class="n">matrix</span><span class="p">([</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">fp</span><span class="o">.</span><span class="n">lu_solve</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">matrix(</span>
<span class="go">[['30.0'],</span>
<span class="go"> ['-20.0']])</span>
</pre></div>
</div>
<p><tt class="docutils literal"><span class="pre">lu_solve</span></tt> accepts overdetermined systems. It is usually not possible to solve
such systems, so the residual is minimized instead. Internally this is done
using Cholesky decomposition to compute a least squares approximation. This means
that that <tt class="docutils literal"><span class="pre">lu_solve</span></tt> will square the errors. If you can’t afford this, use
<tt class="docutils literal"><span class="pre">qr_solve</span></tt> instead. It is twice as slow but more accurate, and it calculates
the residual automatically.</p>
</div>
<div class="section" id="matrix-factorization">
<h3>Matrix factorization<a class="headerlink" href="#matrix-factorization" title="Permalink to this headline">¶</a></h3>
<p>The function <tt class="docutils literal"><span class="pre">lu</span></tt> computes an explicit LU factorization of a matrix:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">P</span><span class="p">,</span> <span class="n">L</span><span class="p">,</span> <span class="n">U</span> <span class="o">=</span> <span class="n">lu</span><span class="p">(</span><span class="n">matrix</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="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="mi">6</span><span class="p">],[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">]]))</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">P</span>
<span class="go">[0.0 0.0 1.0]</span>
<span class="go">[1.0 0.0 0.0]</span>
<span class="go">[0.0 1.0 0.0]</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">L</span>
<span class="go">[ 1.0 0.0 0.0]</span>
<span class="go">[ 0.0 1.0 0.0]</span>
<span class="go">[0.571428571428571 0.214285714285714 1.0]</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">U</span>
<span class="go">[7.0 8.0 9.0]</span>
<span class="go">[0.0 2.0 3.0]</span>
<span class="go">[0.0 0.0 0.214285714285714]</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">P</span><span class="o">.</span><span class="n">T</span><span class="o">*</span><span class="n">L</span><span class="o">*</span><span class="n">U</span>
<span class="go">[0.0 2.0 3.0]</span>
<span class="go">[4.0 5.0 6.0]</span>
<span class="go">[7.0 8.0 9.0]</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="interval-and-double-precision-matrices">
<h2>Interval and double-precision matrices<a class="headerlink" href="#interval-and-double-precision-matrices" title="Permalink to this headline">¶</a></h2>
<p>The <tt class="docutils literal"><span class="pre">iv.matrix</span></tt> and <tt class="docutils literal"><span class="pre">fp.matrix</span></tt> classes convert inputs
to intervals and Python floating-point numbers respectively.</p>
<p>Interval matrices can be used to perform linear algebra operations
with rigorous error tracking:</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">iv</span><span class="o">.</span><span class="n">matrix</span><span class="p">([[</span><span class="s">'0.1'</span><span class="p">,</span><span class="s">'0.3'</span><span class="p">,</span><span class="s">'1.0'</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span><span class="s">'7.1'</span><span class="p">,</span><span class="s">'5.5'</span><span class="p">,</span><span class="s">'4.8'</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span><span class="s">'3.2'</span><span class="p">,</span><span class="s">'4.4'</span><span class="p">,</span><span class="s">'5.6'</span><span class="p">]])</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">iv</span><span class="o">.</span><span class="n">matrix</span><span class="p">([</span><span class="s">'4'</span><span class="p">,</span><span class="s">'0.6'</span><span class="p">,</span><span class="s">'0.5'</span><span class="p">])</span>
<span class="gp">>>> </span><span class="n">c</span> <span class="o">=</span> <span class="n">iv</span><span class="o">.</span><span class="n">lu_solve</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="gp">>>> </span><span class="k">print</span> <span class="n">c</span>
<span class="go">[ [5.2582327113062393041, 5.2582327113062749951]]</span>
<span class="go">[[-13.155049396267856583, -13.155049396267821167]]</span>
<span class="go">[ [7.4206915477497212555, 7.4206915477497310922]]</span>
<span class="gp">>>> </span><span class="k">print</span> <span class="n">a</span><span class="o">*</span><span class="n">c</span>
<span class="go">[ [3.9999999999999866773, 4.0000000000000133227]]</span>
<span class="go">[[0.59999999999972430942, 0.60000000000027142733]]</span>
<span class="go">[[0.49999999999982236432, 0.50000000000018474111]]</span>
</pre></div>
</div>
</div>
<div class="section" id="matrix-functions">
<h2>Matrix functions<a class="headerlink" href="#matrix-functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="mpmath.expm">
<tt class="descclassname">mpmath.</tt><tt class="descname">expm</tt><big>(</big><em>ctx</em>, <em>A</em>, <em>method='taylor'</em><big>)</big><a class="headerlink" href="#mpmath.expm" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the matrix exponential of a square matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>, which is defined
by the power series</p>
<div class="math">
<p><img src="_images/math/0b5d6398ab2874e0d2b16245ae32b08ebb195649.png" alt="\exp(A) = I + A + \frac{A^2}{2!} + \frac{A^3}{3!} + \ldots" /></p>
</div><p>With method=’taylor’, the matrix exponential is computed
using the Taylor series. With method=’pade’, Pade approximants
are used instead.</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">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">expm</span><span class="p">(</span><span class="n">zeros</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>
<span class="go">[1.0 0.0 0.0]</span>
<span class="go">[0.0 1.0 0.0]</span>
<span class="go">[0.0 0.0 1.0]</span>
<span class="gp">>>> </span><span class="n">expm</span><span class="p">(</span><span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">))</span>
<span class="go">[2.71828182845905 0.0 0.0]</span>
<span class="go">[ 0.0 2.71828182845905 0.0]</span>
<span class="go">[ 0.0 0.0 2.71828182845905]</span>
<span class="gp">>>> </span><span class="n">expm</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">0</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">1</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="mi">0</span><span class="p">]])</span>
<span class="go">[ 3.86814500615414 2.26812870852145 0.841130841230196]</span>
<span class="go">[ 2.26812870852145 2.44114713886289 1.42699786729125]</span>
<span class="go">[0.841130841230196 1.42699786729125 1.6000162976327]</span>
<span class="gp">>>> </span><span class="n">expm</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">0</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">1</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="mi">0</span><span class="p">]],</span> <span class="n">method</span><span class="o">=</span><span class="s">'pade'</span><span class="p">)</span>
<span class="go">[ 3.86814500615414 2.26812870852145 0.841130841230196]</span>
<span class="go">[ 2.26812870852145 2.44114713886289 1.42699786729125]</span>
<span class="go">[0.841130841230196 1.42699786729125 1.6000162976327]</span>
<span class="gp">>>> </span><span class="n">expm</span><span class="p">([[</span><span class="mi">1</span><span class="o">+</span><span class="n">j</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="o">+</span><span class="n">j</span><span class="p">,</span><span class="mi">1</span><span class="p">]])</span>
<span class="go">[(1.46869393991589 + 2.28735528717884j) 0.0]</span>
<span class="go">[ (1.03776739863568 + 3.536943175722j) (2.71828182845905 + 0.0j)]</span>
</pre></div>
</div>
<p>Matrices with large entries are allowed:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">expm</span><span class="p">(</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">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]])</span><span class="o">**</span><span class="mi">25</span><span class="p">)</span>
<span class="go">[5.65024064048415e+2050488462815550 9.14228140091932e+2050488462815550]</span>
<span class="go">[9.14228140091932e+2050488462815550 1.47925220414035e+2050488462815551]</span>
</pre></div>
</div>
<p>The identity <img class="math" src="_images/math/e72e6f94282a4ae2cae770064835263bb7c54f52.png" alt="\exp(A+B) = \exp(A) \exp(B)"/> does not hold for
noncommuting matrices:</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">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">B</span> <span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">mnorm</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">B</span> <span class="o">-</span> <span class="n">B</span><span class="o">*</span><span class="n">A</span><span class="p">))</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">mnorm</span><span class="p">(</span><span class="n">expm</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="n">expm</span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="o">*</span><span class="n">expm</span><span class="p">(</span><span class="n">B</span><span class="p">)))</span>
<span class="go">0.0</span>
<span class="gp">>>> </span><span class="n">B</span> <span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">ones</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">mnorm</span><span class="p">(</span><span class="n">A</span><span class="o">*</span><span class="n">B</span> <span class="o">-</span> <span class="n">B</span><span class="o">*</span><span class="n">A</span><span class="p">)</span>
<span class="go">1.8</span>
<span class="gp">>>> </span><span class="n">mnorm</span><span class="p">(</span><span class="n">expm</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="n">expm</span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="o">*</span><span class="n">expm</span><span class="p">(</span><span class="n">B</span><span class="p">))</span>
<span class="go">42.0927851137247</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.cosm">
<tt class="descclassname">mpmath.</tt><tt class="descname">cosm</tt><big>(</big><em>ctx</em>, <em>A</em><big>)</big><a class="headerlink" href="#mpmath.cosm" title="Permalink to this definition">¶</a></dt>
<dd><p>Gives the cosine of a square matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>, defined in analogy
with the matrix exponential.</p>
<p>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">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">X</span> <span class="o">=</span> <span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">cosm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[0.54030230586814 0.0 0.0]</span>
<span class="go">[ 0.0 0.54030230586814 0.0]</span>
<span class="go">[ 0.0 0.0 0.54030230586814]</span>
<span class="gp">>>> </span><span class="n">X</span> <span class="o">=</span> <span class="n">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">cosm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[ 0.424403834569555 -0.316643413047167 -0.221474945949293]</span>
<span class="go">[-0.316643413047167 0.820646708837824 -0.127183694770039]</span>
<span class="go">[-0.221474945949293 -0.127183694770039 0.909236687217541]</span>
<span class="gp">>>> </span><span class="n">X</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="mi">1</span><span class="o">+</span><span class="n">j</span><span class="p">,</span><span class="o">-</span><span class="mi">2</span><span class="p">],[</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="n">j</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">cosm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[(0.833730025131149 - 0.988897705762865j) (1.07485840848393 - 0.17192140544213j)]</span>
<span class="go">[ 0.0 (1.54308063481524 + 0.0j)]</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.sinm">
<tt class="descclassname">mpmath.</tt><tt class="descname">sinm</tt><big>(</big><em>ctx</em>, <em>A</em><big>)</big><a class="headerlink" href="#mpmath.sinm" title="Permalink to this definition">¶</a></dt>
<dd><p>Gives the sine of a square matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>, defined in analogy
with the matrix exponential.</p>
<p>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">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">X</span> <span class="o">=</span> <span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">sinm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[0.841470984807897 0.0 0.0]</span>
<span class="go">[ 0.0 0.841470984807897 0.0]</span>
<span class="go">[ 0.0 0.0 0.841470984807897]</span>
<span class="gp">>>> </span><span class="n">X</span> <span class="o">=</span> <span class="n">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">sinm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[0.711608512150994 0.339783913247439 0.220742837314741]</span>
<span class="go">[0.339783913247439 0.244113865695532 0.187231271174372]</span>
<span class="go">[0.220742837314741 0.187231271174372 0.155816730769635]</span>
<span class="gp">>>> </span><span class="n">X</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="mi">1</span><span class="o">+</span><span class="n">j</span><span class="p">,</span><span class="o">-</span><span class="mi">2</span><span class="p">],[</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="n">j</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">sinm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[(1.29845758141598 + 0.634963914784736j) (-1.96751511930922 + 0.314700021761367j)]</span>
<span class="go">[ 0.0 (0.0 - 1.1752011936438j)]</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.sqrtm">
<tt class="descclassname">mpmath.</tt><tt class="descname">sqrtm</tt><big>(</big><em>ctx</em>, <em>A</em>, <em>_may_rotate=2</em><big>)</big><a class="headerlink" href="#mpmath.sqrtm" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes a square root of the square matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>, i.e. returns
a matrix <img class="math" src="_images/math/b483873061aab278d8b0e037734d22b865965a07.png" alt="B = A^{1/2}"/> such that <img class="math" src="_images/math/f18be3cebf1a0b71b37566467b5dbcb5465a6302.png" alt="B^2 = A"/>. The square root
of a matrix, if it exists, is not unique.</p>
<p><strong>Examples</strong></p>
<p>Square roots of some simple matrices:</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">sqrtm</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="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">sqrtm</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="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]])</span>
<span class="go">[0.0 0.0]</span>
<span class="go">[0.0 0.0]</span>
<span class="gp">>>> </span><span class="n">sqrtm</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="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">]])</span>
<span class="go">[1.4142135623731 0.0]</span>
<span class="go">[ 0.0 1.0]</span>
<span class="gp">>>> </span><span class="n">sqrtm</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">1</span><span class="p">,</span><span class="mi">0</span><span class="p">]])</span>
<span class="go">[ (0.920442065259926 - 0.21728689675164j) (0.568864481005783 + 0.351577584254143j)]</span>
<span class="go">[(0.568864481005783 + 0.351577584254143j) (0.351577584254143 - 0.568864481005783j)]</span>
<span class="gp">>>> </span><span class="n">sqrtm</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">sqrtm</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="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">]])</span>
<span class="go">[(0.0 - 1.0j) 0.0]</span>
<span class="go">[ 0.0 (1.0 + 0.0j)]</span>
<span class="gp">>>> </span><span class="n">sqrtm</span><span class="p">([[</span><span class="n">j</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="n">j</span><span class="p">]])</span>
<span class="go">[(0.707106781186547 + 0.707106781186547j) 0.0]</span>
<span class="go">[ 0.0 (0.707106781186547 + 0.707106781186547j)]</span>
</pre></div>
</div>
<p>A square root of a rotation matrix, giving the corresponding
half-angle rotation matrix:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t1</span> <span class="o">=</span> <span class="mf">0.75</span>
<span class="gp">>>> </span><span class="n">t2</span> <span class="o">=</span> <span class="n">t1</span> <span class="o">*</span> <span class="mf">0.5</span>
<span class="gp">>>> </span><span class="n">A1</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="n">cos</span><span class="p">(</span><span class="n">t1</span><span class="p">),</span> <span class="o">-</span><span class="n">sin</span><span class="p">(</span><span class="n">t1</span><span class="p">)],</span> <span class="p">[</span><span class="n">sin</span><span class="p">(</span><span class="n">t1</span><span class="p">),</span> <span class="n">cos</span><span class="p">(</span><span class="n">t1</span><span class="p">)]])</span>
<span class="gp">>>> </span><span class="n">A2</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="n">cos</span><span class="p">(</span><span class="n">t2</span><span class="p">),</span> <span class="o">-</span><span class="n">sin</span><span class="p">(</span><span class="n">t2</span><span class="p">)],</span> <span class="p">[</span><span class="n">sin</span><span class="p">(</span><span class="n">t2</span><span class="p">),</span> <span class="n">cos</span><span class="p">(</span><span class="n">t2</span><span class="p">)]])</span>
<span class="gp">>>> </span><span class="n">sqrtm</span><span class="p">(</span><span class="n">A1</span><span class="p">)</span>
<span class="go">[0.930507621912314 -0.366272529086048]</span>
<span class="go">[0.366272529086048 0.930507621912314]</span>
<span class="gp">>>> </span><span class="n">A2</span>
<span class="go">[0.930507621912314 -0.366272529086048]</span>
<span class="go">[0.366272529086048 0.930507621912314]</span>
</pre></div>
</div>
<p>The identity <img class="math" src="_images/math/9c60eff813d166d3d9b124fcbaefda3f139c8c4a.png" alt="(A^2)^{1/2} = A"/> does not necessarily hold:</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">matrix</span><span class="p">([[</span><span class="mi">4</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">],[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">],[</span><span class="mi">10</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">11</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">sqrtm</span><span class="p">(</span><span class="n">A</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
<span class="go">[ 4.0 1.0 4.0]</span>
<span class="go">[ 7.0 8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
<span class="gp">>>> </span><span class="n">sqrtm</span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span>
<span class="go">[ 4.0 1.0 4.0]</span>
<span class="go">[ 7.0 8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">],[</span><span class="mi">7</span><span class="p">,</span><span class="o">-</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">],[</span><span class="mi">10</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">11</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">sqrtm</span><span class="p">(</span><span class="n">A</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
<span class="go">[ 7.43715112194995 -0.324127569985474 1.8481718827526]</span>
<span class="go">[-0.251549715716942 9.32699765900402 2.48221180985147]</span>
<span class="go">[ 4.11609388833616 0.775751877098258 13.017955697342]</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">sqrtm</span><span class="p">(</span><span class="n">A</span><span class="p">)</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
<span class="go">[-4.0 1.0 4.0]</span>
<span class="go">[ 7.0 -8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
</pre></div>
</div>
<p>For some matrices, a square root does not exist:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">sqrtm</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="p">[</span><span class="mi">0</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">ZeroDivisionError</span>: <span class="n-Identifier">matrix is numerically singular</span>
</pre></div>
</div>
<p>Two examples from the documentation for Matlab’s <tt class="docutils literal"><span class="pre">sqrtm</span></tt>:</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">sqrtm</span><span class="p">([[</span><span class="mi">7</span><span class="p">,</span><span class="mi">10</span><span class="p">],[</span><span class="mi">15</span><span class="p">,</span><span class="mi">22</span><span class="p">]])</span>
<span class="go">[1.56669890360128 1.74077655955698]</span>
<span class="go">[2.61116483933547 4.17786374293675]</span>
<span class="go">>>></span>
<span class="gp">>>> </span><span class="n">X</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">(</span>\
<span class="gp">... </span> <span class="p">[[</span><span class="mi">5</span><span class="p">,</span><span class="o">-</span><span class="mi">4</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="gp">... </span> <span class="p">[</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="o">-</span><span class="mi">4</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="gp">... </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="p">,</span><span class="mi">6</span><span class="p">,</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span><span class="mi">1</span><span class="p">],</span>
<span class="gp">... </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="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="o">-</span><span class="mi">4</span><span class="p">],</span>
<span class="gp">... </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="o">-</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">Y</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">(</span>\
<span class="gp">... </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="p">,</span><span class="o">-</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="mi">0</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</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="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="mi">0</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span><span class="mi">0</span><span class="p">,</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="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span><span class="o">-</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</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="mi">1</span><span class="p">],</span>
<span class="gp">... </span> <span class="p">[</span><span class="o">-</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="mi">0</span><span class="p">,</span><span class="o">-</span><span class="mi">0</span><span class="p">,</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="gp">>>> </span><span class="n">mnorm</span><span class="p">(</span><span class="n">sqrtm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span> <span class="o">-</span> <span class="n">Y</span><span class="p">)</span>
<span class="go">4.53155328326114e-19</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.logm">
<tt class="descclassname">mpmath.</tt><tt class="descname">logm</tt><big>(</big><em>ctx</em>, <em>A</em><big>)</big><a class="headerlink" href="#mpmath.logm" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes a logarithm of the square matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/>, i.e. returns
a matrix <img class="math" src="_images/math/dee154386ef182cf16601a7eca95119235eab589.png" alt="B = \log(A)"/> such that <img class="math" src="_images/math/5f467ed8bbc7f2ed6ee6377cf20b401f85ce1425.png" alt="\exp(B) = A"/>. The logarithm
of a matrix, if it exists, is not unique.</p>
<p><strong>Examples</strong></p>
<p>Logarithms of some simple matrices:</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">X</span> <span class="o">=</span> <span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">logm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="go">[0.0 0.0 0.0]</span>
<span class="gp">>>> </span><span class="n">logm</span><span class="p">(</span><span class="mi">2</span><span class="o">*</span><span class="n">X</span><span class="p">)</span>
<span class="go">[0.693147180559945 0.0 0.0]</span>
<span class="go">[ 0.0 0.693147180559945 0.0]</span>
<span class="go">[ 0.0 0.0 0.693147180559945]</span>
<span class="gp">>>> </span><span class="n">logm</span><span class="p">(</span><span class="n">expm</span><span class="p">(</span><span class="n">X</span><span class="p">))</span>
<span class="go">[1.0 0.0 0.0]</span>
<span class="go">[0.0 1.0 0.0]</span>
<span class="go">[0.0 0.0 1.0]</span>
</pre></div>
</div>
<p>A logarithm of a complex matrix:</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">matrix</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="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">1</span><span class="o">-</span><span class="n">j</span><span class="p">,</span> <span class="mi">1</span><span class="o">-</span><span class="mi">2</span><span class="o">*</span><span class="n">j</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="o">-</span><span class="mi">5</span><span class="p">,</span> <span class="n">j</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">B</span> <span class="o">=</span> <span class="n">logm</span><span class="p">(</span><span class="n">X</span><span class="p">)</span>
<span class="gp">>>> </span><span class="n">nprint</span><span class="p">(</span><span class="n">B</span><span class="p">)</span>
<span class="go">[ (0.808757 + 0.107759j) (2.20752 + 0.202762j) (1.07376 - 0.773874j)]</span>
<span class="go">[ (0.905709 - 0.107795j) (0.0287395 - 0.824993j) (0.111619 + 0.514272j)]</span>
<span class="go">[(-0.930151 + 0.399512j) (-2.06266 - 0.674397j) (0.791552 + 0.519839j)]</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">expm</span><span class="p">(</span><span class="n">B</span><span class="p">))</span>
<span class="go">[(2.0 + 1.0j) 1.0 3.0]</span>
<span class="go">[(1.0 - 1.0j) (1.0 - 2.0j) 1.0]</span>
<span class="go">[ -4.0 -5.0 (0.0 + 1.0j)]</span>
</pre></div>
</div>
<p>A matrix <img class="math" src="_images/math/6a47ca0fe7cb276abc022af6ac88ddae1a9d6894.png" alt="X"/> close to the identity matrix, for which
<img class="math" src="_images/math/09f0e570182f649497cdf108a0c9f7cfb5fd1e3d.png" alt="\log(\exp(X)) = \exp(\log(X)) = X"/> holds:</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">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="n">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span><span class="o">/</span><span class="mi">4</span>
<span class="gp">>>> </span><span class="n">X</span>
<span class="go">[ 1.25 0.125 0.0833333333333333]</span>
<span class="go">[ 0.125 1.08333333333333 0.0625]</span>
<span class="go">[0.0833333333333333 0.0625 1.05]</span>
<span class="gp">>>> </span><span class="n">logm</span><span class="p">(</span><span class="n">expm</span><span class="p">(</span><span class="n">X</span><span class="p">))</span>
<span class="go">[ 1.25 0.125 0.0833333333333333]</span>
<span class="go">[ 0.125 1.08333333333333 0.0625]</span>
<span class="go">[0.0833333333333333 0.0625 1.05]</span>
<span class="gp">>>> </span><span class="n">expm</span><span class="p">(</span><span class="n">logm</span><span class="p">(</span><span class="n">X</span><span class="p">))</span>
<span class="go">[ 1.25 0.125 0.0833333333333333]</span>
<span class="go">[ 0.125 1.08333333333333 0.0625]</span>
<span class="go">[0.0833333333333333 0.0625 1.05]</span>
</pre></div>
</div>
<p>A logarithm of a rotation matrix, giving back the angle of
the rotation:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">t</span> <span class="o">=</span> <span class="mf">3.7</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">=</span> <span class="n">matrix</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="n">sin</span><span class="p">(</span><span class="n">t</span><span class="p">)],[</span><span class="o">-</span><span class="n">sin</span><span class="p">(</span><span class="n">t</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="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">logm</span><span class="p">(</span><span class="n">A</span><span class="p">))</span>
<span class="go">[ 0.0 -2.58318530717959]</span>
<span class="go">[2.58318530717959 0.0]</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="o">-</span><span class="n">t</span><span class="p">)</span>
<span class="go">2.58318530717959</span>
</pre></div>
</div>
<p>For some matrices, a logarithm does not exist:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">logm</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="p">[</span><span class="mi">0</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">ZeroDivisionError</span>: <span class="n-Identifier">matrix is numerically singular</span>
</pre></div>
</div>
<p>Logarithm of a matrix with large entries:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">logm</span><span class="p">(</span><span class="n">hilbert</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="o">*</span> <span class="mi">10</span><span class="o">**</span><span class="mi">20</span><span class="p">)</span><span class="o">.</span><span class="n">apply</span><span class="p">(</span><span class="n">re</span><span class="p">)</span>
<span class="go">[ 45.5597513593433 1.27721006042799 0.317662687717978]</span>
<span class="go">[ 1.27721006042799 42.5222778973542 2.24003708791604]</span>
<span class="go">[0.317662687717978 2.24003708791604 42.395212822267]</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="mpmath.powm">
<tt class="descclassname">mpmath.</tt><tt class="descname">powm</tt><big>(</big><em>ctx</em>, <em>A</em>, <em>r</em><big>)</big><a class="headerlink" href="#mpmath.powm" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <img class="math" src="_images/math/9071a4cdd8398dc7bba0a3b404151e21df7d2eb2.png" alt="A^r = \exp(A \log r)"/> for a matrix <img class="math" src="_images/math/019e9892786e493964e145e7c5cf7b700314e53b.png" alt="A"/> and complex
number <img class="math" src="_images/math/b55ca7a0aa88ab7d58f4fc035317fdac39b17861.png" alt="r"/>.</p>
<p><strong>Examples</strong></p>
<p>Powers and inverse powers of a matrix:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">mpmath</span> <span class="kn">import</span> <span class="o">*</span>
<span class="gp">>>> </span><span class="n">mp</span><span class="o">.</span><span class="n">dps</span> <span class="o">=</span> <span class="mi">15</span><span class="p">;</span> <span class="n">mp</span><span class="o">.</span><span class="n">pretty</span> <span class="o">=</span> <span class="bp">True</span>
<span class="gp">>>> </span><span class="n">A</span> <span class="o">=</span> <span class="n">matrix</span><span class="p">([[</span><span class="mi">4</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">],[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">],[</span><span class="mi">10</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">11</span><span class="p">]])</span>
<span class="gp">>>> </span><span class="n">powm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">[ 63.0 20.0 69.0]</span>
<span class="go">[174.0 89.0 199.0]</span>
<span class="go">[164.0 48.0 179.0]</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">powm</span><span class="p">(</span><span class="n">powm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="mi">4</span><span class="p">),</span> <span class="mi">1</span><span class="o">/</span><span class="mf">4.</span><span class="p">))</span>
<span class="go">[ 4.0 1.0 4.0]</span>
<span class="go">[ 7.0 8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
<span class="gp">>>> </span><span class="n">powm</span><span class="p">(</span><span class="n">extraprec</span><span class="p">(</span><span class="mi">20</span><span class="p">)(</span><span class="n">powm</span><span class="p">)(</span><span class="n">A</span><span class="p">,</span> <span class="o">-</span><span class="mi">4</span><span class="p">),</span> <span class="o">-</span><span class="mi">1</span><span class="o">/</span><span class="mf">4.</span><span class="p">)</span>
<span class="go">[ 4.0 1.0 4.0]</span>
<span class="go">[ 7.0 8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
<span class="gp">>>> </span><span class="n">chop</span><span class="p">(</span><span class="n">powm</span><span class="p">(</span><span class="n">powm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="mi">1</span><span class="o">+</span><span class="mf">0.5</span><span class="n">j</span><span class="p">),</span> <span class="mi">1</span><span class="o">/</span><span class="p">(</span><span class="mi">1</span><span class="o">+</span><span class="mf">0.5</span><span class="n">j</span><span class="p">)))</span>
<span class="go">[ 4.0 1.0 4.0]</span>
<span class="go">[ 7.0 8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
<span class="gp">>>> </span><span class="n">powm</span><span class="p">(</span><span class="n">extraprec</span><span class="p">(</span><span class="mi">5</span><span class="p">)(</span><span class="n">powm</span><span class="p">)(</span><span class="n">A</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.5</span><span class="p">),</span> <span class="o">-</span><span class="mi">1</span><span class="o">/</span><span class="p">(</span><span class="mf">1.5</span><span class="p">))</span>
<span class="go">[ 4.0 1.0 4.0]</span>
<span class="go">[ 7.0 8.0 9.0]</span>
<span class="go">[10.0 2.0 11.0]</span>
</pre></div>
</div>
<p>A Fibonacci-generating matrix:</p>
<div class="highlight-python"><div class="highlight"><pre><span class="gp">>>> </span><span class="n">powm</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">1</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">[89.0 55.0]</span>
<span class="go">[55.0 34.0]</span>
<span class="gp">>>> </span><span class="n">fib</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="go">55.0</span>
<span class="gp">>>> </span><span class="n">powm</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">1</span><span class="p">,</span><span class="mi">0</span><span class="p">]],</span> <span class="mf">6.5</span><span class="p">)</span>
<span class="go">[(16.5166626964253 - 0.0121089837381789j) (10.2078589271083 + 0.0195927472575932j)]</span>
<span class="go">[(10.2078589271083 + 0.0195927472575932j) (6.30880376931698 - 0.0317017309957721j)]</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">phi</span><span class="o">**</span><span class="mf">6.5</span> <span class="o">-</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">phi</span><span class="p">)</span><span class="o">**</span><span class="mf">6.5</span><span class="p">)</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">(10.2078589271083 - 0.0195927472575932j)</span>
<span class="gp">>>> </span><span class="n">powm</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">1</span><span class="p">,</span><span class="mi">0</span><span class="p">]],</span> <span class="mf">6.2</span><span class="p">)</span>
<span class="go">[ (14.3076953002666 - 0.008222855781077j) (8.81733464837593 + 0.0133048601383712j)]</span>
<span class="go">[(8.81733464837593 + 0.0133048601383712j) (5.49036065189071 - 0.0215277159194482j)]</span>
<span class="gp">>>> </span><span class="p">(</span><span class="n">phi</span><span class="o">**</span><span class="mf">6.2</span> <span class="o">-</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">phi</span><span class="p">)</span><span class="o">**</span><span class="mf">6.2</span><span class="p">)</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">(8.81733464837593 - 0.0133048601383712j)</span>
</pre></div>
</div>
</dd></dl>
</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="#">Matrices</a><ul>
<li><a class="reference external" href="#creating-matrices">Creating matrices</a><ul>
<li><a class="reference external" href="#basic-methods">Basic methods</a></li>
<li><a class="reference external" href="#advanced-methods">Advanced methods</a></li>
<li><a class="reference external" href="#vectors">Vectors</a></li>
<li><a class="reference external" href="#other">Other</a></li>
</ul>
</li>
<li><a class="reference external" href="#matrix-operations">Matrix operations</a><ul>
<li><a class="reference external" href="#norms">Norms</a></li>
</ul>
</li>
<li><a class="reference external" href="#linear-algebra">Linear algebra</a><ul>
<li><a class="reference external" href="#decompositions">Decompositions</a></li>
<li><a class="reference external" href="#linear-equations">Linear equations</a></li>
<li><a class="reference external" href="#matrix-factorization">Matrix factorization</a></li>
</ul>
</li>
<li><a class="reference external" href="#interval-and-double-precision-matrices">Interval and double-precision matrices</a></li>
<li><a class="reference external" href="#matrix-functions">Matrix functions</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="calculus/approximation.html"
title="previous chapter">Function approximation</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="identification.html"
title="next chapter">Number identification</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="_sources/matrices.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="identification.html" title="Number identification"
>next</a> |</li>
<li class="right" >
<a href="calculus/approximation.html" title="Function approximation"
>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
>
1246
