daniel/pylib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
4fc4903dc204a295ba9abc863e2e14fd0a4d8d1f
pylib/docs/build/html/pylib.mathematics.html
Daniel Weschke 4fc4903dc2 change data, mathematics, function, geometry and geometry_plot_pylab. add data_step, data_step_std and helper. add an example and more documentation. 
inside the data module rename read to read_columns add add new read function to read the whole file as string. add print_list function to print one element per line. add unique_list and unique_list_hashable to reduce the list into a unique list with same order. add find_last, str_between, str_to_list functions.

inside the mathematics module for vector add normalized creating a new object (normalize will change the object), isclose and iscloseto, change ang to round internal number. for matrix improve slicing and add transposed creating a new object (transpose will change object).

inside the function module add b_spline_basis, b_spline_curve_with_knots and b_spline_knots functions. add sample_hal_open and sample_half_open_seq. add circle and ellipse.

inside the geometry module change CS init from using lists to Directions and add new constructor CS.init_xzy using lists. rename Wireframe to Polyline. add classes B_spline_curve_with_knots, Ellipse, ArcCircle, ArcEllipse, ArcBSplineCurveWithKnots. add function sample_half_open to create a list of Points.

inside the geometry_plot_pylab module change the help text.

add step_and data data_step_std module to read a step file to list and draw the content.

add helper module with context manager and decorator timeit to meassure the time for a section or function.

add example for b_spline function.
2020-01-08 21:59:53 +01:00

1192 lines
86 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<title>pylib.mathematics module &#8212; pylib 2019.12.21 documentation</title>
<link rel="stylesheet" href="_static/alabaster.css" type="text/css" />
<link rel="stylesheet" href="_static/pygments.css" type="text/css" />
<link rel="stylesheet" href="_static/custom.css" type="text/css" />
<script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
<script type="text/javascript" src="_static/jquery.js"></script>
<script type="text/javascript" src="_static/underscore.js"></script>
<script type="text/javascript" src="_static/doctools.js"></script>
<script type="text/javascript" src="_static/language_data.js"></script>
<script async="async" type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
<link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" />
<link rel="next" title="pylib.time_of_day module" href="pylib.time_of_day.html" />
<link rel="prev" title="pylib.helper module" href="pylib.helper.html" />
<link rel="stylesheet" href="_static/custom.css" type="text/css" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
</head><body>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<div class="section" id="module-pylib.mathematics">
<span id="pylib-mathematics-module"></span><h1>pylib.mathematics module<a class="headerlink" href="#module-pylib.mathematics" title="Permalink to this headline"></a></h1>
<p>Mathematical functions and objects.</p>
<dl class="field-list simple">
<dt class="field-odd">Date</dt>
<dd class="field-odd"><p>2019-12-12</p>
</dd>
</dl>
<span class="target" id="module-mathematics"></span><dl class="function">
<dt id="pylib.mathematics.lcm">
<code class="sig-name descname">lcm</code><span class="sig-paren">(</span><em class="sig-param">a</em>, <em class="sig-param">b</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#lcm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.lcm" title="Permalink to this definition"></a></dt>
<dd><p>Compute the lowest common multiple of a and b</p>
</dd></dl>
<dl class="class">
<dt id="pylib.mathematics.matrix">
<em class="property">class </em><code class="sig-name descname">matrix</code><a class="reference internal" href="_modules/pylib/mathematics.html#matrix"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix" title="Permalink to this definition"></a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></p>
<p>Use/create matrix like list of lists</p>
<dl class="method">
<dt id="pylib.mathematics.matrix.__getitem__">
<code class="sig-name descname">__getitem__</code><span class="sig-paren">(</span><em class="sig-param">index</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.__getitem__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.__getitem__" title="Permalink to this definition"></a></dt>
<dd><p>For index return value, for range return new vector object.</p>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">m</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">0</span><span class="p">],</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">0</span><span class="p">],</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">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="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">[:])</span>
<span class="go">[[1, 2, 3, 0], [4, 5, 6, 0], [7, 8, 9, 0], [0, 0, 0, 0]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">[</span><span class="mi">2</span><span class="p">])</span>
<span class="go">[7, 8, 9, 0]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="p">:])</span>
<span class="go">[7, 8, 9, 0]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">[:,</span> <span class="mi">2</span><span class="p">])</span>
<span class="go">[3, 6, 9, 0]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</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="go">9</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</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="go">[[2, 3], [5, 6], [8, 9], [0, 0]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</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">1</span><span class="p">:</span><span class="mi">3</span><span class="p">])</span>
<span class="go">[[2, 3], [5, 6]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">[::</span><span class="mi">2</span><span class="p">,</span> <span class="p">::</span><span class="mi">2</span><span class="p">])</span>
<span class="go">[[1, 3], [7, 9]]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.__mul__">
<code class="sig-name descname">__mul__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.__mul__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.__mul__" title="Permalink to this definition"></a></dt>
<dd><p>Scalar multiplication, dot product (inner product) or
matrix-vector multiplication. (new object)</p>
<dl class="field-list simple">
</dl>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{C} &amp;= \mathbf{A} \cdot b \\
\mathbf{c} &amp;= \mathbf{A} \cdot \mathbf{b} \\
\mathbf{C} &amp;= \mathbf{A} \cdot \mathbf{B}\end{split}\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>No size checking will be conducted, therefore no exceptions
for wrong usage (result will be nonsense).</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">m</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="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="p">[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">12</span><span class="p">],</span> \
<span class="go"> [0, 0, 0, 1]]) * 5</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="go">[[5, 10, 15, 20], [25, 30, 35, 40], [45, 50, 55, 60], [0, 0, 0, 5]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">m</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="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="p">[</span><span class="mi">9</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">12</span><span class="p">],</span> \
<span class="go"> [0, 0, 0, 1]]) * 5.</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="go">[[5.0, 10.0, 15.0, 20.0], [25.0, 30.0, 35.0, 40.0], [45.0, 50.0, 55.0, 60.0], [0.0, 0.0, 0.0, 5.0]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</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="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="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="o">*</span> \
<span class="go"> vector([12, 12, 13])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[75, 186, 297]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">m</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="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="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="o">*</span> \
<span class="go"> matrix([[12, 12, 13], [14, 15, 16], [17, 18, 19]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="go">[[91, 96, 102], [220, 231, 246], [349, 366, 390]]</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#pylib.mathematics.matrix.__rmul__" title="pylib.mathematics.matrix.__rmul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__rmul__()</span></code></a></p>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.__repr__">
<code class="sig-name descname">__repr__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.__repr__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.__repr__" title="Permalink to this definition"></a></dt>
<dd><p>Return repr(self).</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.__rmul__">
<code class="sig-name descname">__rmul__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.__rmul__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.__rmul__" title="Permalink to this definition"></a></dt>
<dd><p>Scalar multiplication, dot product (inner product) or
vector-matrix multiplication. (new object)</p>
<dl class="field-list simple">
</dl>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{C} &amp;= a \cdot \mathbf{B} \\
\mathbf{c} &amp;= \mathbf{a} \cdot \mathbf{B} \\
\mathbf{C} &amp;= \mathbf{A} \cdot \mathbf{B}\end{split}\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>No size checking will be conducted, therefore no exceptions
for wrong usage (result will be nonsense).</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">m</span> <span class="o">=</span> <span class="mi">5</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="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="go"> [9, 10, 11, 12], [0, 0, 0, 1]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="go">[[5, 10, 15, 20], [25, 30, 35, 40], [45, 50, 55, 60], [0, 0, 0, 5]]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">m</span> <span class="o">=</span> <span class="mf">5.</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="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="go"> [9, 10, 11, 12], [0, 0, 0, 1]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="go">[[5.0, 10.0, 15.0, 20.0], [25.0, 30.0, 35.0, 40.0], [45.0, 50.0, 55.0, 60.0], [0.0, 0.0, 0.0, 5.0]]</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#pylib.mathematics.matrix.__mul__" title="pylib.mathematics.matrix.__mul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__mul__()</span></code></a> and <a class="reference internal" href="#pylib.mathematics.vector.__mul__" title="pylib.mathematics.vector.__mul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">vector.__mul__()</span></code></a> for vector * matrix</p>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.__setitem__">
<code class="sig-name descname">__setitem__</code><span class="sig-paren">(</span><em class="sig-param">index</em>, <em class="sig-param">value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.__setitem__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.__setitem__" title="Permalink to this definition"></a></dt>
<dd><p>Set self[key] to value.</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.__str__">
<code class="sig-name descname">__str__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.__str__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.__str__" title="Permalink to this definition"></a></dt>
<dd><p>Return str(self).</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.rotate_x">
<code class="sig-name descname">rotate_x</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.rotate_x"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.rotate_x" title="Permalink to this definition"></a></dt>
<dd><p>Rotation about the x dirction.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x \\
yx' &amp; yy' &amp; yz' &amp; t_y' \\
zx' &amp; zy' &amp; zz' &amp; t_z' \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix} =
\begin{bmatrix}
1 &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; \cos \theta &amp; -\sin \theta &amp; 0 \\
0 &amp; \sin \theta &amp; \cos \theta &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}
\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x \\
yx &amp; yy &amp; yz &amp; t_y \\
zx &amp; zy &amp; zz &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.rotate_y">
<code class="sig-name descname">rotate_y</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.rotate_y"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.rotate_y" title="Permalink to this definition"></a></dt>
<dd><p>Rotation about the y dirction.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}
xx' &amp; xy' &amp; xz' &amp; t_x' \\
yx &amp; yy &amp; yz &amp; t_y \\
zx' &amp; zy' &amp; zz' &amp; t_z' \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix} =
\begin{bmatrix}
\cos \theta &amp; 0 &amp; \sin \theta &amp; 0 \\
0 &amp; 1 &amp; 0 &amp; 0 \\
-\sin \theta &amp; 0 &amp; \cos \theta &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}
\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x \\
yx &amp; yy &amp; yz &amp; t_y \\
zx &amp; zy &amp; zz &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.rotate_z">
<code class="sig-name descname">rotate_z</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.rotate_z"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.rotate_z" title="Permalink to this definition"></a></dt>
<dd><p>Rotation about the z dirction.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}
xx' &amp; xy' &amp; xz' &amp; t_x' \\
yx' &amp; yy' &amp; yz' &amp; t_y' \\
zx &amp; zy &amp; zz &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix} =
\begin{bmatrix}
\cos \theta &amp; -\sin \theta &amp; 0 &amp; 0 \\
\sin \theta &amp; \cos \theta &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; 1 &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x \\
yx &amp; yy &amp; yz &amp; t_y \\
zx &amp; zy &amp; zz &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.rx">
<em class="property">static </em><code class="sig-name descname">rx</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.rx"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.rx" title="Permalink to this definition"></a></dt>
<dd><p>Rotation matrix about the x direction.</p>
<p>Rotates the coordinate system of vectors</p>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{R}_{x}(\theta) =
\begin{bmatrix}
1 &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; \cos \theta &amp; -\sin \theta &amp; 0 \\
0 &amp; \sin \theta &amp; \cos \theta &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.ry">
<em class="property">static </em><code class="sig-name descname">ry</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.ry"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.ry" title="Permalink to this definition"></a></dt>
<dd><p>Rotation matrix about the y direction.</p>
<p>Rotates the coordinate system of vectors</p>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{R}_{y}(\theta) =
\begin{bmatrix}
\cos \theta &amp; 0 &amp; \sin \theta &amp; 0 \\
0 &amp; 1 &amp; 0 &amp; 0 \\
-\sin \theta &amp; 0 &amp; \cos \theta &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.rz">
<em class="property">static </em><code class="sig-name descname">rz</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.rz"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.rz" title="Permalink to this definition"></a></dt>
<dd><p>Rotation matrix about the z direction.</p>
<p>Rotates the coordinate system of vectors</p>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{R}_{z}(\theta) =
\begin{bmatrix}
\cos \theta &amp; -\sin \theta &amp; 0 &amp; 0 \\
\sin \theta &amp; \cos \theta &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; 1 &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}\end{split}\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{R}_{z}(\theta)
\begin{bmatrix}1 \\ 0 \\ 0 \\ 1\end{bmatrix}
&amp;=
\begin{bmatrix}
\cos 90° &amp; -\sin 90° &amp; 0 &amp; 0 \\
\sin 90° &amp; \cos 90° &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; 1 &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}1 \\ 0 \\ 0 \\ 1\end{bmatrix} \\
&amp;=
\begin{bmatrix}
0 &amp; -1 &amp; 0 &amp; 0 \\
1 &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; 1 &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}1 \\ 0 \\ 0 \\ 1\end{bmatrix} =
\begin{bmatrix}0 \\ 1 \\ 0 \\ 1\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.s">
<em class="property">static </em><code class="sig-name descname">s</code><span class="sig-paren">(</span><em class="sig-param">sx</em>, <em class="sig-param">sy=None</em>, <em class="sig-param">sz=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.s"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.s" title="Permalink to this definition"></a></dt>
<dd><p>Scaling matrix</p>
<p>uniform scaling if sx=sy=sz=s.
Note that scaling happens around the origin, so objects not
centered at the origin will have their centers move. To avoid
this, either scale the object when it’s located at the origin,
or perform a translation afterwards to move the object back to
where it should be.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{S} =
\begin{bmatrix}
s_x &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; s_y &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; s_z &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.scale">
<code class="sig-name descname">scale</code><span class="sig-paren">(</span><em class="sig-param">sx</em>, <em class="sig-param">sy=None</em>, <em class="sig-param">sz=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.scale"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.scale" title="Permalink to this definition"></a></dt>
<dd><p>Scaling</p>
<p>uniform scaling if sx=sy=sz=s.
Note that scaling happens around the origin, so objects not
centered at the origin will have their centers move. To avoid
this, either scale the object when it’s located at the origin,
or perform a translation afterwards to move the object back to
where it should be.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}
xx' &amp; xy' &amp; xz' &amp; t_x' \\
yx' &amp; yy' &amp; yz' &amp; t_y' \\
zx' &amp; zy' &amp; zz' &amp; t_z' \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix} =
\begin{bmatrix}
s_x &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; s_y &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; s_z &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x \\
yx &amp; yy &amp; yz &amp; t_y \\
zx &amp; zy &amp; zz &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.t">
<em class="property">static </em><code class="sig-name descname">t</code><span class="sig-paren">(</span><em class="sig-param">tx</em>, <em class="sig-param">ty</em>, <em class="sig-param">tz</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.t"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.t" title="Permalink to this definition"></a></dt>
<dd><p>Translation matrix</p>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{T} =
\begin{bmatrix}
1 &amp; 0 &amp; 0 &amp; t_x \\
0 &amp; 1 &amp; 0 &amp; t_y \\
0 &amp; 0 &amp; 1 &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.translate">
<code class="sig-name descname">translate</code><span class="sig-paren">(</span><em class="sig-param">tx</em>, <em class="sig-param">ty</em>, <em class="sig-param">tz</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.translate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.translate" title="Permalink to this definition"></a></dt>
<dd><p>Translation</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x' \\
yx &amp; yy &amp; yz &amp; t_y' \\
zx &amp; zy &amp; zz &amp; t_z' \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix} =
\begin{bmatrix}
1 &amp; 0 &amp; 0 &amp; t_x \\
0 &amp; 1 &amp; 0 &amp; t_y \\
0 &amp; 0 &amp; 1 &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}
xx &amp; xy &amp; xz &amp; t_x \\
yx &amp; yy &amp; yz &amp; t_y \\
zx &amp; zy &amp; zz &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; h
\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.transpose">
<code class="sig-name descname">transpose</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.transpose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.transpose" title="Permalink to this definition"></a></dt>
<dd><p>Transpose</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.transposed">
<em class="property">static </em><code class="sig-name descname">transposed</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.transposed"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.transposed" title="Permalink to this definition"></a></dt>
<dd><p>Transpose</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.matrix.zeros">
<em class="property">static </em><code class="sig-name descname">zeros</code><span class="sig-paren">(</span><em class="sig-param">m</em>, <em class="sig-param">n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#matrix.zeros"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.matrix.zeros" title="Permalink to this definition"></a></dt>
<dd><p>Returns a zero matrix of size mxn; m rows and n columns
filled with zeros.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>m</strong> (<em>int</em>) – number of rows of the matrix, e. g. 3</p></li>
<li><p><strong>n</strong> (<em>int</em>) – number of columns of the matrix, e. g. 3</p></li>
</ul>
</dd>
<dt class="field-even">Example</dt>
<dd class="field-even"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">m</span> <span class="o">=</span> <span class="n">matrix</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span> <span class="p">[[</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">],</span> <span class="p">[</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">],</span> <span class="p">[</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">]]</span>
</pre></div>
</div>
</dd></dl>
</dd></dl>
<dl class="class">
<dt id="pylib.mathematics.vector">
<em class="property">class </em><code class="sig-name descname">vector</code><a class="reference internal" href="_modules/pylib/mathematics.html#vector"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector" title="Permalink to this definition"></a></dt>
<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">list</span></code></p>
<p>Use/create vector like lists</p>
<ul class="simple">
<li><p>size, length of a vector use len(a)</p></li>
<li><p>absolute, magntude, norm of a vector use abs(a), see
<a class="reference internal" href="#pylib.mathematics.vector.__abs__" title="pylib.mathematics.vector.__abs__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__abs__()</span></code></a></p></li>
<li><p>dot product use a * b, see <a class="reference internal" href="#pylib.mathematics.vector.__mul__" title="pylib.mathematics.vector.__mul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__mul__()</span></code></a> and <a class="reference internal" href="#pylib.mathematics.vector.__rmul__" title="pylib.mathematics.vector.__rmul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__rmul__()</span></code></a></p></li>
<li><p>outer product use a &#64; b, see <a class="reference internal" href="#pylib.mathematics.vector.__matmul__" title="pylib.mathematics.vector.__matmul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__matmul__()</span></code></a></p></li>
</ul>
<dl class="field-list simple">
<dt class="field-odd">__iter__</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="p">[</span><span class="n">i</span><span class="o">*</span><span class="mi">2</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="n">vector</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">[2, 4, 6]</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__setitem__</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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="mi">5</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span><span class="p">[</span><span class="mi">3</span><span class="p">:</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[1, 2, 3, 1, 2]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">isinstance</span><span class="p">(</span><span class="n">v</span><span class="p">,</span> <span class="n">vector</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__eq__(a, b)</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span> <span class="o">==</span> <span class="n">vector</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span> <span class="o">==</span> <span class="n">vector</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">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">False</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__ne__(a, b)</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span> <span class="o">!=</span> <span class="n">vector</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
<span class="go">False</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span> <span class="o">!=</span> <span class="n">vector</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">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">True</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__contains__</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="mi">2</span> <span class="ow">in</span> <span class="n">vector</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">True</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__isub__</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">-=</span> <span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[-2, -1, 0]</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__imul__</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">*=</span> <span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">18</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">__imatmul__</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">m</span> <span class="o">=</span> <span class="n">vector</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">&gt;&gt;&gt; </span><span class="n">m</span> <span class="o">*=</span> <span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[[3, 3, 3], [6, 6, 6], [9, 9, 9]]</span>
</pre></div>
</div>
<dl class="method">
<dt id="pylib.mathematics.vector.__abs__">
<code class="sig-name descname">__abs__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__abs__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__abs__" title="Permalink to this definition"></a></dt>
<dd><p>Magnitude / norm of a vector</p>
<div class="math notranslate nohighlight">
\[b = |\mathbf{a}| = \sqrt{\sum a_i^2} =
\sqrt{\mathbf{a} \cdot \mathbf{a}}\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">&gt;&gt;&gt; </span><span class="nb">abs</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">5.0</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__add__">
<code class="sig-name descname">__add__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__add__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__add__" title="Permalink to this definition"></a></dt>
<dd><p>a + b (new object)</p>
<div class="math notranslate nohighlight">
\[\mathbf{c} = \mathbf{a} + \mathbf{b}\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">vector</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">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[2, 4, 6]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__ge__">
<code class="sig-name descname">__ge__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__ge__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__ge__" title="Permalink to this definition"></a></dt>
<dd><p>Test if this object is greater (larger) than or equal the
other object.</p>
<div class="math notranslate nohighlight">
\[|\mathbf{a}| \ge |\mathbf{b}|\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">&gt;=</span> <span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">&gt;=</span> <span class="n">vector</span><span class="p">([</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">False</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__getitem__">
<code class="sig-name descname">__getitem__</code><span class="sig-paren">(</span><em class="sig-param">index</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__getitem__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__getitem__" title="Permalink to this definition"></a></dt>
<dd><p>For index return value, for range return new vector object.</p>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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="mi">5</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</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="go">[2, 3]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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="mi">5</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span>
<span class="go">4</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__gt__">
<code class="sig-name descname">__gt__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__gt__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__gt__" title="Permalink to this definition"></a></dt>
<dd><p>Test if this object is greater (larger) than the other
object.</p>
<div class="math notranslate nohighlight">
\[|\mathbf{a}| \gt |\mathbf{b}|\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">&gt;</span> <span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">False</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vector</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">&gt;</span> <span class="n">vector</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">1</span><span class="p">])</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__iadd__">
<code class="sig-name descname">__iadd__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__iadd__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__iadd__" title="Permalink to this definition"></a></dt>
<dd><p>a += b (new object)</p>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">+=</span> <span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[4, 5, 6]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__le__">
<code class="sig-name descname">__le__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__le__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__le__" title="Permalink to this definition"></a></dt>
<dd><p>Test if this object is lower (smaller) than or equal the
other object.</p>
<div class="math notranslate nohighlight">
\[|\mathbf{a}| \le |\mathbf{b}|\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span> <span class="o">&lt;=</span> <span class="n">vector</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">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span> <span class="o">&lt;=</span> <span class="n">vector</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="go">False</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__lt__">
<code class="sig-name descname">__lt__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__lt__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__lt__" title="Permalink to this definition"></a></dt>
<dd><p>Test if this object is lower (smaller) than the other object.</p>
<div class="math notranslate nohighlight">
\[|\mathbf{a}| \lt |\mathbf{b}|\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span> <span class="o">&lt;</span> <span class="n">vector</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">False</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vector</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span> <span class="o">&lt;</span> <span class="n">vector</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">4</span><span class="p">])</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__matmul__">
<code class="sig-name descname">__matmul__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__matmul__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__matmul__" title="Permalink to this definition"></a></dt>
<dd><p>Outer product a &#64; b (new object)</p>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{c} = \mathbf{a} \otimes \mathbf{b}
=
\begin{pmatrix}
a_{1}\\
a_{2}\\
a_{3}
\end{pmatrix}
\otimes
\begin{pmatrix}
b_{1}\\
b_{2}\\
b_{3}
\end{pmatrix}
=
\begin{pmatrix}
a_{1}b_{1}&amp;a_{1}b_{2}&amp;a_{1}b_{3}\\
a_{2}b_{1}&amp;a_{2}b_{2}&amp;a_{2}b_{3}\\
a_{3}b_{1}&amp;a_{3}b_{2}&amp;a_{3}b_{3}
\end{pmatrix}\end{split}\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">m</span> <span class="o">=</span> <span class="n">vector</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">vector</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">4</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
<span class="go">[[1, 2, 4], [2, 4, 8], [3, 6, 12]]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__mul__">
<code class="sig-name descname">__mul__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__mul__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__mul__" title="Permalink to this definition"></a></dt>
<dd><p>Scalar multiplication, dot product (inner product) or
vector-matrix multiplication. (new object)</p>
<dl class="field-list simple">
</dl>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{c} &amp;= \mathbf{a} \cdot b \\
\mathbf{c} &amp;= \mathbf{a} \cdot \mathbf{b} \\
\mathbf{c} &amp;= \mathbf{a} \cdot \mathbf{B}\end{split}\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>No size checking will be conducted, therefore no exceptions
for wrong usage (result will be nonsense).</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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="mi">5</span><span class="p">])</span> <span class="o">*</span> <span class="mi">3</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[3, 6, 9, 12, 15]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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="mi">5</span><span class="p">])</span> <span class="o">*</span> <span class="mf">3.</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[3.0, 6.0, 9.0, 12.0, 15.0]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">s</span> <span class="o">=</span> <span class="n">vector</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">vector</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">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">s</span><span class="p">)</span>
<span class="go">14</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#pylib.mathematics.vector.__rmul__" title="pylib.mathematics.vector.__rmul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__rmul__()</span></code></a></p>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__neg__">
<code class="sig-name descname">__neg__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__neg__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__neg__" title="Permalink to this definition"></a></dt>
<dd><p>- a (new object)</p>
<div class="math notranslate nohighlight">
\[\mathbf{b} = -\mathbf{a}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__pos__">
<code class="sig-name descname">__pos__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__pos__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__pos__" title="Permalink to this definition"></a></dt>
<dd><p>+ a (new object)</p>
<div class="math notranslate nohighlight">
\[\mathbf{b} = +\mathbf{a}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__repr__">
<code class="sig-name descname">__repr__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__repr__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__repr__" title="Permalink to this definition"></a></dt>
<dd><p>Return repr(self).</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__rmul__">
<code class="sig-name descname">__rmul__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__rmul__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__rmul__" title="Permalink to this definition"></a></dt>
<dd><p>Scalar multiplication, dot product (inner product) or
matrix-vector multiplication. (new object)</p>
<dl class="field-list simple">
</dl>
<div class="math notranslate nohighlight">
\[\begin{split}\mathbf{c} &amp;= a \cdot \mathbf{b} \\
\mathbf{c} &amp;= \mathbf{a} \cdot \mathbf{b} \\
\mathbf{c} &amp;= \mathbf{A} \cdot \mathbf{b}\end{split}\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>No size checking will be conducted, therefore no exceptions
for wrong usage (result will be nonsense).</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="mi">3</span> <span class="o">*</span> <span class="n">vector</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="mi">5</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[3, 6, 9, 12, 15]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="mf">3.</span> <span class="o">*</span> <span class="n">vector</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="mi">5</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[3.0, 6.0, 9.0, 12.0, 15.0]</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#pylib.mathematics.vector.__mul__" title="pylib.mathematics.vector.__mul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__mul__()</span></code></a> and <a class="reference internal" href="#pylib.mathematics.matrix.__mul__" title="pylib.mathematics.matrix.__mul__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">matrix.__mul__()</span></code></a> for matrix * vector</p>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__str__">
<code class="sig-name descname">__str__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__str__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__str__" title="Permalink to this definition"></a></dt>
<dd><p>Return str(self).</p>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.__sub__">
<code class="sig-name descname">__sub__</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.__sub__"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.__sub__" title="Permalink to this definition"></a></dt>
<dd><p>a - b (new object)</p>
<div class="math notranslate nohighlight">
\[\mathbf{c} = \mathbf{a} - \mathbf{b}\]</div>
<dl class="field-list simple">
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">vector</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">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[0, 0, 0]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.abs">
<em class="property">static </em><code class="sig-name descname">abs</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.abs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.abs" title="Permalink to this definition"></a></dt>
<dd><p>Return modulus parts of a complex vector</p>
<dl class="field-list simple">
</dl>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.ang">
<em class="property">static </em><code class="sig-name descname">ang</code><span class="sig-paren">(</span><em class="sig-param">a</em>, <em class="sig-param">b</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.ang"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.ang" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.arg">
<em class="property">static </em><code class="sig-name descname">arg</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.arg"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.arg" title="Permalink to this definition"></a></dt>
<dd><p>Return phase parts of a complex vector</p>
<dl class="field-list simple">
</dl>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.ch_cs">
<code class="sig-name descname">ch_cs</code><span class="sig-paren">(</span><em class="sig-param">cs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.ch_cs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.ch_cs" title="Permalink to this definition"></a></dt>
<dd><p>Transform this vector from its defined coordinate system to
a new coordinate system, defined by the given coordinate system
(u, v and w direction vectors).</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} =
\begin{bmatrix}
u_x &amp; u_y &amp; u_z &amp; 0 \\
v_x &amp; v_y &amp; v_z &amp; 0 \\
w_x &amp; w_y &amp; w_z &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.conjugate">
<em class="property">static </em><code class="sig-name descname">conjugate</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.conjugate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.conjugate" title="Permalink to this definition"></a></dt>
<dd><p>New vector object</p>
<dl class="field-list simple">
</dl>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.cross">
<em class="property">static </em><code class="sig-name descname">cross</code><span class="sig-paren">(</span><em class="sig-param">a</em>, <em class="sig-param">b</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.cross"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.cross" title="Permalink to this definition"></a></dt>
<dd><p>Cross product</p>
<dl class="field-list simple">
</dl>
<p>c is orthogonal to both a and b.
The direction of c can be found with the right-hand rule.</p>
<div class="math notranslate nohighlight">
\[\mathbf{c} = \mathbf{a} \times \mathbf{b}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.full">
<em class="property">static </em><code class="sig-name descname">full</code><span class="sig-paren">(</span><em class="sig-param">length</em>, <em class="sig-param">fill_value</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.full"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.full" title="Permalink to this definition"></a></dt>
<dd><p>Returns a vector of length m filled with v.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>length</strong> (<em>int</em>) – length of the vector, e. g. 3</p></li>
<li><p><strong>fill_value</strong> – fill value</p></li>
</ul>
</dd>
<dt class="field-even">Type fill_value</dt>
<dd class="field-even"><p>scalar</p>
</dd>
<dt class="field-odd">Example</dt>
<dd class="field-odd"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</span><span class="o">.</span><span class="n">full</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">7</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[7, 7, 7]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.im">
<em class="property">static </em><code class="sig-name descname">im</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.im"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.im" title="Permalink to this definition"></a></dt>
<dd><p>Return the imaginary parts of a complex vector</p>
<dl class="field-list simple">
</dl>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.isclose">
<em class="property">static </em><code class="sig-name descname">isclose</code><span class="sig-paren">(</span><em class="sig-param">a</em>, <em class="sig-param">b</em>, <em class="sig-param">rel_tol=0.05</em>, <em class="sig-param">abs_tol=1e-08</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.isclose"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.isclose" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.iscloseto">
<code class="sig-name descname">iscloseto</code><span class="sig-paren">(</span><em class="sig-param">other</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.iscloseto"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.iscloseto" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.normalize">
<code class="sig-name descname">normalize</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.normalize"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.normalize" title="Permalink to this definition"></a></dt>
<dd><p>Normalize a vector (i. e. the vector has a length of 1)</p>
<dl class="field-list simple">
</dl>
<div class="math notranslate nohighlight">
\[\mathbf{\hat{a}} = \frac{\mathbf{a}}{|\mathbf{a}|}\]</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#pylib.mathematics.vector.__abs__" title="pylib.mathematics.vector.__abs__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__abs__()</span></code></a> for a norm (magnitude) of a vector</p>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.normalized">
<em class="property">static </em><code class="sig-name descname">normalized</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.normalized"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.normalized" title="Permalink to this definition"></a></dt>
<dd><p>Normalize a vector (i. e. the vector has a length of 1)</p>
<dl class="field-list simple">
</dl>
<div class="math notranslate nohighlight">
\[\mathbf{\hat{a}} = \frac{\mathbf{a}}{|\mathbf{a}|}\]</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#pylib.mathematics.vector.__abs__" title="pylib.mathematics.vector.__abs__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__abs__()</span></code></a> for a norm (magnitude) of a vector</p>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.ones">
<em class="property">static </em><code class="sig-name descname">ones</code><span class="sig-paren">(</span><em class="sig-param">length</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.ones"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.ones" title="Permalink to this definition"></a></dt>
<dd><p>Returns a vector of length m filled with ones.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>length</strong> (<em>int</em>) – lhape of the vector, e. g. 3</p>
</dd>
<dt class="field-even">Example</dt>
<dd class="field-even"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</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">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[1.0, 1.0, 1.0]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.random">
<em class="property">static </em><code class="sig-name descname">random</code><span class="sig-paren">(</span><em class="sig-param">length</em>, <em class="sig-param">lmin=0.0</em>, <em class="sig-param">lmax=1.0</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.random"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.random" title="Permalink to this definition"></a></dt>
<dd><p>Returns a random vector of length n filled with random
numbers.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>length</strong> (<em>int</em>) – lhape of the vector, e. g. 3</p>
</dd>
<dt class="field-even">Example</dt>
<dd class="field-even"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</span><span class="o">.</span><span class="n">random</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[0.9172905912930438, 0.8908124278322492, 0.5256002790725927]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</span><span class="o">.</span><span class="n">random</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[1.2563665665080803, 1.9270454509964547, 1.2381672401270487]</span>
</pre></div>
</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.re">
<em class="property">static </em><code class="sig-name descname">re</code><span class="sig-paren">(</span><em class="sig-param">a</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.re"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.re" title="Permalink to this definition"></a></dt>
<dd><p>Return the real parts of a complex vector</p>
<dl class="field-list simple">
</dl>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.rotate_x">
<code class="sig-name descname">rotate_x</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.rotate_x"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.rotate_x" title="Permalink to this definition"></a></dt>
<dd><p>Rotation about the x dirction.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} =
\begin{bmatrix}
1 &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; \cos \theta &amp; -\sin \theta &amp; 0 \\
0 &amp; \sin \theta &amp; \cos \theta &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.rotate_y">
<code class="sig-name descname">rotate_y</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.rotate_y"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.rotate_y" title="Permalink to this definition"></a></dt>
<dd><p>Rotation about the y dirction.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} =
\begin{bmatrix}
\cos \theta &amp; 0 &amp; \sin \theta &amp; 0 \\
0 &amp; 1 &amp; 0 &amp; 0 \\
-\sin \theta &amp; 0 &amp; \cos \theta &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.rotate_z">
<code class="sig-name descname">rotate_z</code><span class="sig-paren">(</span><em class="sig-param">theta</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.rotate_z"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.rotate_z" title="Permalink to this definition"></a></dt>
<dd><p>Rotation about the z dirction.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} =
\begin{bmatrix}
\cos \theta &amp; -\sin \theta &amp; 0 &amp; 0 \\
\sin \theta &amp; \cos \theta &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; 1 &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.scale">
<code class="sig-name descname">scale</code><span class="sig-paren">(</span><em class="sig-param">sx</em>, <em class="sig-param">sy=None</em>, <em class="sig-param">sz=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.scale"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.scale" title="Permalink to this definition"></a></dt>
<dd><p>Scaling</p>
<p>uniform scaling if sx=sy=sz=s.
Note that scaling happens around the origin, so objects not
centered at the origin will have their centers move. To avoid
this, either scale the object when it’s located at the origin,
or perform a translation afterwards to move the object back to
where it should be.</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} =
\begin{bmatrix}
s_x &amp; 0 &amp; 0 &amp; 0 \\
0 &amp; s_y &amp; 0 &amp; 0 \\
0 &amp; 0 &amp; s_z &amp; 0 \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.translate">
<code class="sig-name descname">translate</code><span class="sig-paren">(</span><em class="sig-param">tx</em>, <em class="sig-param">ty</em>, <em class="sig-param">tz</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.translate"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.translate" title="Permalink to this definition"></a></dt>
<dd><p>Translation</p>
<div class="math notranslate nohighlight">
\[\begin{split}\begin{bmatrix}x' \\ y' \\ z' \\ h'\end{bmatrix} =
\begin{bmatrix}
1 &amp; 0 &amp; 0 &amp; t_x \\
0 &amp; 1 &amp; 0 &amp; t_y \\
0 &amp; 0 &amp; 1 &amp; t_z \\
0 &amp; 0 &amp; 0 &amp; 1
\end{bmatrix}
\begin{bmatrix}x \\ y \\ z \\ h\end{bmatrix}\end{split}\]</div>
</dd></dl>
<dl class="method">
<dt id="pylib.mathematics.vector.zeros">
<em class="property">static </em><code class="sig-name descname">zeros</code><span class="sig-paren">(</span><em class="sig-param">length</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/pylib/mathematics.html#vector.zeros"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#pylib.mathematics.vector.zeros" title="Permalink to this definition"></a></dt>
<dd><p>Returns a zero vector of length m filled with zeros.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>length</strong> (<em>int</em>) – length of the vector, e. g. 3</p>
</dd>
<dt class="field-even">Example</dt>
<dd class="field-even"><p></p></dd>
</dl>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">vector</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">print</span><span class="p">(</span><span class="n">v</span><span class="p">)</span>
<span class="go">[0.0, 0.0, 0.0]</span>
</pre></div>
</div>
</dd></dl>
</dd></dl>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="index.html">pylib</a></h1>
<h3>Navigation</h3>
<p class="caption"><span class="caption-text">Contents:</span></p>
<ul class="current">
<li class="toctree-l1 current"><a class="reference internal" href="modules.html">pylib</a><ul class="current">
<li class="toctree-l2 current"><a class="reference internal" href="pylib.html">pylib package</a></li>
</ul>
</li>
</ul>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="index.html">Documentation overview</a><ul>
<li><a href="modules.html">pylib</a><ul>
<li><a href="pylib.html">pylib package</a><ul>
<li>Previous: <a href="pylib.helper.html" title="previous chapter">pylib.helper module</a></li>
<li>Next: <a href="pylib.time_of_day.html" title="next chapter">pylib.time_of_day module</a></li>
</ul></li>
</ul></li>
</ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" />
<input type="submit" value="Go" />
</form>
</div>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
&copy;2019, Daniel Weschke.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 2.2.1</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|
<a href="_sources/pylib.mathematics.rst.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink