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="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="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="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="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="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> <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/integration.html">numerical.integration</a></li>
<li><a href="numerical/ode.html">numerical.ode</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="numerical/ode_model.html">numerical.ode_model</a></li>
<li><a href="time_of_day.html">time_of_day</a></li>
</ul> </ul>
</div> </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="c1"># -*- coding: utf-8 -*-</span>
<span class="sd">&quot;&quot;&quot;Numerical solver of ordinary differential equations.</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">Solves the initial value problem for systems of first order</span>
<span class="sd">equations.</span> <span class="sd">ordinary differential equations.</span>
<span class="sd">:Date: 2015-09-21</span> <span class="sd">:Date: 2015-09-21</span>
@@ -68,7 +68,8 @@
<span class="sd"> :type x0: list</span> <span class="sd"> :type x0: list</span>
<span class="sd"> :param t: time</span> <span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</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"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span> <span class="sd"> :type verbose: bool</span>
@@ -83,14 +84,14 @@
<span class="sd"> .. math ::</span> <span class="sd"> .. math ::</span>
<span class="sd"> t_i = t_0 + i h ~,\quad i=1,2,\ldots,n</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"> The derivative of the solution is approximated as the forward</span>
<span class="sd"> equation</span> <span class="sd"> difference equation</span>
<span class="sd"> </span> <span class="sd"> </span>
<span class="sd"> .. math ::</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"> \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"> Therefore one step :math:`h` of the Euler method from</span>
<span class="sd"> :math:`t_{i+1}` is</span> <span class="sd"> :math:`t_i` to :math:`t_{i+1}` is</span>
<span class="sd"> .. math ::</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> <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"> .. math ::</span>
<span class="sd"> \dot{x} &amp;= f(t,x) \\</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} \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"> &amp;=</span>
<span class="sd"> \begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +</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> <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"> .. math ::</span>
<span class="sd"> \dot{x}_1 &amp;= x_2 \\</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"> or</span>
<span class="sd"> .. math ::</span> <span class="sd"> .. math ::</span>
<span class="sd"> \dot{x} &amp;= f(t,x) \\</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} \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"> &amp;=</span>
<span class="sd"> \begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} +</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"> \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}</span>
<span class="sd"> The Euler method is a first-order method,</span> <span class="sd"> The Euler method is a first-order method, which means that the</span>
<span class="sd"> which means that the local error (error per step) is proportional to the</span> <span class="sd"> local error (error per step) is proportional to the square of</span>
<span class="sd"> square of the step size, and the global error (error at a given time) is</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"> proportional to the step size.</span>
<span class="sd"> &quot;&quot;&quot;</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="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="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="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">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">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="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> <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> <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"> :type x0: list</span>
<span class="sd"> :param t: time</span> <span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</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"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span> <span class="sd"> :type verbose: bool</span>
<span class="sd"> &quot;&quot;&quot;</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="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="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="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">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_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">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="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> <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> <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"> :type x0: list</span>
<span class="sd"> :param t: time</span> <span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</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"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span> <span class="sd"> :type verbose: bool</span>
<span class="sd"> &quot;&quot;&quot;</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_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_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">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="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> <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> <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="sa">r</span><span class="sd">&quot;&quot;&quot;</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
<span class="sd"> :param f: :math:`f = \dot{x}`</span> <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Fixed-point iteration.</span>
<span class="sd"> :type f: function</span>
<span class="sd"> :param Dt: :math:`\Delta{t}`</span>
<span class="sd"> </span> <span class="sd"> </span>
<span class="sd"> :returns: :math:`\Delta x = \dot{x} \Delta t`</span> <span class="sd"> :param f: the function to iterate :math:`f = \dot{x}(x,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"> :type f: function</span> <span class="sd"> :type f: function</span>
<span class="sd"> :param xi: initial condition :math:`x_i`</span> <span class="sd"> :param xi: initial condition :math:`x_i`</span>
<span class="sd"> :type xi: list</span> <span class="sd"> :type xi: list</span>
<span class="sd"> :param t: time :math:`t`</span> <span class="sd"> :param ti: time :math:`t_i`</span>
<span class="sd"> :type t: float</span> <span class="sd"> :type ti: float</span>
<span class="sd"> :param `*p`: parameters of the function (thickness, diameter, ...)</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"> :param max_iterations: maximum number of iterations</span>
<span class="sd"> :type max_iterations: int</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"> :type tol: float</span>
<span class="sd"> :param verbose: print information (default = False)</span> <span class="sd"> :param verbose: print information (default = False)</span>
<span class="sd"> :type verbose: bool</span> <span class="sd"> :type verbose: bool</span>
<span class="sd"> </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"> </span>
<span class="sd"> .. math ::</span> <span class="sd"> .. math ::</span>
<span class="sd"> x_{i+1} = x_i + \Delta x</span> <span class="sd"> x_{i,j=0} = x_{i}</span>
<span class="sd"> </span>
<span class="sd"> .. seealso::</span> <span class="sd"> .. math ::</span>
<span class="sd"> :meth:`dxdt_Dt` for :math:`\Delta x`</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="sd"> &quot;&quot;&quot;</span>
<span class="n">xi</span> <span class="o">=</span> <span class="n">x0</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="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="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">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="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="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">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">xi</span> <span class="o">=</span> <span class="n">xi1</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">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="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="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> <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">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">verbose</span><span class="o">=</span><span class="kc">False</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>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;Implicite first-order method / backward Euler method.</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> <span class="sd"> :param f: the function to solve</span>
@@ -286,7 +293,8 @@
<span class="sd"> :type x0: list</span> <span class="sd"> :type x0: list</span>
<span class="sd"> :param t: time</span> <span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</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"> :param max_iterations: maximum number of iterations</span>
<span class="sd"> :type max_iterations: int</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 (default = 1e-9)</span>
@@ -298,26 +306,24 @@
<span class="sd"> &quot;&quot;&quot;</span> <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">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="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="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">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">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="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="c1"># available therefor using Newton-Raphson method</span> <span class="n">tol</span><span class="p">,</span> <span class="n">verbose</span><span class="p">)</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">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">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="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> <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="sa">r</span><span class="sd">&quot;&quot;&quot;Newmark method.</span>
<span class="sd"> :param f: the function to solve</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"> :type xpp0: list</span>
<span class="sd"> :param t: time</span> <span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</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"> :param gamma: newmark parameter for velocity (default = 0.5)</span>
<span class="sd"> :type gamma: float</span> <span class="sd"> :type gamma: float</span>
<span class="sd"> :param beta: newmark parameter for displacement (default = 0.25)</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">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">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">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">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">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">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="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">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="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="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">#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">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> <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="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="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">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> <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">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="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="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="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> <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="sa">r</span><span class="sd">&quot;&quot;&quot;Newmark method.</span>
<span class="sd"> :param f: the function to solve</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"> :type xpp0: list</span>
<span class="sd"> :param t: time</span> <span class="sd"> :param t: time</span>
<span class="sd"> :type t: list</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"> :param gamma: newmark parameter for velocity (default = 0.5)</span>
<span class="sd"> :type gamma: float</span> <span class="sd"> :type gamma: float</span>
<span class="sd"> :param beta: newmark parameter for displacement (default = 0.25)</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">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">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">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">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">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">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="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">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">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> <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">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">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="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">#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">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">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">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">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">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">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> <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">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="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="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="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> <span class="c1"># x = concatenate((x, xp, xpp), axis=1)</span>
</pre></div> </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 date
geometry geometry
numerical 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="#E"><strong>E</strong></a>
| <a href="#F"><strong>F</strong></a> | <a href="#F"><strong>F</strong></a>
| <a href="#G"><strong>G</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="#I"><strong>I</strong></a>
| <a href="#L"><strong>L</strong></a> | <a href="#L"><strong>L</strong></a>
| <a href="#M"><strong>M</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><a href="data.html#data.data_read">data_read() (in module data)</a>
</li> </li>
<li><a href="data.html#data.data_store">data_store() (in module data)</a> <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> </li>
</ul></td> </ul></td>
<td style="width: 33%; vertical-align: top;"><ul> <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>
<li><a href="numerical.html#numerical.ode_model.disk">disk() (in module numerical.ode_model)</a> <li><a href="numerical.html#numerical.ode_model.disk">disk() (in module numerical.ode_model)</a>
</li> </li>
<li><a href="numerical.html#numerical.ode_model.disk_nm">disk_nm() (in module numerical.ode_model)</a> <li><a href="numerical.html#numerical.ode_model.disk_nm">disk_nm() (in module numerical.ode_model)</a>
</li> </li>
<li><a href="numerical.html#numerical.ode_model.disk_nmmdk">disk_nmmdk() (in module numerical.ode_model)</a> <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> </li>
</ul></td> </ul></td>
</tr></table> </tr></table>
@@ -127,7 +130,7 @@
</li> </li>
</ul></td> </ul></td>
<td style="width: 33%; vertical-align: top;"><ul> <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> </li>
</ul></td> </ul></td>
</tr></table> </tr></table>
@@ -148,6 +151,18 @@
</ul></td> </ul></td>
</tr></table> </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> <h2 id="I">I</h2>
<table style="width: 100%" class="indextable genindextable"><tr> <table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
@@ -155,7 +170,7 @@
</li> </li>
</ul></td> </ul></td>
<td style="width: 33%; vertical-align: top;"><ul> <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>
<li><a href="numerical.html#module-integration">integration (module)</a> <li><a href="numerical.html#module-integration">integration (module)</a>
</li> </li>
@@ -174,6 +189,12 @@
<table style="width: 100%" class="indextable genindextable"><tr> <table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul> <td style="width: 33%; vertical-align: top;"><ul>
<li><a href="data.html#data.main">main() (in module data)</a> <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> </li>
</ul></td> </ul></td>
</tr></table> </tr></table>
@@ -241,6 +262,12 @@
<h2 id="S">S</h2> <h2 id="S">S</h2>
<table style="width: 100%" class="indextable genindextable"><tr> <table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul> <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><a href="geometry.html#geometry.square">square() (in module geometry)</a>
</li> </li>
</ul></td> </ul></td>
@@ -249,10 +276,14 @@
<h2 id="T">T</h2> <h2 id="T">T</h2>
<table style="width: 100%" class="indextable genindextable"><tr> <table style="width: 100%" class="indextable genindextable"><tr>
<td style="width: 33%; vertical-align: top;"><ul> <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> </li>
</ul></td> </ul></td>
<td style="width: 33%; vertical-align: top;"><ul> <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><a href="numerical.html#numerical.integration.trapez">trapez() (in module numerical.integration)</a>
</li> </li>
</ul></td> </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> <li class="toctree-l2"><a class="reference internal" href="numerical.html#module-numerical">Module contents</a></li>
</ul> </ul>
</li> </li>
<li class="toctree-l1"><a class="reference internal" href="time_of_day.html">time_of_day module</a></li>
</ul> </ul>
</div> </div>
</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"> <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> <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>Numerical solver of ordinary differential equations.</p>
<p>Solves the initial value problem for systems of first order ordinary differential <p>Solves the initial value problem for systems of first order
equations.</p> ordinary differential equations.</p>
<dl class="field-list simple"> <dl class="field-list simple">
<dt class="field-odd">Date</dt> <dt class="field-odd">Date</dt>
<dd class="field-odd"><p>2015-09-21</p> <dd class="field-odd"><p>2015-09-21</p>
</dd> </dd>
</dl> </dl>
<span class="target" id="module-ode"></span><dl class="function"> <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"> <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> <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 / <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>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>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</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> <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul> </ul>
</dd> </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> <p>Choose a value h for the size of every step and set</p>
<div class="math notranslate nohighlight"> <div class="math notranslate nohighlight">
\[t_i = t_0 + i h ~,\quad i=1,2,\ldots,n\]</div> \[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 <p>The derivative of the solution is approximated as the forward
equation</p> difference equation</p>
<div class="math notranslate nohighlight"> <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> \[\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 <p>Therefore one step <span class="math notranslate nohighlight">\(h\)</span> of the Euler method from
<span class="math notranslate nohighlight">\(t_{i+1}\)</span> is</p> <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"> <div class="math notranslate nohighlight">
\[\begin{split}x_{i+1} &amp;= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\ \[\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> 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"> <div class="math notranslate nohighlight">
\[\begin{split}\dot{x} &amp;= f(t,x) \\ \[\begin{split}\dot{x} &amp;= f(t,x) \\
\begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;= \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;= &amp;=
\begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} + \begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +
\begin{bmatrix} 0 &amp; 1 \\ -m^{-1} k &amp; -m^{-1} d \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> <p>becomes</p>
<div class="math notranslate nohighlight"> <div class="math notranslate nohighlight">
\[\begin{split}\dot{x}_1 &amp;= x_2 \\ \[\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> <p>or</p>
<div class="math notranslate nohighlight"> <div class="math notranslate nohighlight">
\[\begin{split}\dot{x} &amp;= f(t,x) \\ \[\begin{split}\dot{x} &amp;= f(t,x) \\
\begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;= \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;= &amp;=
\begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} + \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> \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}\end{split}\]</div>
<p>The Euler method is a first-order method, <p>The Euler method is a first-order method, which means that the
which means that the local error (error per step) is proportional to the local error (error per step) is proportional to the square of
square of the step size, and the global error (error at a given time) is the step size, and the global error (error at a given time) is
proportional to the step size.</p> proportional to the step size.</p>
</dd></dl> </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>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>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</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> <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul> </ul>
</dd> </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>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>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</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> <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul> </ul>
</dd> </dd>
@@ -339,30 +332,37 @@ proportional to the step size.</p>
</dd></dl> </dd></dl>
<dl class="function"> <dl class="function">
<dt id="numerical.ode.fixed_point_iteration"> <dt id="numerical.ode.fpi">
<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> <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><dl class="field-list simple"> <dd><p>Fixed-point iteration.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt> <dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple"> <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>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>ti</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t_i\)</span></p></li>
<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</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>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> <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
</ul> </ul>
</dd> </dd>
<dt class="field-even">Returns</dt> <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> </dd>
</dl> </dl>
<div class="math notranslate nohighlight"> <div class="math notranslate nohighlight">
\[x_{i+1} = x_i + \Delta x\]</div> \[x_{i,j=0} = x_{i}\]</div>
<div class="admonition seealso"> <div class="math notranslate nohighlight">
<p class="admonition-title">See also</p> \[x_{i,j+1} = x_i + \dot{x}(x_{i,j}, t_{i+1})\cdot(t_{i+1}-t_i)\]</div>
<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 class="math notranslate nohighlight">
</div> \[\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> </dd></dl>
<dl class="function"> <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>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>x0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>t</strong> (<em>list</em>) – time</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>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 (default = 1e-9)</p></li>
<li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</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> <p>The backward Euler method has order one and is A-stable.</p>
</dd></dl> </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"> <dl class="function">
<dt id="numerical.ode.newmark_newtonraphson"> <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> <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>xp0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>xpp0</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>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>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>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> <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"> <dl class="function">
<dt id="numerical.ode.newmark_newtonraphson_rdk"> <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> <dd><p>Newmark method.</p>
<dl class="field-list simple"> <dl class="field-list simple">
<dt class="field-odd">Parameters</dt> <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>xp0</strong> (<em>list</em>) – initial condition</p></li>
<li><p><strong>xpp0</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>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>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>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> <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 # Project: pylib
# Version: # Version:
# The remainder of this file is compressed using zlib. # 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 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ꢘ
<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 <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-g"><strong>g</strong></a> |
<a href="#cap-i"><strong>i</strong></a> | <a href="#cap-i"><strong>i</strong></a> |
<a href="#cap-n"><strong>n</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> </div>
<table class="indextable modindextable"> <table class="indextable modindextable">
@@ -137,6 +138,14 @@
<td> <td>
<a href="numerical.html#module-ode_model"><code class="xref">ode_model</code></a> <em>(*nix, Windows)</em></td><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> <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> </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 date
geometry geometry
numerical 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:

221
src/numerical/ode.py
View File

@@ -2,8 +2,8 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
"""Numerical solver of ordinary differential equations. """Numerical solver of ordinary differential equations.
Solves the initial value problem for systems of first order ordinary differential Solves the initial value problem for systems of first order
equations. ordinary differential equations.
:Date: 2015-09-21 :Date: 2015-09-21
@@ -33,7 +33,8 @@ def e1(f, x0, t, *p, verbose=False):
:type x0: list :type x0: list
:param t: time :param t: time
:type t: list :type t: list
:param `*p`: parameters of the function (thickness, diameter, ...) :param `*p`: parameters of the function (thickness, diameter,
...)
:param verbose: print information (default = False) :param verbose: print information (default = False)
:type verbose: bool :type verbose: bool
@@ -48,14 +49,14 @@ def e1(f, x0, t, *p, verbose=False):
.. math :: .. math ::
t_i = t_0 + i h ~,\quad i=1,2,\ldots,n t_i = t_0 + i h ~,\quad i=1,2,\ldots,n
The derivative of the solution is approximated as the forward difference The derivative of the solution is approximated as the forward
equation difference equation
.. math :: .. math ::
\dot{x}_i = f(t_i, x_i) = \frac{x_{i+1} - x_i}{t_{i+1}-t_i} \dot{x}_i = f(t_i, x_i) = \frac{x_{i+1} - x_i}{t_{i+1}-t_i}
Therefore one step :math:`h` of the Euler method from :math:`t_i` to Therefore one step :math:`h` of the Euler method from
:math:`t_{i+1}` is :math:`t_i` to :math:`t_{i+1}` is
.. math :: .. math ::
x_{i+1} &= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\ x_{i+1} &= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\
@@ -84,7 +85,8 @@ def e1(f, x0, t, *p, verbose=False):
.. math :: .. math ::
\dot{x} &= f(t,x) \\ \dot{x} &= f(t,x) \\
\begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &= \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &=
\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} \\
&= &=
\begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} + \begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +
\begin{bmatrix} 0 & 1 \\ -m^{-1} k & -m^{-1} d \end{bmatrix} \begin{bmatrix} 0 & 1 \\ -m^{-1} k & -m^{-1} d \end{bmatrix}
@@ -106,32 +108,39 @@ def e1(f, x0, t, *p, verbose=False):
.. math :: .. math ::
\dot{x}_1 &= x_2 \\ \dot{x}_1 &= x_2 \\
\dot{x}_2 &= m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\ \dot{x}_2 &=
m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\
or or
.. math :: .. math ::
\dot{x} &= f(t,x) \\ \dot{x} &= f(t,x) \\
\begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &= \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \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} \\ \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} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} + \begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} +
\begin{bmatrix} 0 & 1 \\ -m^{-1}(x_1) k(x_1) & -m^{-1} d(x_1,x_2) \end{bmatrix} \begin{bmatrix}
0 & 1 \\ -m^{-1}(x_1) k(x_1) & -m^{-1} d(x_1,x_2)
\end{bmatrix}
\begin{bmatrix} x_1 \\ x_2 \end{bmatrix} \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}
The Euler method is a first-order method, The Euler method is a first-order method, which means that the
which means that the local error (error per step) is proportional to the local error (error per step) is proportional to the square of
square of the step size, and the global error (error at a given time) is the step size, and the global error (error at a given time) is
proportional to the step size. proportional to the step size.
""" """
x = zeros((len(t), len(x0))) # Preallocate array x = zeros((len(t), len(x0))) # Preallocate array
x[0,:] = x0 # Initial condition gives solution at first t x[0,:] = x0 # Initial condition gives solution at first t
for i in range(len(t)-1): # Calculation loop for i in range(len(t)-1): # Calculation loop
Dt = t[i+1]-t[i] Dt = t[i+1]-t[i]
dxdt = array(f(x[i,:], t[i], *p)) dxdt = array(f(x[i,:], t[i], *p))
x[i+1,:] = x[i,:] + dxdt*Dt # Approximate solution at next value of x # Approximate solution at next value of x
x[i+1,:] = x[i,:] + dxdt*Dt
if verbose: if verbose:
print('Numerical integration of ODE using explicit first-order method (Euler / Runge-Kutta) was successful.') print('Numerical integration of ODE using explicit ' +
'first-order method (Euler / Runge-Kutta) was successful.')
return x return x
def e2(f, x0, t, *p, verbose=False): def e2(f, x0, t, *p, verbose=False):
@@ -143,19 +152,22 @@ def e2(f, x0, t, *p, verbose=False):
:type x0: list :type x0: list
:param t: time :param t: time
:type t: list :type t: list
:param `*p`: parameters of the function (thickness, diameter, ...) :param `*p`: parameters of the function (thickness, diameter,
...)
:param verbose: print information (default = False) :param verbose: print information (default = False)
:type verbose: bool :type verbose: bool
""" """
x = zeros((len(t), len(x0))) # Preallocate array x = zeros((len(t), len(x0))) # Preallocate array
x[0,:] = x0 # Initial condition gives solution at first t x[0,:] = x0 # Initial condition gives solution at first t
for i in range(len(t)-1): # Calculation loop for i in range(len(t)-1): # Calculation loop
Dt = t[i+1]-t[i] Dt = t[i+1]-t[i]
k_1 = array(f(x[i,:], t[i], *p)) k_1 = array(f(x[i,:], t[i], *p))
k_2 = array(f(x[i,:]+0.5*Dt*k_1, t[i]+0.5*Dt, *p)) k_2 = array(f(x[i,:]+0.5*Dt*k_1, t[i]+0.5*Dt, *p))
x[i+1,:] = x[i,:] + k_2*Dt # Approximate solution at next value of x # Approximate solution at next value of x
x[i+1,:] = x[i,:] + k_2*Dt
if verbose: if verbose:
print('Numerical integration of ODE using explicit 2th-order method (Runge-Kutta) was successful.') print('Numerical integration of ODE using explicit ' +
'2th-order method (Runge-Kutta) was successful.')
return x return x
def e4(f, x0, t, *p, verbose=False): def e4(f, x0, t, *p, verbose=False):
@@ -167,7 +179,8 @@ def e4(f, x0, t, *p, verbose=False):
:type x0: list :type x0: list
:param t: time :param t: time
:type t: list :type t: list
:param `*p`: parameters of the function (thickness, diameter, ...) :param `*p`: parameters of the function (thickness, diameter,
...)
:param verbose: print information (default = False) :param verbose: print information (default = False)
:type verbose: bool :type verbose: bool
""" """
@@ -179,70 +192,64 @@ def e4(f, x0, t, *p, verbose=False):
k_2 = array(f(x[i,:]+0.5*Dt*k_1, t[i]+0.5*Dt, *p)) k_2 = array(f(x[i,:]+0.5*Dt*k_1, t[i]+0.5*Dt, *p))
k_3 = array(f(x[i,:]+0.5*Dt*k_2, t[i]+0.5*Dt, *p)) k_3 = array(f(x[i,:]+0.5*Dt*k_2, t[i]+0.5*Dt, *p))
k_4 = array(f(x[i,:]+k_3*Dt, t[i]+Dt, *p)) k_4 = array(f(x[i,:]+k_3*Dt, t[i]+Dt, *p))
x[i+1,:] = x[i,:] + 1./6*(k_1+2*k_2+2*k_3+k_4)*Dt # Approximate solution at next value of x # Approximate solution at next value of x
x[i+1,:] = x[i,:] + 1./6*(k_1+2*k_2+2*k_3+k_4)*Dt
if verbose: if verbose:
print('Numerical integration of ODE using explicit 4th-order method (Runge-Kutta) was successful.') print('Numerical integration of ODE using explicit ' +
'4th-order method (Runge-Kutta) was successful.')
return x return x
def dxdt_Dt(f, x, t, Dt, *p): def fpi(f, xi, ti, ti1, *p, max_iterations=1000, tol=1e-9,
r""" verbose=False):
:param f: :math:`f = \dot{x}` r"""Fixed-point iteration.
:type f: function
:param Dt: :math:`\Delta{t}`
:returns: :math:`\Delta x = \dot{x} \Delta t` :param f: the function to iterate :math:`f = \dot{x}(x,t)`
"""
return array(dxdt(x, t, *p)) * Dt
def fixed_point_iteration(f, xi, t, max_iterations=1000, tol=1e-9, verbose=False):
r"""
:param f: the function to iterate :math:`f = \Delta{x}(t)`
:type f: function :type f: function
:param xi: initial condition :math:`x_i` :param xi: initial condition :math:`x_i`
:type xi: list :type xi: list
:param t: time :math:`t` :param ti: time :math:`t_i`
:type t: float :type ti: float
:param `*p`: parameters of the function (thickness, diameter, ...) :param ti1: time :math:`t_{i+1}`
:type ti1: float
:param `*p`: parameters of the function (thickness, diameter,
...)
:param max_iterations: maximum number of iterations :param max_iterations: maximum number of iterations
:type max_iterations: int :type max_iterations: int
:param tol: tolerance against residuum (default = 1e-9) :param tol: tolerance against residuum :math:`\varepsilon`
(default = 1e-9)
:type tol: float :type tol: float
:param verbose: print information (default = False) :param verbose: print information (default = False)
:type verbose: bool :type verbose: bool
:returns: :math:`x_{i+1}` :returns: :math:`x_{i}`
.. math :: .. math ::
x_{i+1} = x_i + \Delta x x_{i,j=0} = x_{i}
.. seealso:: .. math ::
:meth:`dxdt_Dt` for :math:`\Delta x` x_{i,j+1} = x_i + \dot{x}(x_{i,j}, t_{i+1})\cdot(t_{i+1}-t_i)
.. math ::
\text{residuum} = \frac{\lVert x_{i,j+1}-x_{i,j}\rVert}
{\lVert x_{i,j+1} \rVert} < \varepsilon
.. math ::
x_{i} = x_{i,j=\text{end}}
""" """
xi = x0 xij = xi
for j in range(max_iterations): # Fixed-point iteration for j in range(max_iterations):
Dx = array(f(xi, t, *p)) dxdt = array(f(xij, ti1, *p))
xi1 = x0 + Dx # Approximate solution at next value of x # Approximate solution at next value of x
residuum = norm(xi1-xi)/norm(xi1) xij1 = xi + dxdt * (ti1-ti)
xi = xi1 residuum = norm(xij1-xij)/norm(xij1)
xij = xij1
if residuum < tol: if residuum < tol:
break break
iterations = j+1 # number beginning with 1 therefore + 1 iterations = j+1 # number beginning with 1 therefore + 1
return xi, iterations return xij, iterations
def i1n(f, x0, t, *p, max_iterations=1000, tol=1e-9, verbose=False): def i1(f, x0, t, *p, max_iterations=1000, tol=1e-9,
iterations = zeros((len(t), 1)) verbose=False):
x = zeros((len(t), len(x0))) # Preallocate array
x[0,:] = x0 # Initial condition gives solution at first t
for i in range(len(t)-1):
Dt = t[i+1]-t[i]
xi = x[i,:]
Dx = dxdt_Dt(f, xi, t[i+1], Dt, *p)
x[i+1,:], iterations[i] = fixed_point_iteration(Dx, xi, t, max_iterations, tol, verbose)
if verbose:
print('Numerical integration of ODE using implicite first-order method (Euler) was successful.')
return x, iterations
def i1(f, x0, t, *p, max_iterations=1000, tol=1e-9, verbose=False):
r"""Implicite first-order method / backward Euler method. r"""Implicite first-order method / backward Euler method.
:param f: the function to solve :param f: the function to solve
@@ -251,7 +258,8 @@ def i1(f, x0, t, *p, max_iterations=1000, tol=1e-9, verbose=False):
:type x0: list :type x0: list
:param t: time :param t: time
:type t: list :type t: list
:param `*p`: parameters of the function (thickness, diameter, ...) :param `*p`: parameters of the function (thickness, diameter,
...)
:param max_iterations: maximum number of iterations :param max_iterations: maximum number of iterations
:type max_iterations: int :type max_iterations: int
:param tol: tolerance against residuum (default = 1e-9) :param tol: tolerance against residuum (default = 1e-9)
@@ -263,26 +271,24 @@ def i1(f, x0, t, *p, max_iterations=1000, tol=1e-9, verbose=False):
""" """
iterations = zeros((len(t), 1)) iterations = zeros((len(t), 1))
x = zeros((len(t), len(x0))) # Preallocate array x = zeros((len(t), len(x0))) # Preallocate array
x[0,:] = x0 # Initial condition gives solution at first t x[0,:] = x0 # Initial condition gives solution at first t
# x(i+1) = x(i) + f(x(i+1), t(i+1)), exact value of
# f(x(i+1), t(i+1)) is not available therefore using
# Newton-Raphson method
for i in range(len(t)-1): for i in range(len(t)-1):
Dt = t[i+1]-t[i] Dt = t[i+1]-t[i]
xi = x[i,:] xi = x[i,:]
# x(i+1) = x(i) + f(x(i+1), t(i+1)), exact value of f(x(i+1), t(i+1)) is not xi, iteration = fpi(f, xi, t[i], t[i+1], *p, max_iterations,
# available therefor using Newton-Raphson method tol, verbose)
for j in range(max_iterations): # Fixed-point iteration
dxdt = array(f(xi, t[i+1], *p))
xi1 = x[i,:] + dxdt*Dt # Approximate solution at next value of x
residuum = norm(xi1-xi)/norm(xi1)
xi = xi1
if residuum < tol:
break
iterations[i] = j+1
x[i+1,:] = xi x[i+1,:] = xi
iterations[i] = iteration
if verbose: if verbose:
print('Numerical integration of ODE using implicite first-order method (Euler) was successful.') print('Numerical integration of ODE using implicite ' +
'first-order method (Euler) was successful.')
return x, iterations return x, iterations
def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_iterations=1000, tol=1e-9, verbose=False): def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5,
beta=.25, max_iterations=1000, tol=1e-9, verbose=False):
r"""Newmark method. r"""Newmark method.
:param f: the function to solve :param f: the function to solve
@@ -295,7 +301,8 @@ def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_itera
:type xpp0: list :type xpp0: list
:param t: time :param t: time
:type t: list :type t: list
:param `*p`: parameters of the function (thickness, diameter, ...) :param `*p`: parameters of the function (thickness, diameter,
...)
:param gamma: newmark parameter for velocity (default = 0.5) :param gamma: newmark parameter for velocity (default = 0.5)
:type gamma: float :type gamma: float
:param beta: newmark parameter for displacement (default = 0.25) :param beta: newmark parameter for displacement (default = 0.25)
@@ -311,9 +318,9 @@ def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_itera
x = zeros((len(t), len(x0))) # Preallocate array x = zeros((len(t), len(x0))) # Preallocate array
xp = zeros((len(t), len(xp0))) # Preallocate array xp = zeros((len(t), len(xp0))) # Preallocate array
xpp = zeros((len(t), len(xpp0))) # Preallocate array xpp = zeros((len(t), len(xpp0))) # Preallocate array
x[0,:] = x0 # Initial condition gives solution at first t x[0,:] = x0 # Initial condition gives solution at first t
xp[0,:] = xp0 # Initial condition gives solution at first t xp[0,:] = xp0 # Initial condition gives solution at first t
xpp[0,:] = xpp0 # Initial condition gives solution at first t xpp[0,:] = xpp0 # Initial condition gives solution at first t
for i in range(len(t)-1): for i in range(len(t)-1):
Dt = t[i+1]-t[i] Dt = t[i+1]-t[i]
@@ -326,7 +333,8 @@ def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_itera
j = 0 j = 0
for j in range(max_iterations): # Fixed-point iteration for j in range(max_iterations): # Fixed-point iteration
#dxdt = array(f(t[i+1], x1, p)) #dxdt = array(f(t[i+1], x1, p))
#x11 = x[i,:] + dxdt*Dt # Approximate solution at next value of x # Approximate solution at next value of x
#x11 = x[i,:] + dxdt*Dt
N, dN, dNp, dNpp = f(x1.reshape(-1,).tolist(), N, dN, dNp, dNpp = f(x1.reshape(-1,).tolist(),
xp1.reshape(-1,).tolist(), xpp1.reshape(-1,).tolist(), xp1.reshape(-1,).tolist(), xpp1.reshape(-1,).tolist(),
@@ -335,7 +343,8 @@ def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_itera
print('divergiert') print('divergiert')
break break
xpp11 = xpp1 - dot(inv(dNpp), (N + dot(dN, (x1-xi)) + dot(dNp, (xp1-xpi)))) xpp11 = xpp1 - dot(inv(dNpp), (N + dot(dN, (x1-xi)) + \
dot(dNp, (xp1-xpi))))
xp1 = xpi + Dt*( (1-gamma)*xppi + gamma*xpp11 ) xp1 = xpi + Dt*( (1-gamma)*xppi + gamma*xpp11 )
x1 = xi + Dt*xpi + Dt**2*( (.5-beta)*xppi + beta*xpp11 ) x1 = xi + Dt*xpi + Dt**2*( (.5-beta)*xppi + beta*xpp11 )
@@ -349,11 +358,13 @@ def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_itera
xp[i+1,:] = xp1.reshape(-1,).tolist() xp[i+1,:] = xp1.reshape(-1,).tolist()
x[i+1,:] = x1.reshape(-1,).tolist() x[i+1,:] = x1.reshape(-1,).tolist()
if verbose: if verbose:
print('Numerical integration of ODE using explicite newmark method was successful.') print('Numerical integration of ODE using explicite ' +
'newmark method was successful.')
return x, xp, xpp, iterations return x, xp, xpp, iterations
# x = concatenate((x, xp, xpp), axis=1) # x = concatenate((x, xp, xpp), axis=1)
def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, maxIterations=1000, tol=1e-9, verbose=False): def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5,
beta=.25, max_iterations=1000, tol=1e-9, verbose=False):
r"""Newmark method. r"""Newmark method.
:param f: the function to solve :param f: the function to solve
@@ -366,7 +377,8 @@ def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max
:type xpp0: list :type xpp0: list
:param t: time :param t: time
:type t: list :type t: list
:param `*p`: parameters of the function (thickness, diameter, ...) :param `*p`: parameters of the function (thickness, diameter,
...)
:param gamma: newmark parameter for velocity (default = 0.5) :param gamma: newmark parameter for velocity (default = 0.5)
:type gamma: float :type gamma: float
:param beta: newmark parameter for displacement (default = 0.25) :param beta: newmark parameter for displacement (default = 0.25)
@@ -382,13 +394,14 @@ def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max
x = zeros((len(t), len(x0))) # Preallocate array x = zeros((len(t), len(x0))) # Preallocate array
xp = zeros((len(t), len(xp0))) # Preallocate array xp = zeros((len(t), len(xp0))) # Preallocate array
xpp = zeros((len(t), len(xpp0))) # Preallocate array xpp = zeros((len(t), len(xpp0))) # Preallocate array
x[0,:] = x0 # Initial condition gives solution at first t x[0,:] = x0 # Initial condition gives solution at first t
xp[0,:] = xp0 # Initial condition gives solution at first t xp[0,:] = xp0 # Initial condition gives solution at first t
xpp[0,:] = xpp0 # Initial condition gives solution at first t xpp[0,:] = xpp0 # Initial condition gives solution at first t
for i in range(len(t)-1): for i in range(len(t)-1):
Dt = t[i+1]-t[i] Dt = t[i+1]-t[i]
rm, rmx, rmxpp, rd, rdx, rdxp, rk, rkx, f = fnm(x[i,:], xp[i,:], xpp[i,:], t[i], *p) rm, rmx, rmxpp, rd, rdx, rdxp, rk, rkx, f = fnm(x[i,:],
xp[i,:], xpp[i,:], t[i], *p)
xi = x[i,:].reshape(3,1) xi = x[i,:].reshape(3,1)
xpi = xp[i,:].reshape(3,1) xpi = xp[i,:].reshape(3,1)
@@ -397,13 +410,16 @@ def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max
xp1 = xpi xp1 = xpi
xpp1 = xppi xpp1 = xppi
j = 0 j = 0
for j in range(maxIterations): # Fixed-point iteration for j in range(max_iterations): # Fixed-point iteration
#dxdt = array(f(t[i+1], x1, p)) #dxdt = array(f(t[i+1], x1, p))
#x11 = x[i,:] + dxdt*Dt # Approximate solution at next value of x # Approximate solution at next value of x
#x11 = x[i,:] + dxdt*Dt
r = (rmx+rdx+rkx)*Dt**2./4 + rdxp*Dt/2 + rmxpp r = (rmx+rdx+rkx)*Dt**2./4 + rdxp*Dt/2 + rmxpp
rp = f - (rm + dot(rmx, (Dt*xpi+Dt**2./4*xppi)) - dot(rmxpp, xppi) + \ rp = f - (rm + dot(rmx, (Dt*xpi+Dt**2./4*xppi)) - \
rd + dot(rdx, (Dt*xpi+Dt**2./4*xppi)) + dot(rdxp, Dt/2*xppi) + \ dot(rmxpp, xppi) + \
rd + dot(rdx, (Dt*xpi+Dt**2./4*xppi)) + \
dot(rdxp, Dt/2*xppi) + \
rk + dot(rkx, (Dt*xpi+Dt**2./4*xppi)) ) rk + dot(rkx, (Dt*xpi+Dt**2./4*xppi)) )
xpp11 = dot(inv(r), rp) xpp11 = dot(inv(r), rp)
xp1 = xpi + Dt*( (1-gamma)*xppi + gamma*xpp11 ) xp1 = xpi + Dt*( (1-gamma)*xppi + gamma*xpp11 )
@@ -419,6 +435,7 @@ def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max
xp[i+1,:] = xp1.reshape(-1,).tolist() xp[i+1,:] = xp1.reshape(-1,).tolist()
x[i+1,:] = x1.reshape(-1,).tolist() x[i+1,:] = x1.reshape(-1,).tolist()
if verbose: if verbose:
print('Numerical integration of ODE using explicite newmark method was successful.') print('Numerical integration of ODE using explicite ' +
'newmark method was successful.')
return x, xp, xpp, iterations return x, xp, xpp, iterations
# x = concatenate((x, xp, xpp), axis=1) # x = concatenate((x, xp, xpp), axis=1)

156
src/time_of_day.py Normal file
View File

@@ -0,0 +1,156 @@
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Calculate time.
:Date: 2019-06-01
.. module:: time_of_day
:platform: *nix, Windows
:synopsis: Calculate time.
.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
"""
from __future__ import division, print_function, unicode_literals
from time import struct_time, mktime
def in_seconds(time):
"""If time is `time.struct_time` convert to float seconds.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: the time in seconds
:rtype: float
"""
if isinstance(time, struct_time):
time = mktime(time)
return time
def seconds(time):
"""The seconds of the time.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: seconds, range [0, 60]
:rtype: float
"""
return in_seconds(time)%60
def seconds_norm(time):
"""The seconds normalized to 60 seconds.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: the normalized seconds, range [0, 1]
:rtype: float
"""
return seconds(time)/60
def minutes(time):
"""The minutes of the time.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: minutes, range [0, 60]
:rtype: float
"""
return in_seconds(time)/60%60
def minutes_norm(time):
"""The minutes normalized to 60 minutes.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: the normalized minutes, range [0, 1]
:rtype: float
"""
return minutes(time)/60
def hours(time):
"""The hours of the time.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: hours, range [0, 24]
:rtype: float
"""
return in_seconds(time)/60/60%24
def hours_norm(time):
"""The hours normalized to 24 hours.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: the normalized hours, range [0, 1]
:rtype: float
"""
return hours(time)/24
def days(time):
"""The days of the time (year).
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: hours, range [0, 365.2425]
:rtype: float
"""
return in_seconds(time)/60/60/24%365.2425
def days_norm(time):
"""The days normalized to 365.2425 (Gregorian, on average) days.
:param time: the time in seconds
:type time: float or `time.struct_time`
:returns: the normalized days, range [0, 1]
:rtype: float
"""
return days(time)/365.2425
def transform(time_norm, length, offset=0):
"""Transform normalized time value to new length.
:param position_norm: the normalized time value to transform
:type position_norm: float
:param length: the transformation
:type length: float
:param offset: the offset (default = 0)
:type offset: float
:returns: the transformation value
:rtype: float
"""
return time_norm*length + offset
if __name__ == "__main__":
from time import time, gmtime, localtime
# time in seconds
t = time()
min = minutes(t)
h = hours(t)
min_norm = minutes_norm(t)
h_norm = hours_norm(t)
print('min ', min)
print('h ', h)
print('min_norm ', min_norm)
print('h_norm ', h_norm)
x_len = 30
x_offset = -8
x_pos = transform(min_norm, x_len, x_offset)
print('m[-8,22] ', x_pos)
y_len = 20
y_offset = -10
y_pos = transform(h_norm, y_len, y_offset)
print('h[-10,10]', y_pos)

95
tests/test_time_of_day.py Normal file
View File

@@ -0,0 +1,95 @@
"""Test of fit module.
:Date: 2019-06-01
.. module:: test_fit
:platform: *nix, Windows
:synopsis: Test of fit module.
.. moduleauthor:: Daniel Weschke <daniel.weschke@directbox.de>
"""
from __future__ import division, print_function, unicode_literals
import unittest
from time import mktime
import os
import sys
sys.path.insert(0, os.path.abspath('../src'))
from time_of_day import (in_seconds, seconds, seconds_norm,
minutes, minutes_norm, hours, hours_norm, days, days_norm,
transform)
# tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec,
# tm_wday, tm_yday, tm_isdst
T = mktime((2000, 11, 30, 0, 10, 20, 3, 335, -1))
class TestTimeOfDay(unittest.TestCase):
def test_in_seconds(self):
"""test in_seconds"""
t = in_seconds(T)
self.assertEqual(t, 975539420.0)
def test_seconds(self):
"""test seconds"""
t = seconds(T)
self.assertEqual(t, 20.0)
def test_seconds_norm(self):
"""test seconds_norm"""
t = seconds_norm(T)
self.assertEqual(t, 20.0/60) # 0.3333333333333333
def test_minutes(self):
"""test minutes"""
t = minutes(T)
self.assertEqual(t, T/60%60) # 10.333333333954215
def test_minutes_norm(self):
"""test minutes_norm"""
t = minutes_norm(T)
self.assertEqual(t, T/60%60/60) # 0.17222222223257025
def test_hours(self):
"""test hours"""
t = hours(T)
self.assertEqual(t, T/60/60%24) # 23.172222222259734
def test_hours_norm(self):
"""test hours_norm"""
t = hours_norm(T)
self.assertEqual(t, T/60/60%24/24) # 0.9655092592608222
def test_days(self):
"""test days"""
t = days(T)
self.assertEqual(t, T/60/60/24%365.2425) # 333.69050925926
def test_days_norm(self):
"""test days_norm"""
t = days_norm(T)
# 0.9136135834664915
self.assertEqual(t, T/60/60/24%365.2425/365.2425)
def test_transform_minutes(self):
"""test transform minutes"""
min_norm = minutes_norm(T)
x_len = 30
x_offset = -8
x_pos = transform(min_norm, x_len, x_offset)
# -2.8333333330228925
self.assertEqual(x_pos, min_norm*x_len + x_offset)
def test_transform_hours(self):
"""test transform hours"""
h_norm = hours_norm(T)
y_len = 20
y_offset = -10
y_pos = transform(h_norm, y_len, y_offset)
# 9.310185185216444
self.assertEqual(y_pos, h_norm*y_len + y_offset)
if __name__ == '__main__':
unittest.main()