daniel/pylib
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add time module and move fixed-point iteration to own function

Browse Source
This commit is contained in:
Daniel Weschke
2019-06-01 15:51:35 +02:00
parent 0162ce2701
commit 4ec84c49ac
18 changed files with 1148 additions and 270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
docs/build/html/_modules/data.html vendored
View File

@@ -89,7 +89,7 @@
<span class="n">object_data</span> <span class="o">=</span> <span class="n">pickle</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span> <span class="c1"># one load for every dump is needed to load all the data</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;found:&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">object_data</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">object_data</span><span class="p">)</span>
<span class="k">except</span> <span class="ne">IOError</span><span class="p">:</span>
<span class="n">object_data</span> <span class="o">=</span> <span class="kc">None</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

1
docs/build/html/_modules/index.html vendored
View File

@@ -40,6 +40,7 @@
<li><a href="numerical/integration.html">numerical.integration</a></li>
<li><a href="numerical/ode.html">numerical.ode</a></li>
<li><a href="numerical/ode_model.html">numerical.ode_model</a></li>
<li><a href="time_of_day.html">time_of_day</a></li>
</ul>
</div>

221
docs/build/html/_modules/numerical/ode.html vendored
View File

@@ -37,8 +37,8 @@
<span class="c1"># -*- coding: utf-8 -*-</span>
<span class="sd">&quot;&quot;&quot;Numerical solver of ordinary differential equations.</span>
<span class="sd">Solves the initial value problem for systems of first order ordinary differential</span>
<span class="sd">equations.</span>
<span class="sd">Solves the initial value problem for systems of first order</span>
<span class="sd">ordinary differential equations.</span>
<span class="sd">:Date: 2015-09-21</span>
@@ -68,7 +68,8 @@
<span class="sd"> :type x0: list</span>
<span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span>
@@ -83,14 +84,14 @@
<span class="sd"> .. math ::</span>
<span class="sd"> t_i = t_0 + i h ~,\quad i=1,2,\ldots,n</span>
<span class="sd"> The derivative of the solution is approximated as the forward difference</span>
<span class="sd"> equation</span>
<span class="sd"> The derivative of the solution is approximated as the forward</span>
<span class="sd"> difference equation</span>
<span class="sd"> </span>
<span class="sd"> .. math ::</span>
<span class="sd"> \dot{x}_i = f(t_i, x_i) = \frac{x_{i+1} - x_i}{t_{i+1}-t_i}</span>
<span class="sd"> Therefore one step :math:`h` of the Euler method from :math:`t_i` to</span>
<span class="sd"> :math:`t_{i+1}` is</span>
<span class="sd"> Therefore one step :math:`h` of the Euler method from</span>
<span class="sd"> :math:`t_i` to :math:`t_{i+1}` is</span>
<span class="sd"> .. math ::</span>
<span class="sd"> x_{i+1} &amp;= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\</span>
@@ -119,7 +120,8 @@
<span class="sd"> .. math ::</span>
<span class="sd"> \dot{x} &amp;= f(t,x) \\</span>
<span class="sd"> \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=</span>
<span class="sd"> \begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1) \end{bmatrix} \\</span>
<span class="sd"> \begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1)</span>
<span class="sd"> \end{bmatrix} \\</span>
<span class="sd"> &amp;=</span>
<span class="sd"> \begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +</span>
<span class="sd"> \begin{bmatrix} 0 &amp; 1 \\ -m^{-1} k &amp; -m^{-1} d \end{bmatrix}</span>
@@ -141,32 +143,39 @@
<span class="sd"> .. math ::</span>
<span class="sd"> \dot{x}_1 &amp;= x_2 \\</span>
<span class="sd"> \dot{x}_2 &amp;= m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\</span>
<span class="sd"> \dot{x}_2 &amp;=</span>
<span class="sd"> m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\</span>
<span class="sd"> or</span>
<span class="sd"> .. math ::</span>
<span class="sd"> \dot{x} &amp;= f(t,x) \\</span>
<span class="sd"> \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=</span>
<span class="sd"> \begin{bmatrix} x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \end{bmatrix} \\</span>
<span class="sd"> \begin{bmatrix}</span>
<span class="sd"> x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1)</span>
<span class="sd"> \end{bmatrix} \\</span>
<span class="sd"> &amp;=</span>
<span class="sd"> \begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} +</span>
<span class="sd"> \begin{bmatrix} 0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2) \end{bmatrix}</span>
<span class="sd"> \begin{bmatrix}</span>
<span class="sd"> 0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2)</span>
<span class="sd"> \end{bmatrix}</span>
<span class="sd"> \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}</span>
<span class="sd"> The Euler method is a first-order method,</span>
<span class="sd"> which means that the local error (error per step) is proportional to the</span>
<span class="sd"> square of the step size, and the global error (error at a given time) is</span>
<span class="sd"> The Euler method is a first-order method, which means that the</span>
<span class="sd"> local error (error per step) is proportional to the square of</span>
<span class="sd"> the step size, and the global error (error at a given time) is</span>
<span class="sd"> proportional to the step size.</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span> <span class="c1"># Calculation loop</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span> <span class="c1"># Calculation loop</span>
<span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">dxdt</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">dxdt</span><span class="o">*</span><span class="n">Dt</span> <span class="c1"># Approximate solution at next value of x</span>
<span class="c1"># Approximate solution at next value of x</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">dxdt</span><span class="o">*</span><span class="n">Dt</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit first-order method (Euler / Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit &#39;</span> <span class="o">+</span>
<span class="s1">&#39;first-order method (Euler / Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span></div>
<div class="viewcode-block" id="e2"><a class="viewcode-back" href="../../numerical.html#numerical.ode.e2">[docs]</a><span class="k">def</span> <span class="nf">e2</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
@@ -178,19 +187,22 @@
<span class="sd"> :type x0: list</span>
<span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span> <span class="c1"># Calculation loop</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span> <span class="c1"># Calculation loop</span>
<span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">k_1</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">k_2</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="o">*</span><span class="n">k_1</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">k_2</span><span class="o">*</span><span class="n">Dt</span> <span class="c1"># Approximate solution at next value of x</span>
<span class="c1"># Approximate solution at next value of x</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">k_2</span><span class="o">*</span><span class="n">Dt</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit 2th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit &#39;</span> <span class="o">+</span>
<span class="s1">&#39;2th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span></div>
<div class="viewcode-block" id="e4"><a class="viewcode-back" href="../../numerical.html#numerical.ode.e4">[docs]</a><span class="k">def</span> <span class="nf">e4</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
@@ -202,7 +214,8 @@
<span class="sd"> :type x0: list</span>
<span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span>
<span class="sd"> &quot;&quot;&quot;</span>
@@ -214,70 +227,64 @@
<span class="n">k_2</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="o">*</span><span class="n">k_1</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">k_3</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="o">*</span><span class="n">k_2</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">k_4</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="n">k_3</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="mf">1.</span><span class="o">/</span><span class="mi">6</span><span class="o">*</span><span class="p">(</span><span class="n">k_1</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_2</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_3</span><span class="o">+</span><span class="n">k_4</span><span class="p">)</span><span class="o">*</span><span class="n">Dt</span> <span class="c1"># Approximate solution at next value of x</span>
<span class="c1"># Approximate solution at next value of x</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="mf">1.</span><span class="o">/</span><span class="mi">6</span><span class="o">*</span><span class="p">(</span><span class="n">k_1</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_2</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_3</span><span class="o">+</span><span class="n">k_4</span><span class="p">)</span><span class="o">*</span><span class="n">Dt</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit 4th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit &#39;</span> <span class="o">+</span>
<span class="s1">&#39;4th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span></div>
<div class="viewcode-block" id="dxdt_Dt"><a class="viewcode-back" href="../../numerical.html#numerical.ode.dxdt_Dt">[docs]</a><span class="k">def</span> <span class="nf">dxdt_Dt</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> :param f: :math:`f = \dot{x}`</span>
<span class="sd"> :type f: function</span>
<span class="sd"> :param Dt: :math:`\Delta{t}`</span>
<div class="viewcode-block" id="fpi"><a class="viewcode-back" href="../../numerical.html#numerical.ode.fpi">[docs]</a><span class="k">def</span> <span class="nf">fpi</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">ti</span><span class="p">,</span> <span class="n">ti1</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span>
<span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;Fixed-point iteration.</span>
<span class="sd"> </span>
<span class="sd"> :returns: :math:`\Delta x = \dot{x} \Delta t`</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">array</span><span class="p">(</span><span class="n">dxdt</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span> <span class="o">*</span> <span class="n">Dt</span></div>
<div class="viewcode-block" id="fixed_point_iteration"><a class="viewcode-back" href="../../numerical.html#numerical.ode.fixed_point_iteration">[docs]</a><span class="k">def</span> <span class="nf">fixed_point_iteration</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;</span>
<span class="sd"> :param f: the function to iterate :math:`f = \Delta{x}(t)`</span>
<span class="sd"> :param f: the function to iterate :math:`f = \dot{x}(x,t)`</span>
<span class="sd"> :type f: function</span>
<span class="sd"> :param xi: initial condition :math:`x_i`</span>
<span class="sd"> :type xi: list</span>
<span class="sd"> :param t: time :math:`t`</span>
<span class="sd"> :type t: float</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param ti: time :math:`t_i`</span>
<span class="sd"> :type ti: float</span>
<span class="sd"> :param ti1: time :math:`t_{i+1}`</span>
<span class="sd"> :type ti1: float</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param max_iterations: maximum number of iterations</span>
<span class="sd"> :type max_iterations: int</span>
<span class="sd"> :param tol: tolerance against residuum (default = 1e-9)</span>
<span class="sd"> :param tol: tolerance against residuum :math:`\varepsilon`</span>
<span class="sd"> (default = 1e-9)</span>
<span class="sd"> :type tol: float</span>
<span class="sd"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span>
<span class="sd"> </span>
<span class="sd"> :returns: :math:`x_{i+1}`</span>
<span class="sd"> :returns: :math:`x_{i}`</span>
<span class="sd"> </span>
<span class="sd"> .. math ::</span>
<span class="sd"> x_{i+1} = x_i + \Delta x</span>
<span class="sd"> .. seealso::</span>
<span class="sd"> :meth:`dxdt_Dt` for :math:`\Delta x`</span>
<span class="sd"> x_{i,j=0} = x_{i}</span>
<span class="sd"> </span>
<span class="sd"> .. math ::</span>
<span class="sd"> x_{i,j+1} = x_i + \dot{x}(x_{i,j}, t_{i+1})\cdot(t_{i+1}-t_i)</span>
<span class="sd"> </span>
<span class="sd"> .. math ::</span>
<span class="sd"> \text{residuum} = \frac{\lVert x_{i,j+1}-x_{i,j}\rVert}</span>
<span class="sd"> {\lVert x_{i,j+1} \rVert} &lt; \varepsilon</span>
<span class="sd"> </span>
<span class="sd"> .. math ::</span>
<span class="sd"> x_{i} = x_{i,j=\text{end}}</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">x0</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
<span class="n">Dx</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">xi1</span> <span class="o">=</span> <span class="n">x0</span> <span class="o">+</span> <span class="n">Dx</span> <span class="c1"># Approximate solution at next value of x</span>
<span class="n">residuum</span> <span class="o">=</span> <span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="o">-</span><span class="n">xi</span><span class="p">)</span><span class="o">/</span><span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="p">)</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">xi1</span>
<span class="n">xij</span> <span class="o">=</span> <span class="n">xi</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span>
<span class="n">dxdt</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">xij</span><span class="p">,</span> <span class="n">ti1</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="c1"># Approximate solution at next value of x</span>
<span class="n">xij1</span> <span class="o">=</span> <span class="n">xi</span> <span class="o">+</span> <span class="n">dxdt</span> <span class="o">*</span> <span class="p">(</span><span class="n">ti1</span><span class="o">-</span><span class="n">ti</span><span class="p">)</span>
<span class="n">residuum</span> <span class="o">=</span> <span class="n">norm</span><span class="p">(</span><span class="n">xij1</span><span class="o">-</span><span class="n">xij</span><span class="p">)</span><span class="o">/</span><span class="n">norm</span><span class="p">(</span><span class="n">xij1</span><span class="p">)</span>
<span class="n">xij</span> <span class="o">=</span> <span class="n">xij1</span>
<span class="k">if</span> <span class="n">residuum</span> <span class="o">&lt;</span> <span class="n">tol</span><span class="p">:</span>
<span class="k">break</span>
<span class="n">iterations</span> <span class="o">=</span> <span class="n">j</span><span class="o">+</span><span class="mi">1</span> <span class="c1"># number beginning with 1 therefore + 1</span>
<span class="k">return</span> <span class="n">xi</span><span class="p">,</span> <span class="n">iterations</span></div>
<span class="k">return</span> <span class="n">xij</span><span class="p">,</span> <span class="n">iterations</span></div>
<div class="viewcode-block" id="i1n"><a class="viewcode-back" href="../../numerical.html#numerical.ode.i1n">[docs]</a><span class="k">def</span> <span class="nf">i1n</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="n">iterations</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="mi">1</span><span class="p">))</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span>
<span class="n">Dx</span> <span class="o">=</span> <span class="n">dxdt_Dt</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:],</span> <span class="n">iterations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">fixed_point_iteration</span><span class="p">(</span><span class="n">Dx</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="n">max_iterations</span><span class="p">,</span> <span class="n">tol</span><span class="p">,</span> <span class="n">verbose</span><span class="p">)</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using implicite first-order method (Euler) was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">iterations</span></div>
<div class="viewcode-block" id="i1"><a class="viewcode-back" href="../../numerical.html#numerical.ode.i1">[docs]</a><span class="k">def</span> <span class="nf">i1</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<div class="viewcode-block" id="i1"><a class="viewcode-back" href="../../numerical.html#numerical.ode.i1">[docs]</a><span class="k">def</span> <span class="nf">i1</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span>
<span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;Implicite first-order method / backward Euler method.</span>
<span class="sd"> :param f: the function to solve</span>
@@ -286,7 +293,8 @@
<span class="sd"> :type x0: list</span>
<span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param max_iterations: maximum number of iterations</span>
<span class="sd"> :type max_iterations: int</span>
<span class="sd"> :param tol: tolerance against residuum (default = 1e-9)</span>
@@ -298,26 +306,24 @@
<span class="sd"> &quot;&quot;&quot;</span>
<span class="n">iterations</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="mi">1</span><span class="p">))</span>
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="c1"># x(i+1) = x(i) + f(x(i+1), t(i+1)), exact value of</span>
<span class="c1"># f(x(i+1), t(i+1)) is not available therefore using</span>
<span class="c1"># Newton-Raphson method</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span>
<span class="c1"># x(i+1) = x(i) + f(x(i+1), t(i+1)), exact value of f(x(i+1), t(i+1)) is not</span>
<span class="c1"># available therefor using Newton-Raphson method</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
<span class="n">dxdt</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
<span class="n">xi1</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">dxdt</span><span class="o">*</span><span class="n">Dt</span> <span class="c1"># Approximate solution at next value of x</span>
<span class="n">residuum</span> <span class="o">=</span> <span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="o">-</span><span class="n">xi</span><span class="p">)</span><span class="o">/</span><span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="p">)</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">xi1</span>
<span class="k">if</span> <span class="n">residuum</span> <span class="o">&lt;</span> <span class="n">tol</span><span class="p">:</span>
<span class="k">break</span>
<span class="n">iterations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">j</span><span class="o">+</span><span class="mi">1</span>
<span class="n">xi</span><span class="p">,</span> <span class="n">iteration</span> <span class="o">=</span> <span class="n">fpi</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="p">,</span>
<span class="n">tol</span><span class="p">,</span> <span class="n">verbose</span><span class="p">)</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xi</span>
<span class="n">iterations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">iteration</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using implicite first-order method (Euler) was successful.&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using implicite &#39;</span> <span class="o">+</span>
<span class="s1">&#39;first-order method (Euler) was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">iterations</span></div>
<div class="viewcode-block" id="newmark_newtonraphson"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span> <span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<div class="viewcode-block" id="newmark_newtonraphson"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span>
<span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;Newmark method.</span>
<span class="sd"> :param f: the function to solve</span>
@@ -330,7 +336,8 @@
<span class="sd"> :type xpp0: list</span>
<span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param gamma: newmark parameter for velocity (default = 0.5)</span>
<span class="sd"> :type gamma: float</span>
<span class="sd"> :param beta: newmark parameter for displacement (default = 0.25)</span>
@@ -346,9 +353,9 @@
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">xp</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">xp0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">xpp</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">xpp0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xpp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xpp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xpp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xpp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
@@ -361,7 +368,8 @@
<span class="n">j</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
<span class="c1">#dxdt = array(f(t[i+1], x1, p))</span>
<span class="c1">#x11 = x[i,:] + dxdt*Dt # Approximate solution at next value of x</span>
<span class="c1"># Approximate solution at next value of x</span>
<span class="c1">#x11 = x[i,:] + dxdt*Dt</span>
<span class="n">N</span><span class="p">,</span> <span class="n">dN</span><span class="p">,</span> <span class="n">dNp</span><span class="p">,</span> <span class="n">dNpp</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">x1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">(),</span>
<span class="n">xp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">(),</span> <span class="n">xpp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">(),</span>
@@ -370,7 +378,8 @@
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;divergiert&#39;</span><span class="p">)</span>
<span class="k">break</span>
<span class="n">xpp11</span> <span class="o">=</span> <span class="n">xpp1</span> <span class="o">-</span> <span class="n">dot</span><span class="p">(</span><span class="n">inv</span><span class="p">(</span><span class="n">dNpp</span><span class="p">),</span> <span class="p">(</span><span class="n">N</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">dN</span><span class="p">,</span> <span class="p">(</span><span class="n">x1</span><span class="o">-</span><span class="n">xi</span><span class="p">))</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">dNp</span><span class="p">,</span> <span class="p">(</span><span class="n">xp1</span><span class="o">-</span><span class="n">xpi</span><span class="p">))))</span>
<span class="n">xpp11</span> <span class="o">=</span> <span class="n">xpp1</span> <span class="o">-</span> <span class="n">dot</span><span class="p">(</span><span class="n">inv</span><span class="p">(</span><span class="n">dNpp</span><span class="p">),</span> <span class="p">(</span><span class="n">N</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">dN</span><span class="p">,</span> <span class="p">(</span><span class="n">x1</span><span class="o">-</span><span class="n">xi</span><span class="p">))</span> <span class="o">+</span> \
<span class="n">dot</span><span class="p">(</span><span class="n">dNp</span><span class="p">,</span> <span class="p">(</span><span class="n">xp1</span><span class="o">-</span><span class="n">xpi</span><span class="p">))))</span>
<span class="n">xp1</span> <span class="o">=</span> <span class="n">xpi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">*</span><span class="p">(</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">gamma</span><span class="p">)</span><span class="o">*</span><span class="n">xppi</span> <span class="o">+</span> <span class="n">gamma</span><span class="o">*</span><span class="n">xpp11</span> <span class="p">)</span>
<span class="n">x1</span> <span class="o">=</span> <span class="n">xi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">**</span><span class="mi">2</span><span class="o">*</span><span class="p">(</span> <span class="p">(</span><span class="o">.</span><span class="mi">5</span><span class="o">-</span><span class="n">beta</span><span class="p">)</span><span class="o">*</span><span class="n">xppi</span> <span class="o">+</span> <span class="n">beta</span><span class="o">*</span><span class="n">xpp11</span> <span class="p">)</span>
@@ -384,11 +393,13 @@
<span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite newmark method was successful.&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite &#39;</span> <span class="o">+</span>
<span class="s1">&#39;newmark method was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">xp</span><span class="p">,</span> <span class="n">xpp</span><span class="p">,</span> <span class="n">iterations</span></div>
<span class="c1"># x = concatenate((x, xp, xpp), axis=1)</span>
<div class="viewcode-block" id="newmark_newtonraphson_rdk"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson_rdk">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson_rdk</span><span class="p">(</span><span class="n">fnm</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span> <span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">maxIterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<div class="viewcode-block" id="newmark_newtonraphson_rdk"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson_rdk">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson_rdk</span><span class="p">(</span><span class="n">fnm</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span>
<span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;Newmark method.</span>
<span class="sd"> :param f: the function to solve</span>
@@ -401,7 +412,8 @@
<span class="sd"> :type xpp0: list</span>
<span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter,</span>
<span class="sd"> ...)</span>
<span class="sd"> :param gamma: newmark parameter for velocity (default = 0.5)</span>
<span class="sd"> :type gamma: float</span>
<span class="sd"> :param beta: newmark parameter for displacement (default = 0.25)</span>
@@ -417,13 +429,14 @@
<span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">xp</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">xp0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">xpp</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">xpp0</span><span class="p">)))</span> <span class="c1"># Preallocate array</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xpp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xpp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="n">xpp</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xpp0</span> <span class="c1"># Initial condition gives solution at first t</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
<span class="n">rm</span><span class="p">,</span> <span class="n">rmx</span><span class="p">,</span> <span class="n">rmxpp</span><span class="p">,</span> <span class="n">rd</span><span class="p">,</span> <span class="n">rdx</span><span class="p">,</span> <span class="n">rdxp</span><span class="p">,</span> <span class="n">rk</span><span class="p">,</span> <span class="n">rkx</span><span class="p">,</span> <span class="n">f</span> <span class="o">=</span> <span class="n">fnm</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">xpp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
<span class="n">rm</span><span class="p">,</span> <span class="n">rmx</span><span class="p">,</span> <span class="n">rmxpp</span><span class="p">,</span> <span class="n">rd</span><span class="p">,</span> <span class="n">rdx</span><span class="p">,</span> <span class="n">rdxp</span><span class="p">,</span> <span class="n">rk</span><span class="p">,</span> <span class="n">rkx</span><span class="p">,</span> <span class="n">f</span> <span class="o">=</span> <span class="n">fnm</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span>
<span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">xpp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">.</span><span class="n">reshape</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="n">xpi</span> <span class="o">=</span> <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
@@ -432,13 +445,16 @@
<span class="n">xp1</span> <span class="o">=</span> <span class="n">xpi</span>
<span class="n">xpp1</span> <span class="o">=</span> <span class="n">xppi</span>
<span class="n">j</span> <span class="o">=</span> <span class="mi">0</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">maxIterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
<span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
<span class="c1">#dxdt = array(f(t[i+1], x1, p))</span>
<span class="c1">#x11 = x[i,:] + dxdt*Dt # Approximate solution at next value of x</span>
<span class="c1"># Approximate solution at next value of x</span>
<span class="c1">#x11 = x[i,:] + dxdt*Dt</span>
<span class="n">r</span> <span class="o">=</span> <span class="p">(</span><span class="n">rmx</span><span class="o">+</span><span class="n">rdx</span><span class="o">+</span><span class="n">rkx</span><span class="p">)</span><span class="o">*</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span> <span class="o">+</span> <span class="n">rdxp</span><span class="o">*</span><span class="n">Dt</span><span class="o">/</span><span class="mi">2</span> <span class="o">+</span> <span class="n">rmxpp</span>
<span class="n">rp</span> <span class="o">=</span> <span class="n">f</span> <span class="o">-</span> <span class="p">(</span><span class="n">rm</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rmx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">-</span> <span class="n">dot</span><span class="p">(</span><span class="n">rmxpp</span><span class="p">,</span> <span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
<span class="n">rd</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rdx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rdxp</span><span class="p">,</span> <span class="n">Dt</span><span class="o">/</span><span class="mi">2</span><span class="o">*</span><span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
<span class="n">rp</span> <span class="o">=</span> <span class="n">f</span> <span class="o">-</span> <span class="p">(</span><span class="n">rm</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rmx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">-</span> \
<span class="n">dot</span><span class="p">(</span><span class="n">rmxpp</span><span class="p">,</span> <span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
<span class="n">rd</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rdx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">+</span> \
<span class="n">dot</span><span class="p">(</span><span class="n">rdxp</span><span class="p">,</span> <span class="n">Dt</span><span class="o">/</span><span class="mi">2</span><span class="o">*</span><span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
<span class="n">rk</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rkx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="p">)</span>
<span class="n">xpp11</span> <span class="o">=</span> <span class="n">dot</span><span class="p">(</span><span class="n">inv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">rp</span><span class="p">)</span>
<span class="n">xp1</span> <span class="o">=</span> <span class="n">xpi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">*</span><span class="p">(</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">gamma</span><span class="p">)</span><span class="o">*</span><span class="n">xppi</span> <span class="o">+</span> <span class="n">gamma</span><span class="o">*</span><span class="n">xpp11</span> <span class="p">)</span>
@@ -454,7 +470,8 @@
<span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
<span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
<span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite newmark method was successful.&#39;</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite &#39;</span> <span class="o">+</span>
<span class="s1">&#39;newmark method was successful.&#39;</span><span class="p">)</span>
<span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">xp</span><span class="p">,</span> <span class="n">xpp</span><span class="p">,</span> <span class="n">iterations</span></div>
<span class="c1"># x = concatenate((x, xp, xpp), axis=1)</span>
</pre></div>

255
docs/build/html/_modules/time_of_day.html vendored Normal file
View File

@@ -0,0 +1,255 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<title>time_of_day &#8212; pylib 2019.5.19 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="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">
<h1>Source code for time_of_day</h1><div class="highlight"><pre>
<span></span><span class="ch">#!/usr/bin/env python</span>
<span class="c1"># -*- coding: utf-8 -*-</span>
<span class="sd">&quot;&quot;&quot;Calculate time.</span>
<span class="sd">:Date: 2019-06-01</span>
<span class="sd">.. module:: time_of_day</span>
<span class="sd"> :platform: *nix, Windows</span>
<span class="sd"> :synopsis: Calculate time.</span>
<span class="sd"> </span>
<span class="sd">.. moduleauthor:: Daniel Weschke &lt;daniel.weschke@directbox.de&gt;</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">division</span><span class="p">,</span> <span class="n">print_function</span><span class="p">,</span> <span class="n">unicode_literals</span>
<span class="kn">from</span> <span class="nn">time</span> <span class="k">import</span> <span class="n">struct_time</span><span class="p">,</span> <span class="n">mktime</span>
<div class="viewcode-block" id="in_seconds"><a class="viewcode-back" href="../time_of_day.html#time_of_day.in_seconds">[docs]</a><span class="k">def</span> <span class="nf">in_seconds</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;If time is `time.struct_time` convert to float seconds.</span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: the time in seconds</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">time</span><span class="p">,</span> <span class="n">struct_time</span><span class="p">):</span>
<span class="n">time</span> <span class="o">=</span> <span class="n">mktime</span><span class="p">(</span><span class="n">time</span><span class="p">)</span>
<span class="k">return</span> <span class="n">time</span></div>
<div class="viewcode-block" id="seconds"><a class="viewcode-back" href="../time_of_day.html#time_of_day.seconds">[docs]</a><span class="k">def</span> <span class="nf">seconds</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The seconds of the time.</span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: seconds, range [0, 60]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">in_seconds</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">%</span><span class="mi">60</span></div>
<div class="viewcode-block" id="seconds_norm"><a class="viewcode-back" href="../time_of_day.html#time_of_day.seconds_norm">[docs]</a><span class="k">def</span> <span class="nf">seconds_norm</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The seconds normalized to 60 seconds.</span>
<span class="sd"> </span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: the normalized seconds, range [0, 1]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">seconds</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mi">60</span></div>
<div class="viewcode-block" id="minutes"><a class="viewcode-back" href="../time_of_day.html#time_of_day.minutes">[docs]</a><span class="k">def</span> <span class="nf">minutes</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The minutes of the time.</span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: minutes, range [0, 60]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">in_seconds</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mi">60</span><span class="o">%</span><span class="mi">60</span></div>
<div class="viewcode-block" id="minutes_norm"><a class="viewcode-back" href="../time_of_day.html#time_of_day.minutes_norm">[docs]</a><span class="k">def</span> <span class="nf">minutes_norm</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The minutes normalized to 60 minutes.</span>
<span class="sd"> </span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: the normalized minutes, range [0, 1]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">minutes</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mi">60</span></div>
<div class="viewcode-block" id="hours"><a class="viewcode-back" href="../time_of_day.html#time_of_day.hours">[docs]</a><span class="k">def</span> <span class="nf">hours</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The hours of the time.</span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: hours, range [0, 24]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">in_seconds</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mi">60</span><span class="o">/</span><span class="mi">60</span><span class="o">%</span><span class="mi">24</span></div>
<div class="viewcode-block" id="hours_norm"><a class="viewcode-back" href="../time_of_day.html#time_of_day.hours_norm">[docs]</a><span class="k">def</span> <span class="nf">hours_norm</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The hours normalized to 24 hours.</span>
<span class="sd"> </span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: the normalized hours, range [0, 1]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">hours</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mi">24</span></div>
<div class="viewcode-block" id="days"><a class="viewcode-back" href="../time_of_day.html#time_of_day.days">[docs]</a><span class="k">def</span> <span class="nf">days</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The days of the time (year).</span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: hours, range [0, 365.2425]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">in_seconds</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mi">60</span><span class="o">/</span><span class="mi">60</span><span class="o">/</span><span class="mi">24</span><span class="o">%</span><span class="mf">365.2425</span></div>
<div class="viewcode-block" id="days_norm"><a class="viewcode-back" href="../time_of_day.html#time_of_day.days_norm">[docs]</a><span class="k">def</span> <span class="nf">days_norm</span><span class="p">(</span><span class="n">time</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;The days normalized to 365.2425 (Gregorian, on average) days.</span>
<span class="sd"> </span>
<span class="sd"> :param time: the time in seconds</span>
<span class="sd"> :type time: float or `time.struct_time`</span>
<span class="sd"> </span>
<span class="sd"> :returns: the normalized days, range [0, 1]</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">days</span><span class="p">(</span><span class="n">time</span><span class="p">)</span><span class="o">/</span><span class="mf">365.2425</span></div>
<div class="viewcode-block" id="transform"><a class="viewcode-back" href="../time_of_day.html#time_of_day.transform">[docs]</a><span class="k">def</span> <span class="nf">transform</span><span class="p">(</span><span class="n">time_norm</span><span class="p">,</span> <span class="n">length</span><span class="p">,</span> <span class="n">offset</span><span class="o">=</span><span class="mi">0</span><span class="p">):</span>
<span class="sd">&quot;&quot;&quot;Transform normalized time value to new length.</span>
<span class="sd"> </span>
<span class="sd"> :param position_norm: the normalized time value to transform</span>
<span class="sd"> :type position_norm: float</span>
<span class="sd"> :param length: the transformation</span>
<span class="sd"> :type length: float</span>
<span class="sd"> :param offset: the offset (default = 0)</span>
<span class="sd"> :type offset: float</span>
<span class="sd"> </span>
<span class="sd"> :returns: the transformation value</span>
<span class="sd"> :rtype: float</span>
<span class="sd"> &quot;&quot;&quot;</span>
<span class="k">return</span> <span class="n">time_norm</span><span class="o">*</span><span class="n">length</span> <span class="o">+</span> <span class="n">offset</span></div>
<span class="k">if</span> <span class="vm">__name__</span> <span class="o">==</span> <span class="s2">&quot;__main__&quot;</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">time</span> <span class="k">import</span> <span class="n">time</span><span class="p">,</span> <span class="n">gmtime</span><span class="p">,</span> <span class="n">localtime</span>
<span class="c1"># time in seconds</span>
<span class="n">t</span> <span class="o">=</span> <span class="n">time</span><span class="p">()</span>
<span class="nb">min</span> <span class="o">=</span> <span class="n">minutes</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="n">h</span> <span class="o">=</span> <span class="n">hours</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="n">min_norm</span> <span class="o">=</span> <span class="n">minutes_norm</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="n">h_norm</span> <span class="o">=</span> <span class="n">hours_norm</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;min &#39;</span><span class="p">,</span> <span class="nb">min</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;h &#39;</span><span class="p">,</span> <span class="n">h</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;min_norm &#39;</span><span class="p">,</span> <span class="n">min_norm</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;h_norm &#39;</span><span class="p">,</span> <span class="n">h_norm</span><span class="p">)</span>
<span class="n">x_len</span> <span class="o">=</span> <span class="mi">30</span>
<span class="n">x_offset</span> <span class="o">=</span> <span class="o">-</span><span class="mi">8</span>
<span class="n">x_pos</span> <span class="o">=</span> <span class="n">transform</span><span class="p">(</span><span class="n">min_norm</span><span class="p">,</span> <span class="n">x_len</span><span class="p">,</span> <span class="n">x_offset</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;m[-8,22] &#39;</span><span class="p">,</span> <span class="n">x_pos</span><span class="p">)</span>
<span class="n">y_len</span> <span class="o">=</span> <span class="mi">20</span>
<span class="n">y_offset</span> <span class="o">=</span> <span class="o">-</span><span class="mi">10</span>
<span class="n">y_pos</span> <span class="o">=</span> <span class="n">transform</span><span class="p">(</span><span class="n">h_norm</span><span class="p">,</span> <span class="n">y_len</span><span class="p">,</span> <span class="n">y_offset</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="s1">&#39;h[-10,10]&#39;</span><span class="p">,</span> <span class="n">y_pos</span><span class="p">)</span>
</pre></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>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="../index.html">Documentation overview</a><ul>
<li><a href="index.html">Module code</a><ul>
</ul></li>
</ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="../search.html" method="get">
<input type="text" name="q" />
<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.0.1</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
</div>
</body>
</html>

1
docs/build/html/_sources/modules.rst.txt vendored
View File

@@ -8,3 +8,4 @@ src
date
geometry
numerical
time_of_day

7
docs/build/html/_sources/time_of_day.rst.txt vendored Normal file
View File

@@ -0,0 +1,7 @@
time\_of\_day module
====================
.. automodule:: time_of_day
:members:
:undoc-members:
:show-inheritance:

43
docs/build/html/genindex.html vendored
View File

@@ -43,6 +43,7 @@
| <a href="#E"><strong>E</strong></a>
| <a href="#F"><strong>F</strong></a>
| <a href="#G"><strong>G</strong></a>
| <a href="#H"><strong>H</strong></a>
| <a href="#I"><strong>I</strong></a>
| <a href="#L"><strong>L</strong></a>
| <a href="#M"><strong>M</strong></a>
@@ -84,18 +85,20 @@
<li><a href="data.html#data.data_read">data_read() (in module data)</a>
</li>
<li><a href="data.html#data.data_store">data_store() (in module data)</a>
</li>
<li><a href="date.html#module-date">date (module)</a>, <a href="date.html#module-date">[1]</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="date.html#module-date">date (module)</a>, <a href="date.html#module-date">[1]</a>
<li><a href="time_of_day.html#time_of_day.days">days() (in module time_of_day)</a>
</li>
<li><a href="time_of_day.html#time_of_day.days_norm">days_norm() (in module time_of_day)</a>
</li>
<li><a href="numerical.html#numerical.ode_model.disk">disk() (in module numerical.ode_model)</a>
</li>
<li><a href="numerical.html#numerical.ode_model.disk_nm">disk_nm() (in module numerical.ode_model)</a>
</li>
<li><a href="numerical.html#numerical.ode_model.disk_nmmdk">disk_nmmdk() (in module numerical.ode_model)</a>
</li>
<li><a href="numerical.html#numerical.ode.dxdt_Dt">dxdt_Dt() (in module numerical.ode)</a>
</li>
</ul></td>
</tr></table>
@@ -127,7 +130,7 @@
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="numerical.html#numerical.ode.fixed_point_iteration">fixed_point_iteration() (in module numerical.ode)</a>
<li><a href="numerical.html#numerical.ode.fpi">fpi() (in module numerical.ode)</a>
</li>
</ul></td>
</tr></table>
@@ -148,6 +151,18 @@
</ul></td>
</tr></table>
<h2 id="H">H</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="time_of_day.html#time_of_day.hours">hours() (in module time_of_day)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="time_of_day.html#time_of_day.hours_norm">hours_norm() (in module time_of_day)</a>
</li>
</ul></td>
</tr></table>
<h2 id="I">I</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
@@ -155,7 +170,7 @@
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="numerical.html#numerical.ode.i1n">i1n() (in module numerical.ode)</a>
<li><a href="time_of_day.html#time_of_day.in_seconds">in_seconds() (in module time_of_day)</a>
</li>
<li><a href="numerical.html#module-integration">integration (module)</a>
</li>
@@ -174,6 +189,12 @@
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="data.html#data.main">main() (in module data)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="time_of_day.html#time_of_day.minutes">minutes() (in module time_of_day)</a>
</li>
<li><a href="time_of_day.html#time_of_day.minutes_norm">minutes_norm() (in module time_of_day)</a>
</li>
</ul></td>
</tr></table>
@@ -241,6 +262,12 @@
<h2 id="S">S</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="time_of_day.html#time_of_day.seconds">seconds() (in module time_of_day)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="time_of_day.html#time_of_day.seconds_norm">seconds_norm() (in module time_of_day)</a>
</li>
<li><a href="geometry.html#geometry.square">square() (in module geometry)</a>
</li>
</ul></td>
@@ -249,10 +276,14 @@
<h2 id="T">T</h2>
<table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#geometry.translate">translate() (in module geometry)</a>
<li><a href="time_of_day.html#module-time_of_day">time_of_day (module)</a>, <a href="time_of_day.html#module-time_of_day">[1]</a>
</li>
<li><a href="time_of_day.html#time_of_day.transform">transform() (in module time_of_day)</a>
</li>
</ul></td>
<td style="width: 33%; vertical-align: top;"><ul>
<li><a href="geometry.html#geometry.translate">translate() (in module geometry)</a>
</li>
<li><a href="numerical.html#numerical.integration.trapez">trapez() (in module numerical.integration)</a>
</li>
</ul></td>

1
docs/build/html/modules.html vendored
View File

@@ -48,6 +48,7 @@
<li class="toctree-l2"><a class="reference internal" href="numerical.html#module-numerical">Module contents</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="time_of_day.html">time_of_day module</a></li>
</ul>
</div>
</div>

106
docs/build/html/numerical.html vendored
View File

@@ -197,30 +197,14 @@ b &amp;= 1\end{split}\]</div>
<div class="section" id="module-numerical.ode">
<span id="numerical-ode-module"></span><h2>numerical.ode module<a class="headerlink" href="#module-numerical.ode" title="Permalink to this headline"></a></h2>
<p>Numerical solver of ordinary differential equations.</p>
<p>Solves the initial value problem for systems of first order ordinary differential
equations.</p>
<p>Solves the initial value problem for systems of first order
ordinary differential equations.</p>
<dl class="field-list simple">
<dt class="field-odd">Date</dt>
<dd class="field-odd"><p>2015-09-21</p>
</dd>
</dl>
<span class="target" id="module-ode"></span><dl class="function">
<dt id="numerical.ode.dxdt_Dt">
<code class="descname">dxdt_Dt</code><span class="sig-paren">(</span><em>f</em>, <em>x</em>, <em>t</em>, <em>Dt</em>, <em>*p</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#dxdt_Dt"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.dxdt_Dt" title="Permalink to this definition"></a></dt>
<dd><dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>f</strong> (<em>function</em>) – <span class="math notranslate nohighlight">\(f = \dot{x}\)</span></p></li>
<li><p><strong>Dt</strong> – <span class="math notranslate nohighlight">\(\Delta{t}\)</span></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><span class="math notranslate nohighlight">\(\Delta x = \dot{x} \Delta t\)</span></p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="numerical.ode.e1">
<code class="descname">e1</code><span class="sig-paren">(</span><em>f</em>, <em>x0</em>, <em>t</em>, <em>*p</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#e1"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.e1" title="Permalink to this definition"></a></dt>
<dd><p>Explicit first-order method /
@@ -235,7 +219,8 @@ Euler-Cauchy-Verfahren / Euler-vorwärts-Verfahren</p>
<li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
<li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul>
</dd>
@@ -247,12 +232,12 @@ x(t_0) &amp;= x_0\end{split}\]</div>
<p>Choose a value h for the size of every step and set</p>
<div class="math notranslate nohighlight">
\[t_i = t_0 + i h ~,\quad i=1,2,\ldots,n\]</div>
<p>The derivative of the solution is approximated as the forward difference
equation</p>
<p>The derivative of the solution is approximated as the forward
difference equation</p>
<div class="math notranslate nohighlight">
\[\dot{x}_i = f(t_i, x_i) = \frac{x_{i+1} - x_i}{t_{i+1}-t_i}\]</div>
<p>Therefore one step <span class="math notranslate nohighlight">\(h\)</span> of the Euler method from <span class="math notranslate nohighlight">\(t_i\)</span> to
<span class="math notranslate nohighlight">\(t_{i+1}\)</span> is</p>
<p>Therefore one step <span class="math notranslate nohighlight">\(h\)</span> of the Euler method from
<span class="math notranslate nohighlight">\(t_i\)</span> to <span class="math notranslate nohighlight">\(t_{i+1}\)</span> is</p>
<div class="math notranslate nohighlight">
\[\begin{split}x_{i+1} &amp;= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\
x_{i+1} &amp;= x_i + h f(t_i, x_i) \\\end{split}\]</div>
@@ -272,7 +257,8 @@ x_2 &amp;= \dot{u} &amp;\quad \dot{x}_2 = \ddot{u} \\\end{split}\]</div>
<div class="math notranslate nohighlight">
\[\begin{split}\dot{x} &amp;= f(t,x) \\
\begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=
\begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1) \end{bmatrix} \\
\begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1)
\end{bmatrix} \\
&amp;=
\begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +
\begin{bmatrix} 0 &amp; 1 \\ -m^{-1} k &amp; -m^{-1} d \end{bmatrix}
@@ -288,19 +274,24 @@ x_2 &amp;= \dot{u} &amp;\quad \dot{x}_2 = \ddot{u} \\\end{split}\]</div>
<p>becomes</p>
<div class="math notranslate nohighlight">
\[\begin{split}\dot{x}_1 &amp;= x_2 \\
\dot{x}_2 &amp;= m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\\end{split}\]</div>
\dot{x}_2 &amp;=
m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\\end{split}\]</div>
<p>or</p>
<div class="math notranslate nohighlight">
\[\begin{split}\dot{x} &amp;= f(t,x) \\
\begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=
\begin{bmatrix} x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \end{bmatrix} \\
\begin{bmatrix}
x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1)
\end{bmatrix} \\
&amp;=
\begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} +
\begin{bmatrix} 0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2) \end{bmatrix}
\begin{bmatrix}
0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2)
\end{bmatrix}
\begin{bmatrix} x_1 \\ x_2 \end{bmatrix}\end{split}\]</div>
<p>The Euler method is a first-order method,
which means that the local error (error per step) is proportional to the
square of the step size, and the global error (error at a given time) is
<p>The Euler method is a first-order method, which means that the
local error (error per step) is proportional to the square of
the step size, and the global error (error at a given time) is
proportional to the step size.</p>
</dd></dl>
@@ -314,7 +305,8 @@ proportional to the step size.</p>
<li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
<li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul>
</dd>
@@ -331,7 +323,8 @@ proportional to the step size.</p>
<li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
<li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul>
</dd>
@@ -339,30 +332,37 @@ proportional to the step size.</p>
</dd></dl>
<dl class="function">
<dt id="numerical.ode.fixed_point_iteration">
<code class="descname">fixed_point_iteration</code><span class="sig-paren">(</span><em>f</em>, <em>xi</em>, <em>t</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#fixed_point_iteration"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.fixed_point_iteration" title="Permalink to this definition"></a></dt>
<dd><dl class="field-list simple">
<dt id="numerical.ode.fpi">
<code class="descname">fpi</code><span class="sig-paren">(</span><em>f</em>, <em>xi</em>, <em>ti</em>, <em>ti1</em>, <em>*p</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#fpi"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.fpi" title="Permalink to this definition"></a></dt>
<dd><p>Fixed-point iteration.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>f</strong> (<em>function</em>) – the function to iterate <span class="math notranslate nohighlight">\(f = \Delta{x}(t)\)</span></p></li>
<li><p><strong>f</strong> (<em>function</em>) – the function to iterate <span class="math notranslate nohighlight">\(f = \dot{x}(x,t)\)</span></p></li>
<li><p><strong>xi</strong> (<em>list</em>) – initial condition <span class="math notranslate nohighlight">\(x_i\)</span></p></li>
<li><p><strong>t</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t\)</span></p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>ti</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t_i\)</span></p></li>
<li><p><strong>ti1</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t_{i+1}\)</span></p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
<li><p><strong>tol</strong> (<em>float</em>) – tolerance against residuum (default = 1e-9)</p></li>
<li><p><strong>tol</strong> (<em>float</em>) – tolerance against residuum <span class="math notranslate nohighlight">\(\varepsilon\)</span>
(default = 1e-9)</p></li>
<li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><span class="math notranslate nohighlight">\(x_{i+1}\)</span></p>
<dd class="field-even"><p><span class="math notranslate nohighlight">\(x_{i}\)</span></p>
</dd>
</dl>
<div class="math notranslate nohighlight">
\[x_{i+1} = x_i + \Delta x\]</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#numerical.ode.dxdt_Dt" title="numerical.ode.dxdt_Dt"><code class="xref py py-meth docutils literal notranslate"><span class="pre">dxdt_Dt()</span></code></a> for <span class="math notranslate nohighlight">\(\Delta x\)</span></p>
</div>
\[x_{i,j=0} = x_{i}\]</div>
<div class="math notranslate nohighlight">
\[x_{i,j+1} = x_i + \dot{x}(x_{i,j}, t_{i+1})\cdot(t_{i+1}-t_i)\]</div>
<div class="math notranslate nohighlight">
\[\text{residuum} = \frac{\lVert x_{i,j+1}-x_{i,j}\rVert}
{\lVert x_{i,j+1} \rVert} &lt; \varepsilon\]</div>
<div class="math notranslate nohighlight">
\[x_{i} = x_{i,j=\text{end}}\]</div>
</dd></dl>
<dl class="function">
@@ -375,7 +375,8 @@ proportional to the step size.</p>
<li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
<li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
<li><p><strong>tol</strong> (<em>float</em>) – tolerance against residuum (default = 1e-9)</p></li>
<li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
@@ -385,11 +386,6 @@ proportional to the step size.</p>
<p>The backward Euler method has order one and is A-stable.</p>
</dd></dl>
<dl class="function">
<dt id="numerical.ode.i1n">
<code class="descname">i1n</code><span class="sig-paren">(</span><em>f</em>, <em>x0</em>, <em>t</em>, <em>*p</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#i1n"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.i1n" title="Permalink to this definition"></a></dt>
<dd></dd></dl>
<dl class="function">
<dt id="numerical.ode.newmark_newtonraphson">
<code class="descname">newmark_newtonraphson</code><span class="sig-paren">(</span><em>f</em>, <em>x0</em>, <em>xp0</em>, <em>xpp0</em>, <em>t</em>, <em>*p</em>, <em>gamma=0.5</em>, <em>beta=0.25</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#newmark_newtonraphson"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.newmark_newtonraphson" title="Permalink to this definition"></a></dt>
@@ -402,7 +398,8 @@ proportional to the step size.</p>
<li><p><strong>xp0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>xpp0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>gamma</strong> (<em>float</em>) – newmark parameter for velocity (default = 0.5)</p></li>
<li><p><strong>beta</strong> (<em>float</em>) – newmark parameter for displacement (default = 0.25)</p></li>
<li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
@@ -415,7 +412,7 @@ proportional to the step size.</p>
<dl class="function">
<dt id="numerical.ode.newmark_newtonraphson_rdk">
<code class="descname">newmark_newtonraphson_rdk</code><span class="sig-paren">(</span><em>fnm</em>, <em>x0</em>, <em>xp0</em>, <em>xpp0</em>, <em>t</em>, <em>*p</em>, <em>gamma=0.5</em>, <em>beta=0.25</em>, <em>maxIterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#newmark_newtonraphson_rdk"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.newmark_newtonraphson_rdk" title="Permalink to this definition"></a></dt>
<code class="descname">newmark_newtonraphson_rdk</code><span class="sig-paren">(</span><em>fnm</em>, <em>x0</em>, <em>xp0</em>, <em>xpp0</em>, <em>t</em>, <em>*p</em>, <em>gamma=0.5</em>, <em>beta=0.25</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#newmark_newtonraphson_rdk"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.newmark_newtonraphson_rdk" title="Permalink to this definition"></a></dt>
<dd><p>Newmark method.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
@@ -425,7 +422,8 @@ proportional to the step size.</p>
<li><p><strong>xp0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>xpp0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
…)</p></li>
<li><p><strong>gamma</strong> (<em>float</em>) – newmark parameter for velocity (default = 0.5)</p></li>
<li><p><strong>beta</strong> (<em>float</em>) – newmark parameter for displacement (default = 0.25)</p></li>
<li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>

6
docs/build/html/objects.inv vendored
View File

@@ -2,6 +2,6 @@
# Project: pylib
# Version:
# The remainder of this file is compressed using zlib.
xڭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<14><><<3C>h<>! <0C><>4<14>0CA<43>Q<EFBFBD>cGD<17># <15>A<EFBFBD><41><EFBFBD>&< <09><>d<EFBFBD>d<EFBFBD>H<EFBFBD>4<EFBFBD>}<7D><><EFBFBD>f<EFBFBD><04><>L<EFBFBD>;mŬ<EFBFBD><EFBFBD>&"<18><><EFBFBD><EFBFBD>e2u<EFBFBD>H<EFBFBD>Z<EFBFBD><EFBFBD><EFBFBD>*<2A>D<EFBFBD><44><EFBFBD>p/<2F>!<21>LQ<4C><0E>Q<EFBFBD><51><EFBFBD>mV3inQpY
<T
<EFBFBD> 9 N<><1D><17><19>=C<><43><07><1D><14>P<EFBFBD>kkZp<5A><70><EFBFBD><EFBFBD>Ϳ!<21><02>Q7X<37>AݖM`<<3C> <20>':H_<48><5F><EFBFBD><1A><>L]5s<04><><EFBFBD>C<EFBFBD><43><EFBFBD><EFBFBD><EFBFBD>=<3D>7<EFBFBD>_<EFBFBD>P<EFBFBD><50>q*`<60><>(i<><69><EFBFBD><EFBFBD>4<1E>y<07>33<33><33><10><><EFBFBD><EFBFBD>l<EFBFBD>ۊƯ3s
xڭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <10><><EFBFBD>Xz<58><7A>ky<6B>7<EFBFBD>`<60>U{<7B>H1<48>Ip<49><70>@J<><4A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>&><3E>$dfIfv<07>^f<><66><EFBFBD><EFBFBD><EFBFBD><06><08><19><>{mD<6D><EFBFBD><EFBFBD>%"<18><>k<EFBFBD>:<3A><>o<EFBFBD>~7<19><1F> <13><><EFBFBD><EFBFBD>{i<><69>%<25>Rj![꼱p[<5B><><EFBFBD>[*X<><06><>*<2A>8<EFBFBD> N<><4E><EFBFBD>p<><70><EFBFBD> K<>0<><30><EFBFBD><EFBFBD>J<EFBFBD><4A>l<EFBFBD>6X"w}<7D><>a<EFBFBD><61>ߎ<EFBFBD>@<40><><EFBFBD><EFBFBD>jP<6A><50><0E>ȳ<>Z<EFBFBD>E<1D><>`%gꢘ

<EFBFBD> <0B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD>U

11
docs/build/html/py-modindex.html vendored
View File

@@ -48,7 +48,8 @@
<a href="#cap-g"><strong>g</strong></a> |
<a href="#cap-i"><strong>i</strong></a> |
<a href="#cap-n"><strong>n</strong></a> |
<a href="#cap-o"><strong>o</strong></a>
<a href="#cap-o"><strong>o</strong></a> |
<a href="#cap-t"><strong>t</strong></a>
</div>
<table class="indextable modindextable">
@@ -137,6 +138,14 @@
<td>
<a href="numerical.html#module-ode_model"><code class="xref">ode_model</code></a> <em>(*nix, Windows)</em></td><td>
<em>Models of ordinary differential equations.</em></td></tr>
<tr class="pcap"><td></td><td>&#160;</td><td></td></tr>
<tr class="cap" id="cap-t"><td></td><td>
<strong>t</strong></td><td></td></tr>
<tr>
<td></td>
<td>
<a href="time_of_day.html#module-time_of_day"><code class="xref">time_of_day</code></a> <em>(*nix, Windows)</em></td><td>
<em>Calculate time.</em></td></tr>
</table>

2
docs/build/html/searchindex.js vendored
View File

File diff suppressed because one or more lines are too long

282
docs/build/html/time_of_day.html vendored Normal file
View File

@@ -0,0 +1,282 @@
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta charset="utf-8" />
<title>time_of_day module &#8212; pylib 2019.5.19 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="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-time_of_day">
<span id="time-of-day-module"></span><h1>time_of_day module<a class="headerlink" href="#module-time_of_day" title="Permalink to this headline"></a></h1>
<p>Calculate time.</p>
<dl class="field-list simple">
<dt class="field-odd">Date</dt>
<dd class="field-odd"><p>2019-06-01</p>
</dd>
</dl>
<span class="target" id="module-time_of_day"></span><dl class="function">
<dt id="time_of_day.days">
<code class="descname">days</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#days"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.days" title="Permalink to this definition"></a></dt>
<dd><p>The days of the time (year).</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>hours, range [0, 365.2425]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.days_norm">
<code class="descname">days_norm</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#days_norm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.days_norm" title="Permalink to this definition"></a></dt>
<dd><p>The days normalized to 365.2425 (Gregorian, on average) days.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>the normalized days, range [0, 1]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.hours">
<code class="descname">hours</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#hours"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.hours" title="Permalink to this definition"></a></dt>
<dd><p>The hours of the time.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>hours, range [0, 24]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.hours_norm">
<code class="descname">hours_norm</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#hours_norm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.hours_norm" title="Permalink to this definition"></a></dt>
<dd><p>The hours normalized to 24 hours.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>the normalized hours, range [0, 1]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.in_seconds">
<code class="descname">in_seconds</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#in_seconds"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.in_seconds" title="Permalink to this definition"></a></dt>
<dd><p>If time is <cite>time.struct_time</cite> convert to float seconds.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>the time in seconds</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.minutes">
<code class="descname">minutes</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#minutes"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.minutes" title="Permalink to this definition"></a></dt>
<dd><p>The minutes of the time.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>minutes, range [0, 60]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.minutes_norm">
<code class="descname">minutes_norm</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#minutes_norm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.minutes_norm" title="Permalink to this definition"></a></dt>
<dd><p>The minutes normalized to 60 minutes.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>the normalized minutes, range [0, 1]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.seconds">
<code class="descname">seconds</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#seconds"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.seconds" title="Permalink to this definition"></a></dt>
<dd><p>The seconds of the time.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>seconds, range [0, 60]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.seconds_norm">
<code class="descname">seconds_norm</code><span class="sig-paren">(</span><em>time</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#seconds_norm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.seconds_norm" title="Permalink to this definition"></a></dt>
<dd><p>The seconds normalized to 60 seconds.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>time</strong> (float or <cite>time.struct_time</cite>) – the time in seconds</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>the normalized seconds, range [0, 1]</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</dd>
</dl>
</dd></dl>
<dl class="function">
<dt id="time_of_day.transform">
<code class="descname">transform</code><span class="sig-paren">(</span><em>time_norm</em>, <em>length</em>, <em>offset=0</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/time_of_day.html#transform"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#time_of_day.transform" title="Permalink to this definition"></a></dt>
<dd><p>Transform normalized time value to new length.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>position_norm</strong> (<em>float</em>) – the normalized time value to transform</p></li>
<li><p><strong>length</strong> (<em>float</em>) – the transformation</p></li>
<li><p><strong>offset</strong> (<em>float</em>) – the offset (default = 0)</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>the transformation value</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>float</p>
</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>
<div class="relations">
<h3>Related Topics</h3>
<ul>
<li><a href="index.html">Documentation overview</a><ul>
</ul></li>
</ul>
</div>
<div id="searchbox" style="display: none" role="search">
<h3>Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="search.html" method="get">
<input type="text" name="q" />
<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.0.1</a>
&amp; <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.12</a>
|
<a href="_sources/time_of_day.rst.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>

1
docs/source/modules.rst
View File

@@ -8,3 +8,4 @@ src
date
geometry
numerical
time_of_day

7
docs/source/time_of_day.rst Normal file
View File

@@ -0,0 +1,7 @@
time\_of\_day module
====================
.. automodule:: time_of_day
:members:
:undoc-members:
:show-inheritance: