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

2019-06-01 15:51:35 +02:00
parent 0162ce2701
commit 4ec84c49ac
18 changed files with 1148 additions and 270 deletions
--- a/docs/build/html/_modules/index.html
+++ b/docs/build/html/_modules/index.html
@@ -40,6 +40,7 @@
 <li><a href="numerical/integration.html">numerical.integration</a></li>
 <li><a href="numerical/ode.html">numerical.ode</a></li>
 <li><a href="numerical/ode_model.html">numerical.ode_model</a></li>
+<li><a href="time_of_day.html">time_of_day</a></li>
 </ul>

          </div>
--- a/docs/build/html/_modules/numerical/ode.html
+++ b/docs/build/html/_modules/numerical/ode.html
@@ -37,8 +37,8 @@
 <span class="c1"># -*- coding: utf-8 -*-</span>
 <span class="sd">&quot;&quot;&quot;Numerical solver of ordinary differential equations.</span>

-<span class="sd">Solves the initial value problem for systems of first order ordinary differential</span>
-<span class="sd">equations.</span>
+<span class="sd">Solves the initial value problem for systems of first order</span>
+<span class="sd">ordinary differential equations.</span>

 <span class="sd">:Date: 2015-09-21</span>

@@ -68,7 +68,8 @@
 <span class="sd">  :type x0: list</span>
 <span class="sd">  :param t: time</span>
 <span class="sd">  :type t: list</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param verbose: print information (default = False)</span>
 <span class="sd">  :type verbose: bool</span>

@@ -83,14 +84,14 @@
 <span class="sd">  .. math ::</span>
 <span class="sd">    t_i = t_0 + i h ~,\quad i=1,2,\ldots,n</span>

-<span class="sd">  The derivative of the solution is approximated as the forward difference</span>
-<span class="sd">  equation</span>
+<span class="sd">  The derivative of the solution is approximated as the forward</span>
+<span class="sd">  difference equation</span>
 <span class="sd">  </span>
 <span class="sd">  .. math ::</span>
 <span class="sd">    \dot{x}_i = f(t_i, x_i) = \frac{x_{i+1} - x_i}{t_{i+1}-t_i}</span>

-<span class="sd">  Therefore one step :math:`h` of the Euler method from :math:`t_i` to</span>
-<span class="sd">  :math:`t_{i+1}` is</span>
+<span class="sd">  Therefore one step :math:`h` of the Euler method from</span>
+<span class="sd">  :math:`t_i` to :math:`t_{i+1}` is</span>

 <span class="sd">  .. math ::</span>
 <span class="sd">    x_{i+1} &amp;= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\</span>
@@ -119,7 +120,8 @@
 <span class="sd">  .. math ::</span>
 <span class="sd">    \dot{x} &amp;= f(t,x) \\</span>
 <span class="sd">    \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=</span>
-<span class="sd">    \begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1) \end{bmatrix}  \\</span>
+<span class="sd">    \begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1)</span>
+<span class="sd">    \end{bmatrix} \\</span>
 <span class="sd">    &amp;=</span>
 <span class="sd">    \begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +</span>
 <span class="sd">    \begin{bmatrix} 0 &amp; 1 \\ -m^{-1} k &amp; -m^{-1} d \end{bmatrix}</span>
@@ -141,22 +143,27 @@

 <span class="sd">  .. math ::</span>
 <span class="sd">    \dot{x}_1 &amp;= x_2 \\</span>
-<span class="sd">    \dot{x}_2 &amp;= m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\</span>
+<span class="sd">    \dot{x}_2 &amp;=</span>
+<span class="sd">      m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\</span>

 <span class="sd">  or</span>

 <span class="sd">  .. math ::</span>
 <span class="sd">    \dot{x} &amp;= f(t,x) \\</span>
 <span class="sd">    \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=</span>
-<span class="sd">    \begin{bmatrix} x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \end{bmatrix}  \\</span>
+<span class="sd">    \begin{bmatrix}</span>
+<span class="sd">      x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1)</span>
+<span class="sd">      \end{bmatrix} \\</span>
 <span class="sd">    &amp;=</span>
 <span class="sd">    \begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} +</span>
-<span class="sd">    \begin{bmatrix} 0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2) \end{bmatrix}</span>
+<span class="sd">    \begin{bmatrix}</span>
+<span class="sd">      0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2)</span>
+<span class="sd">      \end{bmatrix}</span>
 <span class="sd">    \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}</span>

-<span class="sd">  The Euler method is a first-order method,</span>
-<span class="sd">  which means that the local error (error per step) is proportional to the</span>
-<span class="sd">  square of the step size, and the global error (error at a given time) is</span>
+<span class="sd">  The Euler method is a first-order method, which means that the</span>
+<span class="sd">  local error (error per step) is proportional to the square of</span>
+<span class="sd">  the step size, and the global error (error at a given time) is</span>
 <span class="sd">  proportional to the step size.</span>
 <span class="sd">  &quot;&quot;&quot;</span>
  <span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span>  <span class="c1"># Preallocate array</span>
@@ -164,9 +171,11 @@
  <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>     <span class="c1"># Calculation loop</span>
    <span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
    <span class="n">dxdt</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
-    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">dxdt</span><span class="o">*</span><span class="n">Dt</span>    <span class="c1"># Approximate solution at next value of x</span>
+    <span class="c1"># Approximate solution at next value of x</span>
+    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">dxdt</span><span class="o">*</span><span class="n">Dt</span>
  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit first-order method (Euler / Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit &#39;</span> <span class="o">+</span>
+      <span class="s1">&#39;first-order method (Euler / Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
  <span class="k">return</span> <span class="n">x</span></div>

 <div class="viewcode-block" id="e2"><a class="viewcode-back" href="../../numerical.html#numerical.ode.e2">[docs]</a><span class="k">def</span> <span class="nf">e2</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
@@ -178,7 +187,8 @@
 <span class="sd">  :type x0: list</span>
 <span class="sd">  :param t: time</span>
 <span class="sd">  :type t: list</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param verbose: print information (default = False)</span>
 <span class="sd">  :type verbose: bool</span>
 <span class="sd">  &quot;&quot;&quot;</span>
@@ -188,9 +198,11 @@
    <span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
    <span class="n">k_1</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
    <span class="n">k_2</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="o">*</span><span class="n">k_1</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
-    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">k_2</span><span class="o">*</span><span class="n">Dt</span>     <span class="c1"># Approximate solution at next value of x</span>
+    <span class="c1"># Approximate solution at next value of x</span>
+    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">k_2</span><span class="o">*</span><span class="n">Dt</span>
  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit 2th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit &#39;</span> <span class="o">+</span>
+      <span class="s1">&#39;2th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
  <span class="k">return</span> <span class="n">x</span></div>

 <div class="viewcode-block" id="e4"><a class="viewcode-back" href="../../numerical.html#numerical.ode.e4">[docs]</a><span class="k">def</span> <span class="nf">e4</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
@@ -202,7 +214,8 @@
 <span class="sd">  :type x0: list</span>
 <span class="sd">  :param t: time</span>
 <span class="sd">  :type t: list</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param verbose: print information (default = False)</span>
 <span class="sd">  :type verbose: bool</span>
 <span class="sd">  &quot;&quot;&quot;</span>
@@ -214,70 +227,64 @@
    <span class="n">k_2</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="o">*</span><span class="n">k_1</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
    <span class="n">k_3</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="o">*</span><span class="n">k_2</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="mf">0.5</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
    <span class="n">k_4</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">+</span><span class="n">k_3</span><span class="o">*</span><span class="n">Dt</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+</span><span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
-    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="mf">1.</span><span class="o">/</span><span class="mi">6</span><span class="o">*</span><span class="p">(</span><span class="n">k_1</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_2</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_3</span><span class="o">+</span><span class="n">k_4</span><span class="p">)</span><span class="o">*</span><span class="n">Dt</span>  <span class="c1"># Approximate solution at next value of x</span>
+    <span class="c1"># Approximate solution at next value of x</span>
+    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="mf">1.</span><span class="o">/</span><span class="mi">6</span><span class="o">*</span><span class="p">(</span><span class="n">k_1</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_2</span><span class="o">+</span><span class="mi">2</span><span class="o">*</span><span class="n">k_3</span><span class="o">+</span><span class="n">k_4</span><span class="p">)</span><span class="o">*</span><span class="n">Dt</span>
  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit 4th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicit &#39;</span> <span class="o">+</span>
+      <span class="s1">&#39;4th-order method (Runge-Kutta) was successful.&#39;</span><span class="p">)</span>
  <span class="k">return</span> <span class="n">x</span></div>

-<div class="viewcode-block" id="dxdt_Dt"><a class="viewcode-back" href="../../numerical.html#numerical.ode.dxdt_Dt">[docs]</a><span class="k">def</span> <span class="nf">dxdt_Dt</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">):</span>
-  <span class="sa">r</span><span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">  :param f: :math:`f = \dot{x}`</span>
-<span class="sd">  :type f: function</span>
-<span class="sd">  :param Dt: :math:`\Delta{t}`</span>
+<div class="viewcode-block" id="fpi"><a class="viewcode-back" href="../../numerical.html#numerical.ode.fpi">[docs]</a><span class="k">def</span> <span class="nf">fpi</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">ti</span><span class="p">,</span> <span class="n">ti1</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span>
+  <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
+  <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Fixed-point iteration.</span>
 <span class="sd">  </span>
-<span class="sd">  :returns: :math:`\Delta x = \dot{x} \Delta t`</span>
-<span class="sd">  &quot;&quot;&quot;</span>
-  <span class="k">return</span> <span class="n">array</span><span class="p">(</span><span class="n">dxdt</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span> <span class="o">*</span> <span class="n">Dt</span></div>
-
-<div class="viewcode-block" id="fixed_point_iteration"><a class="viewcode-back" href="../../numerical.html#numerical.ode.fixed_point_iteration">[docs]</a><span class="k">def</span> <span class="nf">fixed_point_iteration</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
-  <span class="sa">r</span><span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">  :param f: the function to iterate :math:`f = \Delta{x}(t)`</span>
+<span class="sd">  :param f: the function to iterate :math:`f = \dot{x}(x,t)`</span>
 <span class="sd">  :type f: function</span>
 <span class="sd">  :param xi: initial condition :math:`x_i`</span>
 <span class="sd">  :type xi: list</span>
-<span class="sd">  :param t: time :math:`t`</span>
-<span class="sd">  :type t: float</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param ti: time :math:`t_i`</span>
+<span class="sd">  :type ti: float</span>
+<span class="sd">  :param ti1: time :math:`t_{i+1}`</span>
+<span class="sd">  :type ti1: float</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param max_iterations: maximum number of iterations</span>
 <span class="sd">  :type max_iterations: int</span>
-<span class="sd">  :param tol: tolerance against residuum (default = 1e-9)</span>
+<span class="sd">  :param tol: tolerance against residuum :math:`\varepsilon`</span>
+<span class="sd">    (default = 1e-9)</span>
 <span class="sd">  :type tol: float</span>
 <span class="sd">  :param verbose: print information (default = False)</span>
 <span class="sd">  :type verbose: bool</span>
 <span class="sd">  </span>
-<span class="sd">  :returns: :math:`x_{i+1}`</span>
+<span class="sd">  :returns: :math:`x_{i}`</span>
 <span class="sd">  </span>
 <span class="sd">  .. math ::</span>
-<span class="sd">    x_{i+1} = x_i + \Delta x</span>
-
-<span class="sd">  .. seealso::</span>
-<span class="sd">    :meth:`dxdt_Dt` for :math:`\Delta x`</span>
+<span class="sd">    x_{i,j=0} = x_{i}</span>
+<span class="sd">  </span>
+<span class="sd">  .. math ::</span>
+<span class="sd">    x_{i,j+1} = x_i + \dot{x}(x_{i,j}, t_{i+1})\cdot(t_{i+1}-t_i)</span>
+<span class="sd">  </span>
+<span class="sd">  .. math ::</span>
+<span class="sd">    \text{residuum} = \frac{\lVert x_{i,j+1}-x_{i,j}\rVert}</span>
+<span class="sd">      {\lVert x_{i,j+1} \rVert} &lt; \varepsilon</span>
+<span class="sd">  </span>
+<span class="sd">  .. math ::</span>
+<span class="sd">    x_{i} = x_{i,j=\text{end}}</span>
 <span class="sd">  &quot;&quot;&quot;</span>
-  <span class="n">xi</span> <span class="o">=</span> <span class="n">x0</span>
-  <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span>  <span class="c1"># Fixed-point iteration</span>
-    <span class="n">Dx</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
-    <span class="n">xi1</span> <span class="o">=</span> <span class="n">x0</span> <span class="o">+</span> <span class="n">Dx</span>       <span class="c1"># Approximate solution at next value of x</span>
-    <span class="n">residuum</span> <span class="o">=</span> <span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="o">-</span><span class="n">xi</span><span class="p">)</span><span class="o">/</span><span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="p">)</span>
-    <span class="n">xi</span> <span class="o">=</span> <span class="n">xi1</span>
+  <span class="n">xij</span> <span class="o">=</span> <span class="n">xi</span>
+  <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span>
+    <span class="n">dxdt</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">xij</span><span class="p">,</span> <span class="n">ti1</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
+    <span class="c1"># Approximate solution at next value of x</span>
+    <span class="n">xij1</span> <span class="o">=</span> <span class="n">xi</span> <span class="o">+</span> <span class="n">dxdt</span> <span class="o">*</span> <span class="p">(</span><span class="n">ti1</span><span class="o">-</span><span class="n">ti</span><span class="p">)</span>
+    <span class="n">residuum</span> <span class="o">=</span> <span class="n">norm</span><span class="p">(</span><span class="n">xij1</span><span class="o">-</span><span class="n">xij</span><span class="p">)</span><span class="o">/</span><span class="n">norm</span><span class="p">(</span><span class="n">xij1</span><span class="p">)</span>
+    <span class="n">xij</span> <span class="o">=</span> <span class="n">xij1</span>
    <span class="k">if</span> <span class="n">residuum</span> <span class="o">&lt;</span> <span class="n">tol</span><span class="p">:</span>
      <span class="k">break</span>
  <span class="n">iterations</span> <span class="o">=</span> <span class="n">j</span><span class="o">+</span><span class="mi">1</span>  <span class="c1"># number beginning with 1 therefore + 1</span>
-  <span class="k">return</span> <span class="n">xi</span><span class="p">,</span> <span class="n">iterations</span></div>
+  <span class="k">return</span> <span class="n">xij</span><span class="p">,</span> <span class="n">iterations</span></div>

-<div class="viewcode-block" id="i1n"><a class="viewcode-back" href="../../numerical.html#numerical.ode.i1n">[docs]</a><span class="k">def</span> <span class="nf">i1n</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
-  <span class="n">iterations</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="mi">1</span><span class="p">))</span>
-  <span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span>     <span class="c1"># Preallocate array</span>
-  <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span>                      <span class="c1"># Initial condition gives solution at first t</span>
-  <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
-    <span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
-    <span class="n">xi</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span>
-    <span class="n">Dx</span> <span class="o">=</span> <span class="n">dxdt_Dt</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="n">Dt</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
-    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:],</span> <span class="n">iterations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">fixed_point_iteration</span><span class="p">(</span><span class="n">Dx</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="n">max_iterations</span><span class="p">,</span> <span class="n">tol</span><span class="p">,</span> <span class="n">verbose</span><span class="p">)</span>
-  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using implicite first-order method (Euler) was successful.&#39;</span><span class="p">)</span>
-  <span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">iterations</span></div>
-
-<div class="viewcode-block" id="i1"><a class="viewcode-back" href="../../numerical.html#numerical.ode.i1">[docs]</a><span class="k">def</span> <span class="nf">i1</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
+<div class="viewcode-block" id="i1"><a class="viewcode-back" href="../../numerical.html#numerical.ode.i1">[docs]</a><span class="k">def</span> <span class="nf">i1</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span>
+  <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
  <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Implicite first-order method / backward Euler method.</span>

 <span class="sd">  :param f: the function to solve</span>
@@ -286,7 +293,8 @@
 <span class="sd">  :type x0: list</span>
 <span class="sd">  :param t: time</span>
 <span class="sd">  :type t: list</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param max_iterations: maximum number of iterations</span>
 <span class="sd">  :type max_iterations: int</span>
 <span class="sd">  :param tol: tolerance against residuum (default = 1e-9)</span>
@@ -299,25 +307,23 @@
  <span class="n">iterations</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="mi">1</span><span class="p">))</span>
  <span class="n">x</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">((</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">),</span> <span class="nb">len</span><span class="p">(</span><span class="n">x0</span><span class="p">)))</span>     <span class="c1"># Preallocate array</span>
  <span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x0</span>       <span class="c1"># Initial condition gives solution at first t</span>
+  <span class="c1"># x(i+1) = x(i) + f(x(i+1), t(i+1)), exact value of</span>
+  <span class="c1"># f(x(i+1), t(i+1)) is not available therefore using</span>
+  <span class="c1"># Newton-Raphson method</span>
  <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
    <span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
    <span class="n">xi</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span>
-    <span class="c1"># x(i+1) = x(i) + f(x(i+1), t(i+1)), exact value of f(x(i+1), t(i+1)) is not</span>
-    <span class="c1"># available therefor using Newton-Raphson method</span>
-    <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span>  <span class="c1"># Fixed-point iteration</span>
-      <span class="n">dxdt</span> <span class="o">=</span> <span class="n">array</span><span class="p">(</span><span class="n">f</span><span class="p">(</span><span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">))</span>
-      <span class="n">xi1</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span> <span class="o">+</span> <span class="n">dxdt</span><span class="o">*</span><span class="n">Dt</span>       <span class="c1"># Approximate solution at next value of x</span>
-      <span class="n">residuum</span> <span class="o">=</span> <span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="o">-</span><span class="n">xi</span><span class="p">)</span><span class="o">/</span><span class="n">norm</span><span class="p">(</span><span class="n">xi1</span><span class="p">)</span>
-      <span class="n">xi</span> <span class="o">=</span> <span class="n">xi1</span>
-      <span class="k">if</span> <span class="n">residuum</span> <span class="o">&lt;</span> <span class="n">tol</span><span class="p">:</span>
-        <span class="k">break</span>
-    <span class="n">iterations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">j</span><span class="o">+</span><span class="mi">1</span>
+    <span class="n">xi</span><span class="p">,</span> <span class="n">iteration</span> <span class="o">=</span> <span class="n">fpi</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">xi</span><span class="p">,</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">max_iterations</span><span class="p">,</span>
+      <span class="n">tol</span><span class="p">,</span> <span class="n">verbose</span><span class="p">)</span>
    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xi</span>
+    <span class="n">iterations</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">iteration</span>
  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using implicite first-order method (Euler) was successful.&#39;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using implicite &#39;</span> <span class="o">+</span>
+      <span class="s1">&#39;first-order method (Euler) was successful.&#39;</span><span class="p">)</span>
  <span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">iterations</span></div>

-<div class="viewcode-block" id="newmark_newtonraphson"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span> <span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
+<div class="viewcode-block" id="newmark_newtonraphson"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span>
+  <span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
  <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Newmark method.</span>

 <span class="sd">  :param f: the function to solve</span>
@@ -330,7 +336,8 @@
 <span class="sd">  :type xpp0: list</span>
 <span class="sd">  :param t: time</span>
 <span class="sd">  :type t: list</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param gamma: newmark parameter for velocity (default = 0.5)</span>
 <span class="sd">  :type gamma: float</span>
 <span class="sd">  :param beta: newmark parameter for displacement (default = 0.25)</span>
@@ -361,7 +368,8 @@
    <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span>
    <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span>  <span class="c1"># Fixed-point iteration</span>
      <span class="c1">#dxdt = array(f(t[i+1], x1, p))</span>
-      <span class="c1">#x11 = x[i,:] + dxdt*Dt  # Approximate solution at next value of x</span>
+      <span class="c1"># Approximate solution at next value of x</span>
+      <span class="c1">#x11 = x[i,:] + dxdt*Dt</span>

      <span class="n">N</span><span class="p">,</span> <span class="n">dN</span><span class="p">,</span> <span class="n">dNp</span><span class="p">,</span> <span class="n">dNpp</span> <span class="o">=</span> <span class="n">f</span><span class="p">(</span><span class="n">x1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">(),</span>
        <span class="n">xp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">(),</span> <span class="n">xpp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">(),</span>
@@ -370,7 +378,8 @@
        <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;divergiert&#39;</span><span class="p">)</span>
        <span class="k">break</span>

-      <span class="n">xpp11</span> <span class="o">=</span> <span class="n">xpp1</span> <span class="o">-</span> <span class="n">dot</span><span class="p">(</span><span class="n">inv</span><span class="p">(</span><span class="n">dNpp</span><span class="p">),</span> <span class="p">(</span><span class="n">N</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">dN</span><span class="p">,</span> <span class="p">(</span><span class="n">x1</span><span class="o">-</span><span class="n">xi</span><span class="p">))</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">dNp</span><span class="p">,</span> <span class="p">(</span><span class="n">xp1</span><span class="o">-</span><span class="n">xpi</span><span class="p">))))</span>
+      <span class="n">xpp11</span> <span class="o">=</span> <span class="n">xpp1</span> <span class="o">-</span> <span class="n">dot</span><span class="p">(</span><span class="n">inv</span><span class="p">(</span><span class="n">dNpp</span><span class="p">),</span> <span class="p">(</span><span class="n">N</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">dN</span><span class="p">,</span> <span class="p">(</span><span class="n">x1</span><span class="o">-</span><span class="n">xi</span><span class="p">))</span> <span class="o">+</span> \
+                                          <span class="n">dot</span><span class="p">(</span><span class="n">dNp</span><span class="p">,</span> <span class="p">(</span><span class="n">xp1</span><span class="o">-</span><span class="n">xpi</span><span class="p">))))</span>
      <span class="n">xp1</span> <span class="o">=</span> <span class="n">xpi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">*</span><span class="p">(</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">gamma</span><span class="p">)</span><span class="o">*</span><span class="n">xppi</span> <span class="o">+</span> <span class="n">gamma</span><span class="o">*</span><span class="n">xpp11</span> <span class="p">)</span>
      <span class="n">x1</span> <span class="o">=</span> <span class="n">xi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">**</span><span class="mi">2</span><span class="o">*</span><span class="p">(</span> <span class="p">(</span><span class="o">.</span><span class="mi">5</span><span class="o">-</span><span class="n">beta</span><span class="p">)</span><span class="o">*</span><span class="n">xppi</span> <span class="o">+</span> <span class="n">beta</span><span class="o">*</span><span class="n">xpp11</span> <span class="p">)</span>
            
@@ -384,11 +393,13 @@
    <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite newmark method was successful.&#39;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite &#39;</span> <span class="o">+</span>
+      <span class="s1">&#39;newmark method was successful.&#39;</span><span class="p">)</span>
  <span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">xp</span><span class="p">,</span> <span class="n">xpp</span><span class="p">,</span> <span class="n">iterations</span></div>
  <span class="c1"># x = concatenate((x, xp, xpp), axis=1)</span>

-<div class="viewcode-block" id="newmark_newtonraphson_rdk"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson_rdk">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson_rdk</span><span class="p">(</span><span class="n">fnm</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span> <span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">maxIterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
+<div class="viewcode-block" id="newmark_newtonraphson_rdk"><a class="viewcode-back" href="../../numerical.html#numerical.ode.newmark_newtonraphson_rdk">[docs]</a><span class="k">def</span> <span class="nf">newmark_newtonraphson_rdk</span><span class="p">(</span><span class="n">fnm</span><span class="p">,</span> <span class="n">x0</span><span class="p">,</span> <span class="n">xp0</span><span class="p">,</span> <span class="n">xpp0</span><span class="p">,</span> <span class="n">t</span><span class="p">,</span> <span class="o">*</span><span class="n">p</span><span class="p">,</span> <span class="n">gamma</span><span class="o">=.</span><span class="mi">5</span><span class="p">,</span>
+  <span class="n">beta</span><span class="o">=.</span><span class="mi">25</span><span class="p">,</span> <span class="n">max_iterations</span><span class="o">=</span><span class="mi">1000</span><span class="p">,</span> <span class="n">tol</span><span class="o">=</span><span class="mf">1e-9</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
  <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Newmark method.</span>

 <span class="sd">  :param f: the function to solve</span>
@@ -401,7 +412,8 @@
 <span class="sd">  :type xpp0: list</span>
 <span class="sd">  :param t: time</span>
 <span class="sd">  :type t: list</span>
-<span class="sd">  :param `*p`: parameters of the function (thickness, diameter, ...)</span>
+<span class="sd">  :param `*p`: parameters of the function (thickness, diameter,</span>
+<span class="sd">    ...)</span>
 <span class="sd">  :param gamma: newmark parameter for velocity (default = 0.5)</span>
 <span class="sd">  :type gamma: float</span>
 <span class="sd">  :param beta: newmark parameter for displacement (default = 0.25)</span>
@@ -423,7 +435,8 @@
  <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">t</span><span class="p">)</span><span class="o">-</span><span class="mi">1</span><span class="p">):</span>
    <span class="n">Dt</span> <span class="o">=</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">]</span><span class="o">-</span><span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>

-    <span class="n">rm</span><span class="p">,</span> <span class="n">rmx</span><span class="p">,</span> <span class="n">rmxpp</span><span class="p">,</span> <span class="n">rd</span><span class="p">,</span> <span class="n">rdx</span><span class="p">,</span> <span class="n">rdxp</span><span class="p">,</span> <span class="n">rk</span><span class="p">,</span> <span class="n">rkx</span><span class="p">,</span> <span class="n">f</span> <span class="o">=</span> <span class="n">fnm</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">xpp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
+    <span class="n">rm</span><span class="p">,</span> <span class="n">rmx</span><span class="p">,</span> <span class="n">rmxpp</span><span class="p">,</span> <span class="n">rd</span><span class="p">,</span> <span class="n">rdx</span><span class="p">,</span> <span class="n">rdxp</span><span class="p">,</span> <span class="n">rk</span><span class="p">,</span> <span class="n">rkx</span><span class="p">,</span> <span class="n">f</span> <span class="o">=</span> <span class="n">fnm</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span>
+      <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">xpp</span><span class="p">[</span><span class="n">i</span><span class="p">,:],</span> <span class="n">t</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="o">*</span><span class="n">p</span><span class="p">)</span>
        
    <span class="n">xi</span> <span class="o">=</span> <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
    <span class="n">xpi</span> <span class="o">=</span> <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="p">,:]</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span>
@@ -432,13 +445,16 @@
    <span class="n">xp1</span> <span class="o">=</span> <span class="n">xpi</span>
    <span class="n">xpp1</span> <span class="o">=</span> <span class="n">xppi</span>
    <span class="n">j</span> <span class="o">=</span> <span class="mi">0</span>
-    <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">maxIterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
+    <span class="k">for</span> <span class="n">j</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">max_iterations</span><span class="p">):</span> <span class="c1"># Fixed-point iteration</span>
      <span class="c1">#dxdt = array(f(t[i+1], x1, p))</span>
-      <span class="c1">#x11 = x[i,:] + dxdt*Dt  # Approximate solution at next value of x</span>
+      <span class="c1"># Approximate solution at next value of x</span>
+      <span class="c1">#x11 = x[i,:] + dxdt*Dt</span>

      <span class="n">r</span> <span class="o">=</span> <span class="p">(</span><span class="n">rmx</span><span class="o">+</span><span class="n">rdx</span><span class="o">+</span><span class="n">rkx</span><span class="p">)</span><span class="o">*</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span> <span class="o">+</span> <span class="n">rdxp</span><span class="o">*</span><span class="n">Dt</span><span class="o">/</span><span class="mi">2</span> <span class="o">+</span> <span class="n">rmxpp</span> 
-      <span class="n">rp</span> <span class="o">=</span> <span class="n">f</span> <span class="o">-</span> <span class="p">(</span><span class="n">rm</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rmx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">-</span> <span class="n">dot</span><span class="p">(</span><span class="n">rmxpp</span><span class="p">,</span> <span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
-                <span class="n">rd</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rdx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rdxp</span><span class="p">,</span> <span class="n">Dt</span><span class="o">/</span><span class="mi">2</span><span class="o">*</span><span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
+      <span class="n">rp</span> <span class="o">=</span> <span class="n">f</span> <span class="o">-</span> <span class="p">(</span><span class="n">rm</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rmx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">-</span> \
+                     <span class="n">dot</span><span class="p">(</span><span class="n">rmxpp</span><span class="p">,</span> <span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
+                <span class="n">rd</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rdx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="o">+</span> \
+                     <span class="n">dot</span><span class="p">(</span><span class="n">rdxp</span><span class="p">,</span> <span class="n">Dt</span><span class="o">/</span><span class="mi">2</span><span class="o">*</span><span class="n">xppi</span><span class="p">)</span> <span class="o">+</span> \
                <span class="n">rk</span> <span class="o">+</span> <span class="n">dot</span><span class="p">(</span><span class="n">rkx</span><span class="p">,</span> <span class="p">(</span><span class="n">Dt</span><span class="o">*</span><span class="n">xpi</span><span class="o">+</span><span class="n">Dt</span><span class="o">**</span><span class="mf">2.</span><span class="o">/</span><span class="mi">4</span><span class="o">*</span><span class="n">xppi</span><span class="p">))</span> <span class="p">)</span>
      <span class="n">xpp11</span> <span class="o">=</span> <span class="n">dot</span><span class="p">(</span><span class="n">inv</span><span class="p">(</span><span class="n">r</span><span class="p">),</span> <span class="n">rp</span><span class="p">)</span>
      <span class="n">xp1</span> <span class="o">=</span> <span class="n">xpi</span> <span class="o">+</span> <span class="n">Dt</span><span class="o">*</span><span class="p">(</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">gamma</span><span class="p">)</span><span class="o">*</span><span class="n">xppi</span> <span class="o">+</span> <span class="n">gamma</span><span class="o">*</span><span class="n">xpp11</span> <span class="p">)</span>
@@ -454,7 +470,8 @@
    <span class="n">xp</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">xp1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
    <span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="o">+</span><span class="mi">1</span><span class="p">,:]</span> <span class="o">=</span> <span class="n">x1</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,)</span><span class="o">.</span><span class="n">tolist</span><span class="p">()</span>
  <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>
-    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite newmark method was successful.&#39;</span><span class="p">)</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Numerical integration of ODE using explicite &#39;</span> <span class="o">+</span>
+      <span class="s1">&#39;newmark method was successful.&#39;</span><span class="p">)</span>
  <span class="k">return</span> <span class="n">x</span><span class="p">,</span> <span class="n">xp</span><span class="p">,</span> <span class="n">xpp</span><span class="p">,</span> <span class="n">iterations</span></div>
  <span class="c1"># x = concatenate((x, xp, xpp), axis=1)</span>
 </pre></div>
--- a/docs/build/html/_modules/time_of_day.html
+++ b/docs/build/html/_modules/time_of_day.html
@@ -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>
--- a/docs/build/html/_sources/modules.rst.txt
+++ b/docs/build/html/_sources/modules.rst.txt
@@ -8,3 +8,4 @@ src
   date
   geometry
   numerical
+   time_of_day
--- a/docs/build/html/_sources/time_of_day.rst.txt
+++ b/docs/build/html/_sources/time_of_day.rst.txt
@@ -0,0 +1,7 @@
+time\_of\_day module
+====================
+
+.. automodule:: time_of_day
+    :members:
+    :undoc-members:
+    :show-inheritance:
--- a/docs/build/html/genindex.html
+++ b/docs/build/html/genindex.html
@@ -43,6 +43,7 @@
 | <a href="#E"><strong>E</strong></a>
 | <a href="#F"><strong>F</strong></a>
 | <a href="#G"><strong>G</strong></a>
+ | <a href="#H"><strong>H</strong></a>
 | <a href="#I"><strong>I</strong></a>
 | <a href="#L"><strong>L</strong></a>
 | <a href="#M"><strong>M</strong></a>
@@ -84,18 +85,20 @@
      <li><a href="data.html#data.data_read">data_read() (in module data)</a>
 </li>
      <li><a href="data.html#data.data_store">data_store() (in module data)</a>
+</li>
+      <li><a href="date.html#module-date">date (module)</a>, <a href="date.html#module-date">[1]</a>
 </li>
  </ul></td>
  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="date.html#module-date">date (module)</a>, <a href="date.html#module-date">[1]</a>
+      <li><a href="time_of_day.html#time_of_day.days">days() (in module time_of_day)</a>
+</li>
+      <li><a href="time_of_day.html#time_of_day.days_norm">days_norm() (in module time_of_day)</a>
 </li>
      <li><a href="numerical.html#numerical.ode_model.disk">disk() (in module numerical.ode_model)</a>
 </li>
      <li><a href="numerical.html#numerical.ode_model.disk_nm">disk_nm() (in module numerical.ode_model)</a>
 </li>
      <li><a href="numerical.html#numerical.ode_model.disk_nmmdk">disk_nmmdk() (in module numerical.ode_model)</a>
-</li>
-      <li><a href="numerical.html#numerical.ode.dxdt_Dt">dxdt_Dt() (in module numerical.ode)</a>
 </li>
  </ul></td>
 </tr></table>
@@ -127,7 +130,7 @@
 </li>
  </ul></td>
  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="numerical.html#numerical.ode.fixed_point_iteration">fixed_point_iteration() (in module numerical.ode)</a>
+      <li><a href="numerical.html#numerical.ode.fpi">fpi() (in module numerical.ode)</a>
 </li>
  </ul></td>
 </tr></table>
@@ -148,6 +151,18 @@
  </ul></td>
 </tr></table>

+<h2 id="H">H</h2>
+<table style="width: 100%" class="indextable genindextable"><tr>
+  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="time_of_day.html#time_of_day.hours">hours() (in module time_of_day)</a>
+</li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="time_of_day.html#time_of_day.hours_norm">hours_norm() (in module time_of_day)</a>
+</li>
+  </ul></td>
+</tr></table>
+
 <h2 id="I">I</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
  <td style="width: 33%; vertical-align: top;"><ul>
@@ -155,7 +170,7 @@
 </li>
  </ul></td>
  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="numerical.html#numerical.ode.i1n">i1n() (in module numerical.ode)</a>
+      <li><a href="time_of_day.html#time_of_day.in_seconds">in_seconds() (in module time_of_day)</a>
 </li>
      <li><a href="numerical.html#module-integration">integration (module)</a>
 </li>
@@ -174,6 +189,12 @@
 <table style="width: 100%" class="indextable genindextable"><tr>
  <td style="width: 33%; vertical-align: top;"><ul>
      <li><a href="data.html#data.main">main() (in module data)</a>
+</li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="time_of_day.html#time_of_day.minutes">minutes() (in module time_of_day)</a>
+</li>
+      <li><a href="time_of_day.html#time_of_day.minutes_norm">minutes_norm() (in module time_of_day)</a>
 </li>
  </ul></td>
 </tr></table>
@@ -241,6 +262,12 @@
 <h2 id="S">S</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="time_of_day.html#time_of_day.seconds">seconds() (in module time_of_day)</a>
+</li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="time_of_day.html#time_of_day.seconds_norm">seconds_norm() (in module time_of_day)</a>
+</li>
      <li><a href="geometry.html#geometry.square">square() (in module geometry)</a>
 </li>
  </ul></td>
@@ -249,10 +276,14 @@
 <h2 id="T">T</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
  <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="geometry.html#geometry.translate">translate() (in module geometry)</a>
+      <li><a href="time_of_day.html#module-time_of_day">time_of_day (module)</a>, <a href="time_of_day.html#module-time_of_day">[1]</a>
+</li>
+      <li><a href="time_of_day.html#time_of_day.transform">transform() (in module time_of_day)</a>
 </li>
  </ul></td>
  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="geometry.html#geometry.translate">translate() (in module geometry)</a>
+</li>
      <li><a href="numerical.html#numerical.integration.trapez">trapez() (in module numerical.integration)</a>
 </li>
  </ul></td>
--- a/docs/build/html/modules.html
+++ b/docs/build/html/modules.html
@@ -48,6 +48,7 @@
 <li class="toctree-l2"><a class="reference internal" href="numerical.html#module-numerical">Module contents</a></li>
 </ul>
 </li>
+<li class="toctree-l1"><a class="reference internal" href="time_of_day.html">time_of_day module</a></li>
 </ul>
 </div>
 </div>
--- a/docs/build/html/numerical.html
+++ b/docs/build/html/numerical.html
@@ -197,30 +197,14 @@ b &amp;= 1\end{split}\]</div>
 <div class="section" id="module-numerical.ode">
 <span id="numerical-ode-module"></span><h2>numerical.ode module<a class="headerlink" href="#module-numerical.ode" title="Permalink to this headline">¶</a></h2>
 <p>Numerical solver of ordinary differential equations.</p>
-<p>Solves the initial value problem for systems of first order ordinary differential
-equations.</p>
+<p>Solves the initial value problem for systems of first order
+ordinary differential equations.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Date</dt>
 <dd class="field-odd"><p>2015-09-21</p>
 </dd>
 </dl>
 <span class="target" id="module-ode"></span><dl class="function">
-<dt id="numerical.ode.dxdt_Dt">
-<code class="descname">dxdt_Dt</code><span class="sig-paren">(</span><em>f</em>, <em>x</em>, <em>t</em>, <em>Dt</em>, <em>*p</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#dxdt_Dt"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.dxdt_Dt" title="Permalink to this definition">¶</a></dt>
-<dd><dl class="field-list simple">
-<dt class="field-odd">Parameters</dt>
-<dd class="field-odd"><ul class="simple">
-<li><p><strong>f</strong> (<em>function</em>) – <span class="math notranslate nohighlight">\(f = \dot{x}\)</span></p></li>
-<li><p><strong>Dt</strong> – <span class="math notranslate nohighlight">\(\Delta{t}\)</span></p></li>
-</ul>
-</dd>
-<dt class="field-even">Returns</dt>
-<dd class="field-even"><p><span class="math notranslate nohighlight">\(\Delta x = \dot{x} \Delta t\)</span></p>
-</dd>
-</dl>
-</dd></dl>
-
-<dl class="function">
 <dt id="numerical.ode.e1">
 <code class="descname">e1</code><span class="sig-paren">(</span><em>f</em>, <em>x0</em>, <em>t</em>, <em>*p</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#e1"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.e1" title="Permalink to this definition">¶</a></dt>
 <dd><p>Explicit first-order method /
@@ -235,7 +219,8 @@ Euler-Cauchy-Verfahren / Euler-vorwärts-Verfahren</p>
 <li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
 <li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>t</strong> (<em>list</em>) – time</p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
 </ul>
 </dd>
@@ -247,12 +232,12 @@ x(t_0) &amp;= x_0\end{split}\]</div>
 <p>Choose a value h for the size of every step and set</p>
 <div class="math notranslate nohighlight">
 \[t_i = t_0 + i h ~,\quad i=1,2,\ldots,n\]</div>
-<p>The derivative of the solution is approximated as the forward difference
-equation</p>
+<p>The derivative of the solution is approximated as the forward
+difference equation</p>
 <div class="math notranslate nohighlight">
 \[\dot{x}_i = f(t_i, x_i) = \frac{x_{i+1} - x_i}{t_{i+1}-t_i}\]</div>
-<p>Therefore one step <span class="math notranslate nohighlight">\(h\)</span> of the Euler method from <span class="math notranslate nohighlight">\(t_i\)</span> to
-<span class="math notranslate nohighlight">\(t_{i+1}\)</span> is</p>
+<p>Therefore one step <span class="math notranslate nohighlight">\(h\)</span> of the Euler method from
+<span class="math notranslate nohighlight">\(t_i\)</span> to <span class="math notranslate nohighlight">\(t_{i+1}\)</span> is</p>
 <div class="math notranslate nohighlight">
 \[\begin{split}x_{i+1} &amp;= x_i + (t_{i+1}-t_i) f(t_i, x_i) \\
 x_{i+1} &amp;= x_i + h f(t_i, x_i) \\\end{split}\]</div>
@@ -272,7 +257,8 @@ x_2 &amp;= \dot{u}  &amp;\quad \dot{x}_2 = \ddot{u} \\\end{split}\]</div>
 <div class="math notranslate nohighlight">
 \[\begin{split}\dot{x} &amp;= f(t,x) \\
 \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=
-\begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1) \end{bmatrix}  \\
+\begin{bmatrix} x_2 \\ m^{-1}(f(t) - d x_2 - k x_1)
+\end{bmatrix} \\
 &amp;=
 \begin{bmatrix} 0 \\ m^{-1} f(t) \end{bmatrix} +
 \begin{bmatrix} 0 &amp; 1 \\ -m^{-1} k &amp; -m^{-1} d \end{bmatrix}
@@ -288,19 +274,24 @@ x_2 &amp;= \dot{u}  &amp;\quad \dot{x}_2 = \ddot{u} \\\end{split}\]</div>
 <p>becomes</p>
 <div class="math notranslate nohighlight">
 \[\begin{split}\dot{x}_1 &amp;= x_2 \\
-\dot{x}_2 &amp;= m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\\end{split}\]</div>
+\dot{x}_2 &amp;=
+  m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \\\end{split}\]</div>
 <p>or</p>
 <div class="math notranslate nohighlight">
 \[\begin{split}\dot{x} &amp;= f(t,x) \\
 \begin{bmatrix} \dot{x}_1 \\ \dot{x}_2 \end{bmatrix} &amp;=
-\begin{bmatrix} x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1) \end{bmatrix}  \\
+\begin{bmatrix}
+  x_2 \\ m^{-1}(x_1)(f(t) - d(x_1,x_2) x_2 - k(x_1) x_1)
+  \end{bmatrix} \\
 &amp;=
 \begin{bmatrix} 0 \\ m^{-1}(x_1) f(t) \end{bmatrix} +
-\begin{bmatrix} 0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2) \end{bmatrix}
+\begin{bmatrix}
+  0 &amp; 1 \\ -m^{-1}(x_1) k(x_1) &amp; -m^{-1} d(x_1,x_2)
+  \end{bmatrix}
 \begin{bmatrix} x_1 \\ x_2 \end{bmatrix}\end{split}\]</div>
-<p>The Euler method is a first-order method,
-which means that the local error (error per step) is proportional to the
-square of the step size, and the global error (error at a given time) is
+<p>The Euler method is a first-order method, which means that the
+local error (error per step) is proportional to the square of
+the step size, and the global error (error at a given time) is
 proportional to the step size.</p>
 </dd></dl>

@@ -314,7 +305,8 @@ proportional to the step size.</p>
 <li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
 <li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>t</strong> (<em>list</em>) – time</p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
 </ul>
 </dd>
@@ -331,7 +323,8 @@ proportional to the step size.</p>
 <li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
 <li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>t</strong> (<em>list</em>) – time</p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
 </ul>
 </dd>
@@ -339,30 +332,37 @@ proportional to the step size.</p>
 </dd></dl>

 <dl class="function">
-<dt id="numerical.ode.fixed_point_iteration">
-<code class="descname">fixed_point_iteration</code><span class="sig-paren">(</span><em>f</em>, <em>xi</em>, <em>t</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#fixed_point_iteration"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.fixed_point_iteration" title="Permalink to this definition">¶</a></dt>
-<dd><dl class="field-list simple">
+<dt id="numerical.ode.fpi">
+<code class="descname">fpi</code><span class="sig-paren">(</span><em>f</em>, <em>xi</em>, <em>ti</em>, <em>ti1</em>, <em>*p</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#fpi"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.fpi" title="Permalink to this definition">¶</a></dt>
+<dd><p>Fixed-point iteration.</p>
+<dl class="field-list simple">
 <dt class="field-odd">Parameters</dt>
 <dd class="field-odd"><ul class="simple">
-<li><p><strong>f</strong> (<em>function</em>) – the function to iterate <span class="math notranslate nohighlight">\(f = \Delta{x}(t)\)</span></p></li>
+<li><p><strong>f</strong> (<em>function</em>) – the function to iterate <span class="math notranslate nohighlight">\(f = \dot{x}(x,t)\)</span></p></li>
 <li><p><strong>xi</strong> (<em>list</em>) – initial condition <span class="math notranslate nohighlight">\(x_i\)</span></p></li>
-<li><p><strong>t</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t\)</span></p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>ti</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t_i\)</span></p></li>
+<li><p><strong>ti1</strong> (<em>float</em>) – time <span class="math notranslate nohighlight">\(t_{i+1}\)</span></p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
-<li><p><strong>tol</strong> (<em>float</em>) – tolerance against residuum (default = 1e-9)</p></li>
+<li><p><strong>tol</strong> (<em>float</em>) – tolerance against residuum <span class="math notranslate nohighlight">\(\varepsilon\)</span>
+(default = 1e-9)</p></li>
 <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
 </ul>
 </dd>
 <dt class="field-even">Returns</dt>
-<dd class="field-even"><p><span class="math notranslate nohighlight">\(x_{i+1}\)</span></p>
+<dd class="field-even"><p><span class="math notranslate nohighlight">\(x_{i}\)</span></p>
 </dd>
 </dl>
 <div class="math notranslate nohighlight">
-\[x_{i+1} = x_i + \Delta x\]</div>
-<div class="admonition seealso">
-<p class="admonition-title">See also</p>
-<p><a class="reference internal" href="#numerical.ode.dxdt_Dt" title="numerical.ode.dxdt_Dt"><code class="xref py py-meth docutils literal notranslate"><span class="pre">dxdt_Dt()</span></code></a> for <span class="math notranslate nohighlight">\(\Delta x\)</span></p>
-</div>
+\[x_{i,j=0} = x_{i}\]</div>
+<div class="math notranslate nohighlight">
+\[x_{i,j+1} = x_i + \dot{x}(x_{i,j}, t_{i+1})\cdot(t_{i+1}-t_i)\]</div>
+<div class="math notranslate nohighlight">
+\[\text{residuum} = \frac{\lVert x_{i,j+1}-x_{i,j}\rVert}
+  {\lVert x_{i,j+1} \rVert} &lt; \varepsilon\]</div>
+<div class="math notranslate nohighlight">
+\[x_{i} = x_{i,j=\text{end}}\]</div>
 </dd></dl>

 <dl class="function">
@@ -375,7 +375,8 @@ proportional to the step size.</p>
 <li><p><strong>f</strong> (<em>function</em>) – the function to solve</p></li>
 <li><p><strong>x0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>t</strong> (<em>list</em>) – time</p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
 <li><p><strong>tol</strong> (<em>float</em>) – tolerance against residuum (default = 1e-9)</p></li>
 <li><p><strong>verbose</strong> (<em>bool</em>) – print information (default = False)</p></li>
@@ -385,11 +386,6 @@ proportional to the step size.</p>
 <p>The backward Euler method has order one and is A-stable.</p>
 </dd></dl>

-<dl class="function">
-<dt id="numerical.ode.i1n">
-<code class="descname">i1n</code><span class="sig-paren">(</span><em>f</em>, <em>x0</em>, <em>t</em>, <em>*p</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#i1n"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.i1n" title="Permalink to this definition">¶</a></dt>
-<dd></dd></dl>
-
 <dl class="function">
 <dt id="numerical.ode.newmark_newtonraphson">
 <code class="descname">newmark_newtonraphson</code><span class="sig-paren">(</span><em>f</em>, <em>x0</em>, <em>xp0</em>, <em>xpp0</em>, <em>t</em>, <em>*p</em>, <em>gamma=0.5</em>, <em>beta=0.25</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#newmark_newtonraphson"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.newmark_newtonraphson" title="Permalink to this definition">¶</a></dt>
@@ -402,7 +398,8 @@ proportional to the step size.</p>
 <li><p><strong>xp0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>xpp0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>t</strong> (<em>list</em>) – time</p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>gamma</strong> (<em>float</em>) – newmark parameter for velocity (default = 0.5)</p></li>
 <li><p><strong>beta</strong> (<em>float</em>) – newmark parameter for displacement (default = 0.25)</p></li>
 <li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
@@ -415,7 +412,7 @@ proportional to the step size.</p>

 <dl class="function">
 <dt id="numerical.ode.newmark_newtonraphson_rdk">
-<code class="descname">newmark_newtonraphson_rdk</code><span class="sig-paren">(</span><em>fnm</em>, <em>x0</em>, <em>xp0</em>, <em>xpp0</em>, <em>t</em>, <em>*p</em>, <em>gamma=0.5</em>, <em>beta=0.25</em>, <em>maxIterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#newmark_newtonraphson_rdk"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.newmark_newtonraphson_rdk" title="Permalink to this definition">¶</a></dt>
+<code class="descname">newmark_newtonraphson_rdk</code><span class="sig-paren">(</span><em>fnm</em>, <em>x0</em>, <em>xp0</em>, <em>xpp0</em>, <em>t</em>, <em>*p</em>, <em>gamma=0.5</em>, <em>beta=0.25</em>, <em>max_iterations=1000</em>, <em>tol=1e-09</em>, <em>verbose=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/numerical/ode.html#newmark_newtonraphson_rdk"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#numerical.ode.newmark_newtonraphson_rdk" title="Permalink to this definition">¶</a></dt>
 <dd><p>Newmark method.</p>
 <dl class="field-list simple">
 <dt class="field-odd">Parameters</dt>
@@ -425,7 +422,8 @@ proportional to the step size.</p>
 <li><p><strong>xp0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>xpp0</strong> (<em>list</em>) – initial condition</p></li>
 <li><p><strong>t</strong> (<em>list</em>) – time</p></li>
-<li><p><strong>*p</strong> – parameters of the function (thickness, diameter, …)</p></li>
+<li><p><strong>*p</strong> – parameters of the function (thickness, diameter,
+…)</p></li>
 <li><p><strong>gamma</strong> (<em>float</em>) – newmark parameter for velocity (default = 0.5)</p></li>
 <li><p><strong>beta</strong> (<em>float</em>) – newmark parameter for displacement (default = 0.25)</p></li>
 <li><p><strong>max_iterations</strong> (<em>int</em>) – maximum number of iterations</p></li>
--- a/docs/build/html/objects.inv
+++ b/docs/build/html/objects.inv
@@ -2,6 +2,6 @@
 # Project: pylib
 # Version: 
 # The remainder of this file is compressed using zlib.
-xڭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>0<14><><<3C>h<>!<0C><>4<14>0CA<43>Q<EFBFBD>cGD<17>#	<15>A<EFBFBD><41><EFBFBD>&<	<09><>d<EFBFBD>d<EFBFBD>H<EFBFBD>4<EFBFBD>}<7D><><EFBFBD>f<EFBFBD><04><>L<EFBFBD>;mŬ<EFBFBD><EFBFBD>&"<18><><EFBFBD><EFBFBD>e2u<EFBFBD>H<EFBFBD>Z<EFBFBD><EFBFBD><EFBFBD>*<2A>D<EFBFBD><44><EFBFBD>p/<2F>!<21>LQ<4C><0E>Q<EFBFBD><51><EFBFBD>mV3inQpY
-<T
-<EFBFBD>9N<><1D><17><19>=C<><43><07><1D><14>P<EFBFBD>kkZp<5A><70><EFBFBD><EFBFBD>Ϳ!<21><02>Q7X<37>AݖM`<<3C> <20>':H_<48><5F><EFBFBD><1A><>L]5s<04><><EFBFBD>C<EFBFBD><43><EFBFBD><EFBFBD><EFBFBD>=<3D>7<EFBFBD>_<EFBFBD>P<EFBFBD><50>q*`<60><>(i<><69><EFBFBD><EFBFBD>4<1E>y<07>33<33><33><10><><EFBFBD><EFBFBD>l<EFBFBD>ۊƯ3s
+xڭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD> <10><><EFBFBD>Xz<58><7A>ky<6B>7<EFBFBD>`<60>U{<7B>H1<48>Ip<49><70>@J<><4A><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>&><3E>$dfIfv<07>^f<><66><EFBFBD><EFBFBD><EFBFBD><06><08><19><>{mD<6D><EFBFBD><EFBFBD>%"<18><>k<EFBFBD>:<3A><>o<EFBFBD>~7<19><1F><13><><EFBFBD><EFBFBD>{i<><69>%<25>Rj![꼱p[<5B><><EFBFBD>[*X<><06><>*<2A>8<EFBFBD>N<><4E><EFBFBD>p<><70><EFBFBD>K<>0<><30><EFBFBD><EFBFBD>J<EFBFBD><4A>l<EFBFBD>6X"w}<7D><>a<EFBFBD><61>ߎ<EFBFBD>@<40><><EFBFBD><EFBFBD>jP<6A><50><0E>ȳ<>Z<EFBFBD>E<1D><>`%gꢘ
+
+<EFBFBD><0B><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>A<EFBFBD>U
--- a/docs/build/html/py-modindex.html
+++ b/docs/build/html/py-modindex.html
@@ -48,7 +48,8 @@
   <a href="#cap-g"><strong>g</strong></a> | 
   <a href="#cap-i"><strong>i</strong></a> | 
   <a href="#cap-n"><strong>n</strong></a> | 
-   <a href="#cap-o"><strong>o</strong></a>
+   <a href="#cap-o"><strong>o</strong></a> | 
+   <a href="#cap-t"><strong>t</strong></a>
   </div>

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


--- a/docs/build/html/searchindex.js
+++ b/docs/build/html/searchindex.js
--- a/docs/build/html/time_of_day.html
+++ b/docs/build/html/time_of_day.html
@@ -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>
--- a/docs/source/modules.rst
+++ b/docs/source/modules.rst
@@ -8,3 +8,4 @@ src
   date
   geometry
   numerical
+   time_of_day
--- a/docs/source/time_of_day.rst
+++ b/docs/source/time_of_day.rst
@@ -0,0 +1,7 @@
+time\_of\_day module
+====================
+
+.. automodule:: time_of_day
+    :members:
+    :undoc-members:
+    :show-inheritance:
--- a/src/numerical/ode.py
+++ b/src/numerical/ode.py
@@ -2,8 +2,8 @@
 # -*- coding: utf-8 -*-
 """Numerical solver of ordinary differential equations.

-Solves the initial value problem for systems of first order ordinary differential
-equations.
+Solves the initial value problem for systems of first order
+ordinary differential equations.

 :Date: 2015-09-21

@@ -33,7 +33,8 @@ def e1(f, x0, t, *p, verbose=False):
  :type x0: list
  :param t: time
  :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)
  :type verbose: bool

@@ -48,14 +49,14 @@ def e1(f, x0, t, *p, verbose=False):
  .. math ::
    t_i = t_0 + i h ~,\quad i=1,2,\ldots,n

-  The derivative of the solution is approximated as the forward difference
-  equation
+  The derivative of the solution is approximated as the forward
+  difference equation
  
  .. math ::
    \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
-  :math:`t_{i+1}` is
+  Therefore one step :math:`h` of the Euler method from
+  :math:`t_i` to :math:`t_{i+1}` is

  .. math ::
    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 ::
    \dot{x} &= f(t,x) \\
    \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 & 1 \\ -m^{-1} k & -m^{-1} d \end{bmatrix}
@@ -106,22 +108,27 @@ def e1(f, x0, t, *p, verbose=False):

  .. math ::
    \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

  .. math ::
    \dot{x} &= f(t,x) \\
    \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 & 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}

-  The Euler method is a first-order method,
-  which means that the local error (error per step) is proportional to the
-  square of the step size, and the global error (error at a given time) is
+  The Euler method is a first-order method, which means that the
+  local error (error per step) is proportional to the square of
+  the step size, and the global error (error at a given time) is
  proportional to the step size.
  """
  x = zeros((len(t), len(x0)))  # Preallocate array
@@ -129,9 +136,11 @@ def e1(f, x0, t, *p, verbose=False):
  for i in range(len(t)-1):     # Calculation loop
    Dt = t[i+1]-t[i]
    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:
-    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

 def e2(f, x0, t, *p, verbose=False):
@@ -143,7 +152,8 @@ def e2(f, x0, t, *p, verbose=False):
  :type x0: list
  :param t: time
  :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)
  :type verbose: bool
  """
@@ -153,9 +163,11 @@ def e2(f, x0, t, *p, verbose=False):
    Dt = t[i+1]-t[i]
    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))
-    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:
-    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

 def e4(f, x0, t, *p, verbose=False):
@@ -167,7 +179,8 @@ def e4(f, x0, t, *p, verbose=False):
  :type x0: list
  :param t: time
  :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)
  :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_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))
-    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:
-    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

-def dxdt_Dt(f, x, t, Dt, *p):
-  r"""
-  :param f: :math:`f = \dot{x}`
-  :type f: function
-  :param Dt: :math:`\Delta{t}`
+def fpi(f, xi, ti, ti1, *p, max_iterations=1000, tol=1e-9,
+  verbose=False):
+  r"""Fixed-point iteration.
  
-  :returns: :math:`\Delta x = \dot{x} \Delta 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)`
+  :param f: the function to iterate :math:`f = \dot{x}(x,t)`
  :type f: function
  :param xi: initial condition :math:`x_i`
  :type xi: list
-  :param t: time :math:`t`
-  :type t: float
-  :param `*p`: parameters of the function (thickness, diameter, ...)
+  :param ti: time :math:`t_i`
+  :type ti: float
+  :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
  :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
  :param verbose: print information (default = False)
  :type verbose: bool
  
-  :returns: :math:`x_{i+1}`
+  :returns: :math:`x_{i}`
  
  .. math ::
-    x_{i+1} = x_i + \Delta x
+    x_{i,j=0} = x_{i}
  
-  .. seealso::
-    :meth:`dxdt_Dt` for :math:`\Delta x`
+  .. math ::
+    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
-  for j in range(max_iterations):  # Fixed-point iteration
-    Dx = array(f(xi, t, *p))
-    xi1 = x0 + Dx       # Approximate solution at next value of x
-    residuum = norm(xi1-xi)/norm(xi1)
-    xi = xi1
+  xij = xi
+  for j in range(max_iterations):
+    dxdt = array(f(xij, ti1, *p))
+    # Approximate solution at next value of x
+    xij1 = xi + dxdt * (ti1-ti)
+    residuum = norm(xij1-xij)/norm(xij1)
+    xij = xij1
    if residuum < tol:
      break
  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):
-  iterations = zeros((len(t), 1))
-  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):
+def i1(f, x0, t, *p, max_iterations=1000, tol=1e-9,
+  verbose=False):
  r"""Implicite first-order method / backward Euler method.

  :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
  :param t: time
  :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
  :type max_iterations: int
  :param tol: tolerance against residuum (default = 1e-9)
@@ -264,25 +272,23 @@ def i1(f, x0, t, *p, max_iterations=1000, tol=1e-9, verbose=False):
  iterations = zeros((len(t), 1))
  x = zeros((len(t), len(x0)))     # Preallocate array
  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):
    Dt = t[i+1]-t[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
-    # available therefor using Newton-Raphson method
-    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
+    xi, iteration = fpi(f, xi, t[i], t[i+1], *p, max_iterations,
+      tol, verbose)
    x[i+1,:] = xi
+    iterations[i] = iteration
  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

-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.

  :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
  :param t: time
  :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)
  :type gamma: float
  :param beta: newmark parameter for displacement (default = 0.25)
@@ -326,7 +333,8 @@ def newmark_newtonraphson(f, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max_itera
    j = 0
    for j in range(max_iterations):  # Fixed-point iteration
      #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(),
        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')
        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 )
      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()
    x[i+1,:] = x1.reshape(-1,).tolist()
  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
  # 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.

  :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
  :param t: time
  :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)
  :type gamma: float
  :param beta: newmark parameter for displacement (default = 0.25)
@@ -388,7 +400,8 @@ def newmark_newtonraphson_rdk(fnm, x0, xp0, xpp0, t, *p, gamma=.5, beta=.25, max
  for i in range(len(t)-1):
    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)
    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
    xpp1 = xppi
    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))
-      #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 
-      rp = f - (rm + dot(rmx, (Dt*xpi+Dt**2./4*xppi)) - dot(rmxpp, xppi) + \
-                rd + dot(rdx, (Dt*xpi+Dt**2./4*xppi)) + dot(rdxp, Dt/2*xppi) + \
+      rp = f - (rm + dot(rmx, (Dt*xpi+Dt**2./4*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)) )
      xpp11 = dot(inv(r), rp)
      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()
    x[i+1,:] = x1.reshape(-1,).tolist()
  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
  # x = concatenate((x, xp, xpp), axis=1)
--- a/src/time_of_day.py
+++ b/src/time_of_day.py
@@ -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)
+  
--- a/tests/test_time_of_day.py
+++ b/tests/test_time_of_day.py
@@ -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()